Is 'auto const' and 'const auto' the same?

Analysis

• auto: This is a type deduction keyword used to let the compiler automatically infer the variable's type.
• const: This is a type modifier used to specify that the variable's value cannot be modified.

Regardless of whether const appears before or after auto, the result is the same: declaring an immutable variable whose type is inferred by the compiler.

Examples

Suppose we have a function that returns an integer:

cpp
int getValue() {
    return 5;
}

Examples of declaring variables with auto const or const auto are as follows:

cpp
auto const a = getValue();  // a's type is inferred as int, and a is constant
const auto b = getValue();  // b's type is inferred as int, and b is constant

In both cases, a and b are constant integers, whose values are set during initialization by getValue() and cannot be modified afterward.

Conclusion

Although syntactically they can be interchanged, choosing one and maintaining consistency is a good programming practice, which improves code readability and maintainability. Typically, it is more common to place const first (i.e., const auto), making it more intuitive to see that the variable is constant. In C++, both auto const and const auto are used to declare variables with constant properties, but the order of modifiers can lead to subtle differences in understanding, especially when declaring pointer types. However, for ordinary variables, these forms are equivalent.

1. Ordinary Variables

For non-pointer variables, auto const and const auto are identical. For example:

cpp
auto const a = 10; // const int a = 10;
const auto b = 10; // const int b = 10;

In both declarations, a and b are constant integers, and their values cannot be changed.

2. Pointer Variables

When dealing with pointers, the differences between auto const and const auto become apparent. This is because the position of const determines whether it modifies the pointer itself or the data it points to.

cpp
int x = 10;
int y = 20;

auto const* p = &x; // p is a pointer to const int, meaning the integer pointed to cannot be modified
const auto* q = &x; // q is also a pointer to const int, similarly the integer pointed to cannot be modified

auto* const r = &x; // r is a const pointer to int, meaning r itself cannot point to other addresses, but the integer it points to can be modified

• In the examples of p and q, both auto const* and const auto* apply the const modifier to int (i.e., the object being pointed to), so they are equivalent.
• The example with r does not apply const auto or auto const, but it demonstrates how to make the pointer itself constant, which is the effect of placing const after *.

Summary

In most cases, especially when not dealing with complex pointer declarations, auto const and const auto are equivalent, both declaring the variable as constant. However, when dealing with pointers, understanding the position of const is crucial for correctly applying the const modifier. In practical programming, maintaining a consistent declaration style can help reduce confusion and errors.