Type Aliases

Type Aliases with Const and Volatile

How do type aliases interact with const and volatile qualifiers?

Illustration representing computer hardware

Type aliases interact with const and volatile qualifiers in interesting ways. Understanding these interactions is crucial for writing correct and maintainable C++ code. Let's explore this topic with some examples.

Basic Interaction

When you create a type alias, you can add const and volatile qualifiers to it, or to the underlying type:

1#include <iostream>
2
3using Integer = int;
4using ConstInteger = const int;
5
6int main() {
7  Integer i{42};
8  ConstInteger ci{10};
9
10  // OK
11  i = 100; 
12
13  // Error: assignment of read-only variable ci
14  ci = 20;  
15
16  // This is equivalent to 'const int ci2{30};
17  const Integer ci2{30};
18  
19  // Error: assignment of read-only variable ci2
20  ci2 = 40; 
21}

1error: 'ci': you cannot assign to a variable that is const
2error: 'ci2': you cannot assign to a variable that is const

Pointers and References

Things get more interesting with pointers and references:

1using IntPtr = int*;
2using ConstIntPtr = const int*;
3using IntConstPtr = int* const;
4
5int main() {
6  int value{42};
7  IntPtr p1{&value};
8  ConstIntPtr p2{&value};
9  IntConstPtr p3{&value};
10
11  *p1 = 10;  // OK 
12  
13  // Error: assignment of read-only location
14  *p2 = 20;  
15
16  *p3 = 30;  // OK 
17
18  int anotherValue{100};
19  p1 = &anotherValue;  // OK
20  p2 = &anotherValue;  // OK
21  
22  // Error: assignment of read-only variable 'p3'
23  p3 = &anotherValue;  
24}

1error: 'p2': you cannot assign to a variable that is const
2error: 'p3': you cannot assign to a variable that is const

In this example:

IntPtr is a pointer to int
ConstIntPtr is a pointer to const int (can't modify the pointed-to value)
IntConstPtr is a const pointer to int (can't change what it points to)

Adding Qualifiers to Aliases

You can add qualifiers to type aliases:

1using Integer = int;
2
3int main() {
4  // Equivalent to const int ci{42};
5  const Integer ci{42};
6
7  // Equivalent to volatile int vi{10};
8  volatile Integer vi{10};
9
10  // Error: assignment of read-only variable 'ci'
11  ci = 100; 
12  
13  // OK, but compiler won't optimize access to 'vi'
14  vi = 20;
15}

1error: 'ci': you cannot assign to a variable that is const

Templates and Type Aliases

Type aliases can be particularly useful with templates:

1#include <iostream>
2#include <vector>
3
4template <typename T>
5using ConstRef = const T&;
6
7int main() {
8  std::vector<int> vec{1, 2, 3};
9
10  ConstRef<std::vector<int>> constVecRef = vec;
11
12  // Error: 'constVecRef' is read-only
13  constVecRef.push_back(4);
14
15  for (ConstRef<int> element : constVecRef) {
16    std::cout << element << ' ';
17  }
18}

1error: 'push_back()': cannot convert from 'const std::vector<int>' to 'std::vector<int>'
2note: Conversion loses qualifiers

In this example, ConstRef<T> is an alias template for a const reference to T.

Understanding these interactions allows you to write more expressive and type-safe code. Remember, type aliases don't create new types - they're just new names for existing types. This means that the const and volatile qualifiers behave exactly as they would with the original types.

This Question is from the Lesson: