Implementation of std::any

Question

Today, I decided to implement std::any using the cppreference page. I've never actually used std::any before and after seeing the implementation first hand... I don't think I'll start now! I'm not entirely sure what this class is actually meant for. I'm not even sure why I implemented this in the first place...

Anyway, here's the code:

#include <memory>
#include <utility>
#include <typeinfo>

namespace mystd {

template <typename T>
struct is_in_place_type : std::false_type {};

template <typename T>
struct is_in_place_type<std::in_place_type_t<T>> : std::true_type {};

class any {
  template <typename ValueType>
  friend const ValueType *any_cast(const any *) noexcept;

  template <typename ValueType>
  friend ValueType *any_cast(any *) noexcept;

public:
  // constructors

  constexpr any() noexcept = default;

  any(const any &other) {
    if (other.instance) {
      instance = other.instance->clone();
    }
  }

  any(any &&other) noexcept
    : instance(std::move(other.instance)) {}

  template <typename ValueType, typename = std::enable_if_t<
    !std::is_same_v<std::decay_t<ValueType>, any> &&
    !is_in_place_type<std::decay_t<ValueType>>::value &&
    std::is_copy_constructible_v<std::decay_t<ValueType>>
  >>
  any(ValueType &&value) {
    static_assert(std::is_copy_constructible_v<std::decay_t<ValueType>>, "program is ill-formed");
    emplace<std::decay_t<ValueType>>(std::forward<ValueType>(value));
  }

  template <typename ValueType, typename... Args, typename = std::enable_if_t<
    std::is_constructible_v<std::decay_t<ValueType>, Args...> &&
    std::is_copy_constructible_v<std::decay_t<ValueType>>
  >>
  explicit any(std::in_place_type_t<ValueType>, Args &&... args) {
    emplace<std::decay_t<ValueType>>(std::forward<Args>(args)...);
  }

  template <typename ValueType, typename List, typename... Args, typename = std::enable_if_t<
    std::is_constructible_v<std::decay_t<ValueType>, std::initializer_list<List> &, Args...> &&
    std::is_copy_constructible_v<std::decay_t<ValueType>>
  >>
  explicit any(std::in_place_type_t<ValueType>, std::initializer_list<List> list, Args &&... args) {
    emplace<std::decay_t<ValueType>>(list, std::forward<Args>(args)...);
  }

  // assignment operators

  any &operator=(const any &rhs) {
    any(rhs).swap(*this);
    return *this;
  }

  any &operator=(any &&rhs) noexcept {
    any(std::move(rhs)).swap(*this);
    return *this;
  }

  template <typename ValueType>
  std::enable_if_t<
    !std::is_same_v<std::decay_t<ValueType>, any> &&
    std::is_copy_constructible_v<std::decay_t<ValueType>>,
    any &
  >
  operator=(ValueType &&rhs) {
    any(std::forward<ValueType>(rhs)).swap(*this);
    return *this;
  }

  // modifiers

  template <typename ValueType, typename... Args>
  std::enable_if_t<
    std::is_constructible_v<std::decay_t<ValueType>, Args...> &&
    std::is_copy_constructible_v<std::decay_t<ValueType>>,
    std::decay_t<ValueType> &
  >
  emplace(Args &&... args) {
    auto new_inst = std::make_unique<storage_impl<std::decay_t<ValueType>>>(std::forward<Args>(args)...);
    std::decay_t<ValueType> &value = new_inst->value;
    instance = std::move(new_inst);
    return value;
  }

  template <typename ValueType, typename List, typename... Args>
  std::enable_if_t<
    std::is_constructible_v<std::decay_t<ValueType>, std::initializer_list<List> &, Args...> &&
    std::is_copy_constructible_v<std::decay_t<ValueType>>,
    std::decay_t<ValueType> &
  >
  emplace(std::initializer_list<List> list, Args &&... args) {
    auto new_inst = std::make_unique<storage_impl<std::decay_t<ValueType>>>(list, std::forward<Args>(args)...);
    std::decay_t<ValueType> &value = new_inst->value;
    instance = std::move(new_inst);
    return value;
  }

  void reset() noexcept {
    instance.reset();
  }

  void swap(any &other) noexcept {
    std::swap(instance, other.instance);
  }

  // observers

  bool has_value() const noexcept {
    return static_cast<bool>(instance);
  }

  const std::type_info &type() const noexcept {
    return instance ? instance->type() : typeid(void);
  }

private:
  struct storage_base;

  std::unique_ptr<storage_base> instance;

  struct storage_base {
    virtual ~storage_base() = default;

    virtual const std::type_info &type() const noexcept = 0;
    virtual std::unique_ptr<storage_base> clone() const = 0;
  };

