constant – Modern C++

The keyword constexpr is used to show that a constant is resolved at compile time. This is a new keyword introduced with C++11.

Both constexpr and const are used to show that something is constant and the difference is that a constexpr value must be resolved at compile time whereas a const can be resolved at run time or at compile time.

void f()
{
    constexpr double pi = 3.141592; // constant defined at compile time

    constexpr double two_pi = 2.0 * 3.141; // constant calculated by the compiler at compile time. 

    const int some_value = 4; // ok, const can be used for both run time and compile time constants
}

void f()

{

constexpr double pi = 3.141592; // constant defined at compile time

constexpr double two_pi = 2.0 * 3.141; // constant calculated by the compiler at compile time.

const int some_value = 4; // ok, const can be used for both run time and compile time constants

}

In most cases there is no real difference between a compile time or a run time constant but in some cases must the constant be defined at compile time. One example is creating fixed size arrays where the size must be a constant defined at compile time:

void f(const int size)
{
    char userMessage[size];  // does not compile. Run time constant.
}

void g()
{
    const int size = 512;
    char message[size];   // compiles. The size is a compile time constant
}


void h()
{
    int size = 512;
    char message[size];   // does not compile. The size is not constant
}

void f(const int size)

{

char userMessage[size]; // does not compile. Run time constant.

}

void g()

{

const int size = 512;

char message[size]; // compiles. The size is a compile time constant

}

void h()

{

int size = 512;

char message[size]; // does not compile. The size is not constant

}

constexpr can also be used for function calls

int size()
{
   return 5;
}

constexpr int const_size()
{
    return 5;
}

void f()
{
    int data[size() + 1]; // this will not compile, size cannot be resolved by compiler

   int data[const_size() + 1]; // this compiles in C++11, size is compile time constant
}

int size()

{

return 5;

}

constexpr int const_size()

{

return 5;

}

void f()

{

int data[size() + 1]; // this will not compile, size cannot be resolved by compiler

int data[const_size() + 1]; // this compiles in C++11, size is compile time constant

}

However, a constexpr function must only consist of a single return statement, only call constexpr functions and only access constexpr global/member variables.

The purpose of constexpr is to replace macros and hard coded literal values without sacrificing performance or type safety.

The const keyword is used to show both other developers and the compiler that an object is constant and its contents cannot be changed. If you anyway try to change the contents of a const object will generate an error already at compile time. It is a good practice to add the const keyword to a parameter, a members or a method to show that the value is not going to be changed. This can both make the intent of the code more clear to the user, and can make the code faster since the compiler can make certain optimizations knowing that the object is not going to change its value.

The difference between the const keyword and the constexpr keyword is that the value of a constexpr constant must be resolved at compile time whereas the value of a const constant can be resolved at run time (or at compile time).

The const keyword can be used in the following contexts:

Const class

An object can be made constant at creation by declaring the object as const:

const Date christmasDay(2016, 12, 25);

1	const Date christmasDay(2016, 12, 25);

Any attempt to change the contents of the object christmasDay will result in a compiler error:

christmasDay.year = 2017; // This will not compile!

1	christmasDay.year = 2017; // This will not compile!

Const member functions

Adding the const keyword to a member function (added at the end of the function declaration, after the parameters) states that this method will not change the state of the object.

class Date
{
public:
   int m_year;
   int m_month;
   int m_day;

   Date(int y, m, d)
    : m_year(y), m_month(m), m_day(d)
   {
   }
  
   // Sets the year. This cannot be declared as const since it changes the object
   void setYear(int newYear)
   {
      m_year = newYear;
   }
 
   // Gets the year. This is const showing that it does not change the object
   int getYear() const
   {
      return m_year;
   }

   // Gets the month. This is not const even though it does not change the object
   int getMonth()
   {
      return m_month;
   }
};

class Date

{

public:

int m_year;

int m_month;

int m_day;

Date(int y, m, d)

: m_year(y), m_month(m), m_day(d)

{

}

// Sets the year. This cannot be declared as const since it changes the object

void setYear(int newYear)

{

m_year = newYear;

}

// Gets the year. This is const showing that it does not change the object

int getYear() const

{

return m_year;

}

// Gets the month. This is not const even though it does not change the object

int getMonth()

{

return m_month;

}

};

The const keyword after the declaration of the method getYear() shows that calling this method will not change any members of the object. This also means that we are allowed to call this method even if the object is const.

const Date christmasDay(2016, 12, 25);

int y = christmasDay.getYear(); // Ok since getYear() is const

int m = christmasDay.getMonth(); // NOT ok, getMonth is not const. This will not compile!

const Date christmasDay(2016, 12, 25);

int y = christmasDay.getYear(); // Ok since getYear() is const

int m = christmasDay.getMonth(); // NOT ok, getMonth is not const. This will not compile!

Const parameters

Parameters to functions can also be declared as const. There are two positions where the const keyword can be added.

// The input is not const, meaning that the function can change the contents of the data
//  AND it can change the pointer itself (to make it point to something else)
void AFunction(double* pData)
{

}

// The input is const, meaning that the function cannot change the contents of the data
//   BUT it can change the pointer itself.
void SomeFunction(const double* pData)
{

}

// The input is const meaning that the function cannot change the contents of the data
//   NOR can it change what the pointer points to.
void AnotherFunction(const double* const pData)
{

}

// The input is not const, meaning that the function can change the contents of the data

// AND it can change the pointer itself (to make it point to something else)

void AFunction(double* pData)

{

}

// The input is const, meaning that the function cannot change the contents of the data

// BUT it can change the pointer itself.

void SomeFunction(const double* pData)

{

}

// The input is const meaning that the function cannot change the contents of the data

// NOR can it change what the pointer points to.

void AnotherFunction(const double* const pData)

{

}

Tag: constant

The constexpr keyword

The const keyword

Const class

Const member functions

Const parameters