/*constexpr is a keyword in C++ that is used to indicate that a function or variable
is a compile-time constant. This means that its value can be computed at compile-time,
rather than at runtime.

One of the main advantages of using constexpr is that it allows for improved
performance, as the value is known at compile-time, and the compiler can optimize 
the code accordingly. It also allows for more robust code, as it can be used to 
ensure that certain values are known at compile-time, which can help catch errors
early in the development process.

constexpr functions can be used for various purposes like creating compile time 
constants, array sizes, template parameters etc.*/

Computing a compile-time constant:

constexpr double pi = 3.14159265358979323846;
constexpr double area_of_circle(double radius) { return pi * radius * radius; }

int main() {
    constexpr double r = 2.0;
    constexpr double circle_area = area_of_circle(r);
    std::cout << "Area of circle with radius " << r << " is: " << circle_area << std::endl;
    // Output: "Area of circle with radius 2 is: 12.566370614359172"
}

In this example, the constexpr keyword is used to indicate that the 
area_of_circle() function and the pi variable are compile-time constants.
Their values are computed at compile-time and the compiler can optimize the
code accordingly.

Using constexpr for array sizes:

constexpr int array_size = 10;
int arr[array_size];

int main() {
    for (int i = 0; i < array_size; ++i) {
        arr[i] = i;
    }
    // Do something with the array
}

In this example, the constexpr keyword is used to indicate that the array_size
variable is a compile-time constant. This means that the size of the arr array
is known at compile-time, which can help catch errors early in the development
process.

Using constexpr for template parameters:

constexpr int get_size() { return 10; }

template <int size>
struct MyArray {};

int main() {
    MyArray<get_size()> my_array;
    // Do something with the array
}

In this example, constexpr function is used as a template parameter which is 
calculated at compile-time.

In all the examples above, the constexpr variables or function are computed at compile time, which provides better performance and robustness for the code.