从类型的右值初始化类型的非常量引用无效

Question

我正在根据更有效的c++的第28期智能指针编写一些代码如下。但是，它无法编译：

main.cpp: In instantiation of 'SmartPointer<T>::operator SmartPointer<U>() [with U = MusicProduct; T = Cassette]':
main.cpp:99:17:   required from here
main.cpp:48:39: error: invalid initialization of non-const reference of type 'SmartPointer<MusicProduct>&' from an rvalue of type 'SmartPointer<MusicProduct>'
       return SmartPointer<U> (ptr_);
                                   ^
main.cpp:16:9: note:   initializing argument 1 of 'SmartPointer<T>::SmartPointer(SmartPointer<T>&) [with T = MusicProduct]'
     SmartPointer(SmartPointer<T>& other)
     ^

这两个更改中的任何一个都有效：

在operator SmartPointer()的实现中，创建一个对象并return:

智能指针 a(ptr_);

return一个；
或者，将拷贝构造函数的参数设为const

SmartPointer（const SmartPointer& 其他）

并注释行

other.ptr_ = nullptr;

这两种解决方案都有效的原因是什么？谢谢

#include <iostream>

template <typename T>
class SmartPointer
{
  public:
    SmartPointer(T* ptr) : ptr_(ptr) {}
    ~SmartPointer()
    {
      if (ptr_)
      {
        delete ptr_;
      }
    }

    SmartPointer(SmartPointer<T>& other)
    {
      ptr_ = other.ptr_;
      other.ptr_ = nullptr;
    }

    SmartPointer<T>& operator = (SmartPointer<T>& other)
    {
      if (this == &other)
      {
        return *this;
      }

      if (ptr_)
      {
        delete ptr_;
      }

      ptr_ = other.ptr_;
      other.ptr_ = nullptr;

      return *this;
    }

    template <typename U>
    operator SmartPointer<U> ()
    {
      // it works
      //SmartPointer<U> a(ptr_);
      //return a;

      // error
      return SmartPointer<U> (ptr_);
    }

    T& operator * () const
    {
      return *ptr_;
    }

    T* operator -> () const
    {
      return ptr_;
    }

  private:
    T* ptr_ = nullptr;
};

class MusicProduct
{
public:
  MusicProduct(const std::string& name) : name_(name) {}
  virtual ~MusicProduct() {}

  virtual void Play() const = 0;
  virtual void ShowName() const
  {
    std::cout << name_ << std::endl;
  }

private:
  std::string name_;
};
class Cassette : public MusicProduct
{
  public:
  Cassette(const std::string& name) : MusicProduct(name) {}
  void Play () const
  {
    std::cout << "play cassette" << std::endl;
  }
};

void CallPlay(const SmartPointer<MusicProduct>& sp)
{
  sp->Play();
}

int main()
{
  SmartPointer<Cassette> a(new Cassette("Zhang"));
  a->ShowName();
  CallPlay(a);
  return 0;
}

Answer 1

那是因为你的复制构造函数有一个非常量引用参数，因此不能接受一个临时的。于是

return SmartPointer<X>(y);

行不通。 return关键字的参数是临时的，需要复制，所以这里的设计就崩溃了。

由于您使用的是 C++11，因此可以通过引入移动构造函数（和移动赋值）来解决此问题。

您也可以将参数设为 const 并将 ptr_ 成员指定为 mutable。这将允许您从临时指针和 const 智能指针进行复制，但要以实际改变它们为代价。

从类型的右值初始化类型的非常量引用无效

invalid initialization of non-const reference of type from an rvalue of type

c++

rvalue

lvalue