Is it possible to create a unique pointer to a `const` object in C++?

Question

Ryan McCombe · Accepted Answer

Yes, it's absolutely possible to create a std::unique_ptr to a const object in C++. This can be useful when you want to ensure that the object pointed to by the unique pointer cannot be modified through that pointer, while still maintaining the benefits of automatic memory management provided by std::unique_ptr.

Here's how you can create a unique pointer to a const object:

1#include <iostream>
2#include <memory>
3
4int main() {
5  auto constPtr = std::make_unique<const int>(42);  
6
7  std::cout << "Value: " << *constPtr;
8
9  // This would cause a compilation error:
10  // *constPtr = 10; 
11}

1Value: 42

In this example, constPtr is a std::unique_ptr<const int>, pointing to a const int. We can read the value, but we can't modify it through this pointer.

You can also create a const unique pointer to a non-const object:

1#include <iostream>
2#include <memory>
3
4int main() {
5  const auto ptr = std::make_unique<int>(42); 
6
7  std::cout << "Value: " << *ptr << '\n';
8
9  // This would cause a compilation error:
10  // ptr = std::make_unique<int>(10); 
11
12  // But this is allowed:
13  *ptr = 10;
14
15  std::cout << "New value: " << *ptr << '\n';
16}

1Value: 42
2New value: 10

Here, ptr is const (can't be reassigned), but the int it points to isn't const (can be modified).

You can even have a const unique pointer to a const object:

1#include <iostream>
2#include <memory>
3
4int main() {
5  const auto constPtr =
6      std::make_unique<const int>(42);  
7
8  std::cout << "Value: " << *constPtr;
9
10  // These would cause compilation errors:
11  // constPtr =  std::make_unique<const int>(10); 
12  // *constPtr = 10; 
13}

1Value: 42

In this case, neither the pointer nor the pointed-to object can be modified.

Remember, const-correctness is a powerful tool in C++ for preventing unintended modifications and communicating intent in your code. Using const with unique pointers allows you to leverage both the safety of const and the automatic memory management of smart pointers.

When working with classes, const unique pointers are particularly useful:

1#include <iostream>
2#include <memory>
3#include <string>
4
5class Character {
6public:
7  Character(std::string name)
8    : name(std::move(name)) {}
9
10  std::string getName() const { return name; }
11
12  void rename(const std::string& newName) {
13    name = newName;
14  }
15
16private:
17  std::string name;
18};
19
20int main() {
21  auto constCharPtr =
22    std::make_unique<const Character>("Frodo");
23
24  std::cout << "Name: " << constCharPtr->getName();
25
26  // This would cause a compilation error:
27  // constCharPtr->rename("Gandalf"); 
28}

1Name: Frodo

In this example, constCharPtr is a unique pointer to a const Character. We can call const member functions like getName(), but we can't call non-const member functions like rename().

Memory Ownership and Smart Pointers

Unique Pointers to Const Objects

Memory Ownership and Smart Pointers

Intro to C++ Programming

Questions & Answers