  template <typename ValueType>
  struct storage_impl final : public storage_base {
    template <typename... Args>
    storage_impl(Args &&... args)
      : value(std::forward<Args>(args)...) {}

    const std::type_info &type() const noexcept override {
      return typeid(ValueType);
    }

    std::unique_ptr<storage_base> clone() const override {
      return std::make_unique<storage_impl<ValueType>>(value);
    }

    ValueType value;
  };
};

} // mystd

template <>
void std::swap(mystd::any &lhs, mystd::any &rhs) noexcept {
  lhs.swap(rhs);
}

namespace mystd {

class bad_any_cast : public std::exception {
public:
  const char *what() const noexcept {
    return "bad any cast";
  }
};

// C++20
template <typename T>
using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;

// any_cast

template <typename ValueType>
ValueType any_cast(const any &anything) {
  using value_type_cvref = remove_cvref_t<ValueType>;
  static_assert(std::is_constructible_v<ValueType, const value_type_cvref &>, "program is ill-formed");
  if (auto *value = any_cast<value_type_cvref>(&anything)) {
    return static_cast<ValueType>(*value);
  } else {
    throw bad_any_cast();
  }
}

template <typename ValueType>
ValueType any_cast(any &anything) {
  using value_type_cvref = remove_cvref_t<ValueType>;
  static_assert(std::is_constructible_v<ValueType, value_type_cvref &>, "program is ill-formed");
  if (auto *value = any_cast<value_type_cvref>(&anything)) {
    return static_cast<ValueType>(*value);
  } else {
    throw bad_any_cast();
  }
}

template <typename ValueType>
ValueType any_cast(any &&anything) {
  using value_type_cvref = remove_cvref_t<ValueType>;
  static_assert(std::is_constructible_v<ValueType, value_type_cvref>, "program is ill-formed");
  if (auto *value = any_cast<value_type_cvref>(&anything)) {
    return static_cast<ValueType>(std::move(*value));
  } else {
    throw bad_any_cast();
  }
}

template <typename ValueType>
const ValueType *any_cast(const any *anything) noexcept {
  if (!anything) return nullptr;
  auto *storage = dynamic_cast<any::storage_impl<ValueType> *>(anything->instance.get());
  if (!storage) return nullptr;
  return &storage->value;
}

template <typename ValueType>
ValueType *any_cast(any *anything) noexcept {
  return const_cast<ValueType *>(any_cast<ValueType>(static_cast<const any *>(anything)));
}

// make_any

template <typename ValueType, typename... Args>
any make_any(Args &&... args) {
  return any(std::in_place_type<ValueType>, std::forward<Args>(args)...);
}

template <typename ValueType, typename List, typename... Args>
any make_any(std::initializer_list<List> list, Args &&... args) {
  return any(std::in_place_type<ValueType>, list, std::forward<Args>(args)...);
}

} // mystd

I'm thinking about doing this in C++11 without rigorously adhering to the standard and without RTTI. Maybe another day...

Answer 1

Your implementation is excellent! I can hardly find any problems. I was amazed how simple a conforming implementation of any can be. And I wholeheartedly agree with @papagaga's comment.

Here's my two cents. I use the N4659, the C++17 final draft, as a reference.

Non-conformance (priority: high)

1. Thou Shalt Not Specialize std::swap. Instead, you should overload swap to be found by ADL. See How to overload std::swap() on Stack Overflow.

   class any {
   public:
     // ...
     friend void swap(any& lhs, any& rhs)
     {
       lhs.swap(rhs);
     }
   };
   

2. [any.bad_any_cast]/2 specifies that bad_any_cast should derive from std::bad_cast. Your implementation fails to do this.

Other suggestions (priority: low)

1. [any.class]/3 says:

   Implementations should avoid the use of dynamically allocated memory for a small contained value. [ Example: where the object constructed is holding only an int. — end example ] Such small-object optimization shall only be applied to types T for which is_nothrow_move_constructible_v<T> is true.

   Clearly, you did not implement this optimization.

2. Initially I thought, "where is your destructor?" Then I realized that the synthesized destructor is equivalent to reset(). I recommend you explicitly default this to reduce confusion since you implemented the rest of the Big Five.

   ~any() = default;
   

3. The following static_assert on line 40 is unnecessary:

   static_assert(std::is_copy_constructible_v<std::decay_t<ValueType>>, "program is ill-formed");
   

   because this constructor does not participate in overload resolution unless std::is_copy_constructible_v<std::decay_t<ValueType>>.

Answer 2

It is good exercise to try to implement std features yourself. But if you want an elegant implementation of any, check boost::any. It has a very readable code and implements both: small value optimization & RTTI without built-in support(i.e. not using virtual nor typeid keywords). More interestingly, there is a boost::anys::basic_any template class who enables you to decide how big the small values to optimize can be.

regards,

FM.