Unconstrained Dynamic Types using Void Pointers and std::any

The main way C++ represents a pointer to potentially any type of data is a void pointer. The syntax looks similar to any other pointer - the type it's pointing to is simply void:

1void* Ptr;

We assign a memory address to such a pointer in the usual way. We can assign a memory address for any data type to a void*.

Below, our Ptr points first at an int, and then gets reassigned to point to a float:

1int main(){
2  int SomeInt{42};
3  void* Ptr{&SomeInt};
4
5  float SomeFloat{9.8f};
6  Ptr = &SomeFloat;
7}

Null Void Pointers

Similar to any other pointer type, void pointers can be initialized or updated to nullptr. This is used to represent the absence of a value, which can be tested for by treating the pointer as a boolean:

1#include <iostream>
2
3int main(){
4  void* Ptr{nullptr};
5  if (!Ptr) { std::cout << "Empty"; }
6}

1Empty

Accessing Void Pointer Values

We cannot directly dereference a void pointer. To access the value it is pointing at, we need to first cast the void pointer to match the underlying type:

1#include <iostream>
2
3int main(){
4  int SomeInt{42};
5  void* Ptr{&SomeInt};
6
7  int* IntPtr{static_cast<int*>(Ptr)};
8  std::cout << "Data: " << *IntPtr;
9}

1Data: 42

Type Safety: The Problem with Void Pointers

Similar to unions, which we introduced in the previous lesson, void pointers offer very little type safety.

It is on us to keep track of what type our void* is pointing at. In a larger program, that bookkeeping can be complicated.

And most importantly, if we get it wrong, the compiler won't tell us. Our program will simply have a bug that could have serious implications:

1#include <iostream>
2
3template <typename T>
4void Log(void* Data){
5  T* Ptr{static_cast<T*>(Data)};
6  std::cout << "Data: " << *Ptr << '\n';
7}
8
9int main(){
10  int SomeInt{42};
11  void* Ptr{&SomeInt};
12  Log<int>(Ptr);
13
14  float SomeFloat{3.14};
15  Ptr = &SomeFloat;
16  Log<int>(Ptr);
17}

1Data: 42
2Data: 1078523331

Because of this, using void pointers directly is quite dangerous. It's generally recommended to wrap the concept in an intermediate container that provides some additional type safety.

In C++17, the standard library introduced an implementation of this concept: std::any

The std::any type is available within the <any> header and can be constructed in the usual ways.

Below, we create a container that is initially storing a type of int, and a value of 42:

1#include <any>
2
3int main(){
4  std::any Data{42};
5}

Using std::make_any()

We also have access to the std::make_any() function. It receives the type we want to construct as a template argument, and a list of function arguments to forward to that type's constructor. It then returns a std::any initialized with that object.

1#include <any>
2
3struct Vec3 {
4  float x;
5  float y;
6  float z;
7};
8
9int main(){
10  auto Data{std::make_any<Vec3>(1.f, 2.f, 3.f)};
11}

The reason for this function is similar to the rationale behind the smart pointer generators like std::make_unique and std::make_shared.

It mitigates some potential memory leaks with constructors that can throw exceptions. Compilers can additionally make small optimizations if the std::any and the object it contains can be constructed at the same time.

There are three main ways we can update the value contained within a std::any

Assignment using =

The simple assignment operator, =, works as we'd expect. Naturally, the type we're assigning doesn't need to match the current type the std::any is holding:

1#include <any>
2
3int main(){
4  std::any Data { 42 };
5  Data = 3.14f;
6}

Constructing in place using emplace()

When we want to simultaneously construct and assign an object to the std::any, we should use the emplace() function. This has the same rationale as the emplace() method in other container types.

Specifically, for non-trivial types, constructing an object in place is more efficient than constructing it outside of the container and then moving it in.

The std::any's emplace() method accepts the type we want to construct as a template argument, and the parameters to forward to that type's constructor as function arguments:

1#include <any>
2
3struct Vec3 {
4  float x;
5  float y;
6  float z;
7};
8
9int main(){
10  std::any Data{42};
11  Data.emplace<Vec3>(1.f, 2.f, 3.f);
12}

Deleting values using reset()

We can destroy the object held by a std::any using the reset() method:

1#include <iostream>
2#include <any>
3
4struct Vec3 {
5  float x;
6  float y;
7  float z;
8  ~Vec3(){ std::cout << "Destructor"; }
9};
10
11int main(){
12  auto Data{std::make_any<Vec3>(1.f, 2.f, 3.f)};
13  Data.reset();
14  std::cout << "\nBye!";
15}

1Destructor
2Bye!

Similar to void pointers, we need to do some additional work before we can access values stored in a std::any

Using has_value()

std::any can be initialized without a value, or we can delete their value using the reset() method. The has_value() method returns a boolean, letting us check if the container is currently holding a value:

1#include <iostream>
2#include <any>
3
4int main(){
5  std::any Data{42};
6  if (Data.has_value()) {
7    std::cout << "I have a value";
8  }
9
10  Data.reset();
11  if (!Data.has_value()) {
12    std::cout << "\nbut not any more";
13  }
14}

1I have a value
2but not any more

Using std::any_cast()

To access the value stored in a std::any, we pass it to the std::any_cast() function, passing the type we expect to receive as a template argument:

1#include <iostream>
2#include <any>
3
4int main(){
5  std::any Data{42};
6
7  std::cout << "Value: "
8    << std::any_cast<int>(Data);
9}

1Value: 42

The std::bad_any_cast Exception Type

Unlike void pointers, std::any provides type safety at this point. If the type we provide as a template argument is not the type the std::any is currently storing, we get an exception.

Specifically, it's a std::bad_any_cast exception, which we can detect and react to in the usual way:

1#include <iostream>
2#include <any>
3
4int main(){
5  std::any Data{42};
6
7  try { std::any_cast<float>(Data); }
8  catch (const std::bad_any_cast& e) {
9    std::cout << "That wasn't a float!";
10  }
11}

1That wasn't a float!

We can get the type currently being stored by a std::any using the type() method.

This will be returned as a std::type_info. We can use the typeid() operator to compare this to other types:

1#include <iostream>
2#include <any>
3
4int main(){
5  std::any Data{42};
6
7  if (Data.type() == typeid(int)) {
8    std::cout << "We have an int over here";
9  }
10}

1We have an int over here

If the container is empty, the object returned by type() will be equal to typeid(void):

1#include <any>
2#include <iostream>
3
4int main(){
5  std::any Data;
6
7  if (Data.type() == typeid(void)) {
8    std::cout << "It's empty";
9  }
10}

1It's empty

We covered std::type_info and the typeid() operator in detail in a dedicated lesson earlier in the course:

In this lesson, we introduced two ways of managing fully dynamic types in C++: void pointers and std::any. The std::any container provides a safer, standardized alternative to void*, but unconstrained dynamic types should still be used sparingly

Here are the key takeaways:

• C++ is statically typed, but sometimes unconstrained dynamic types are needed,
• Void pointers (void*) allow pointing to data of any type, but provide no type safety
• std::any, introduced in C++17, is a type-safe container for single values of any type
• std::any can be created by directly specifying a value, or using std::make_any()
• Values in std::any can be updated by assignment, emplaced with emplace<SomeType>(), or reset with reset()
• Accessing values requires std::any_cast<SomeType>(), which throws std::bad_any_cast if the types mismatch
• The type stored in a std::any can be checked at runtime using the type() method and compared to another type using the typeid() operator