0

可能重复：
防止非 const 左值解析为右值引用而不是 const 左值引用
复制构造函数和转发构造函数之间的冲突

我有存储 std::unique_ptr 所需的这些类（改编的 boost::any）：

class any
{
public:
  any()
    : content(0)
  {
  }

  any(any const&) = delete;

  any(any && other)
    : content(other.content)
  {
    content = 0;
  }

  template<typename ValueType>
  any(ValueType const& value)
    : content(new holder<ValueType>(value))
  {
  }

  template<typename ValueType>
  any(ValueType && value,
    typename std::enable_if<!std::is_lvalue_reference<ValueType>::value,
    void>::type* = 0)
    : content(new holder<ValueType>(std::move(value)))
  {
  }

  ~any()
  {
    delete content;
  }

public: // modifiers

  any & swap(any & rhs)
  {
    std::swap(content, rhs.content);
    return *this;
  }

  any & operator=(const any &) = delete;

  any & operator=(any && rhs)
  {
    return swap(rhs);
  }

  template<typename ValueType>
  any & operator=(ValueType const& rhs)
  {
    any(rhs).swap(*this);
    return *this;
  }

  template<typename ValueType>
  typename std::enable_if<!std::is_lvalue_reference<ValueType>::value,
    any&>::type operator=(ValueType && rhs)
  {
    any(std::move(rhs)).swap(*this);
    return *this;
  }

public: // queries

  bool empty() const
  {
    return !content;
  }

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

private: // types

  class placeholder
  {
  public: // structors

  virtual ~placeholder()
  {
  }

  public: // queries
    virtual const std::type_info & type() const = 0;
  };

  template<typename ValueType>
  class holder : public placeholder
  {
  public: // structors
    template <class T>
    holder(T && value)
      : held(std::forward<T>(value))
    {
    }

    holder & operator=(const holder &) = delete;

  public: // queries
    virtual const std::type_info & type() const
    {
      return typeid(ValueType);
    }

  public:

    ValueType held;
  };

private: // representation

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

  template<typename ValueType>
  friend ValueType * unsafe_any_cast(any *);

  placeholder * content;
};

这个测试用例：

any a;
any b(a);

b = a;

和这个：

std::map<int, int> map({{1,1},{2,2}});
any b(map);
std::cout << map.size() << std::endl; // displays 0

令我恐惧的是，在 gdb 下，我注意到在构造和分配b（甚至从地图）时调用了移动构造函数和移动赋值运算符，即使我没有标记a并且std::move它不是临时的。有人可以解释为什么吗？

4

1 回答 1

0

我的第一个答案是错误的。再次阅读您非常不可读的代码后，我看到您明确提供了移动和默认构造函数，但没有复制构造函数。如果一个类有任何用户定义的构造函数（你有两个），编译器将不会为该类生成任何其他构造函数。因此，您的类没有复制构造函数。

编辑：所以，回到我原来的答案（由您的评论提示）。§12.8/7 [class.copy] 说：

永远不会实例化成员函数模板来执行将类对象复制到其类类型的对象。[例子：

struct S { 
    template<typename T> S(T); 
    template<typename T> S(T&&);
    S(); 
}; 

S f(); 
const S g; 

void h() { 
    S a( f() );          // does not instantiate member template; 
                         // uses the implicitly generated move
    constructor S a(g);  // does not instantiate the member template; 
                         // uses the implicitly generated copy constructor
}

—结束示例]

由于您的复制构造函数是成员模板，但您的移动构造函数不是，因此在此处选择后者（您的情况在这方面与示例不同）。

于 2012-04-13T08:47:59.647 回答