C++17: std::any

When trying to implement something that will store a data value of an unknown type (in order to be as generic as possible, for example), we had these possibilities before C++17:

  • Having a void* pointer to something that will be assigned in runtime. The problem with this approach is that you leave the complete responsability of handling the lifetime of the thing poìnted by this void pointer to the user of our code. Very error prone.
  • Having a union with a limited set of types available.
  • Having a base class (e.g. Object) and store pointers to instances derived from such class (à la Java).
  • Having an instance of template typename T (for example). Good approach, but in order to be useful and generic, we need to propagate the typename T in all the generic code that will use ours. Probably verbose.

So, let’s welcome to std::any.

std::any, as you already guess it, is a template class shipped in C++17 and implemented in <any> that can store a value of any type, so, these lines are completely valid:

std::any a = 123;
std::any b = "Hello";
std::any c = std::vector<int>{10, 20, 30};

Obviously, this is C++ and you, as user, need to know the type of the thing you stored in an instance of std::any, so, to retrieve the value stored, you need to perform an any_cast as in this code:

#include <any>
#include <iostream>

int main()
    std::any number = 150;
    std::cout << std::any_cast<int>(number) << "\n";

If you try to cast the value stored in an instance of std::any, a std::bad_any_cast exception is thrown. For example, if you try to cast that number to a string, you will get this runtime error:

terminate called after throwing an instance of 'std::bad_any_cast'
  what():  bad any_cast

If the value stored in an instance of std::any is an instance of a class or struct, the compiler will make sure the destructor of such value will be invoked when the instance of std::any will go out of scope.

Other really nice thing about std::any is that you can replace the existing value stored in an instance of it, for other value of any other type, for example:

std::any content = 125;
std::cout << std::any_cast<int>(content) << "\n";

content = std::string{"Hello world"};
std::cout << std::any_cast<std::string>(content) << "\n";

About lifetimes

Let’s consider this class:

struct A
  int n;
  A(int n) : n{n} { std::cout << "Constructor\n"; }
  ~A() { std::cout << "Destructor\n"; }
  A(A&& a) : n{a.n} { std::cout << "Move constructor\n"; }
  A(const A& a) : n{a.n} { std::cout << "Copy constructor\n"; }
  void print() const { std::cout << n << "\n"; }

This class stores an int, and print it out with “print”. I wrote constructor, copy constructor, move constructor and destructor with messages that will tell me when the object will be created, copied, moved or destroyed.

So, let’s create a std::any instance with an instance of this class:

std::any some = A{4516};

This will be the output of such code:

Move constructor

Why two constructors and two destructors are invoked if I only created one instance?

Because the instance of std::any will store a copy (ok, in this case a “moved version”) of the original object I created and, though in my example can be trivial, in a complex object it cannot be.

How to avoid this problem?

Using std::make_any.

std::make_any is very similar to std::make_shared in the way that it will be in charge to create the object instead of copying/moving ours. The parameters passed to std::make_any are the ones you would pass to the object’s constructor.

So, I can modify my code to this:

auto some = std::make_any<A>(4517);

And the output will be:


Now, I want to invoke to the method “print”:

auto some = std::make_any<A>(4517);

And when I do that, the output is:

Copy constructor

Why such extra copy was created?

Because std::any_cast<A> returns a copy of the given object. If I want to avoid a copy and use a reference, I need to explicit a reference in std::any_cast, something like:

<code>auto some = std::make_any<A>(4517);

And the output will be:


It is also possible to use std::any_cast<T> passing a pointer to an instance of std::any instead of a reference.

In such case, if the cast is possible, will return a valid pointer to a T* object, otherwise it will return a nullptr. For example:

auto some = std::make_any(4517);
std::cout << std::any_cast<int>(&some) << "\n";

In this case, notice I am passing a pointer to “some” instead of a reference. When this occurs, the implementation returns a pointer to the target type if the object stored is of the same type (as in the second line) or a null pointer if noy (as in the third line, where I am trying to cast my object of type A to int). Using these overloaded version with pointers avoids to raise an exception and lets you check if the returned pointer is null instead.

std::any is a very nice tool to store things that we, as implementors of something reusable, do not know a priori; it could be used to store for example, extra parameters passed to threads, objects of any type stored as extra information in UI widgets (similar to the .Tag property in Windows.Forms.Control in .NET, for example), etc. Performance wise, std::any needs to store things in the heap and also needs to perform some extra checking to return the values only if the cast is valid, so, it is not as fast as having a generic object known at compile time.