3

我想要一个包含引用的对象，并将该对象放入向量中......

我必须在要推入向量的任何对象中使用智能指针而不是成员引用吗？这就是我想做的：

#include <string>
#include <vector>
using namespace std;

class MyClass {
   public:
    MyClass(const string& str_ref);    //constructor
        MyClass(const MyClass& mc);        //copy constructor
   private:
        string& my_str;
};

MyClass::MyClass(const string& str_ref) :
    my_str(str_ref)
{}

MyClass::MyClass(const MyClass& mc) :
    my_str(mc.my_str)
{}


int main() {

    //create obj and pass in reference
    string s = "hello";
    MyClass my_cls(s);

    //put into vector
    vector<MyClass> vec;
    vec.push_back(my_cls);

    return 0;
}

//Throws Error
//ref.cpp:6:7: error: non-static reference member ‘std::string& MyClass::my_str’, can’t use default assignment operator

但是它说我需要实现我自己的 operator=() 因为默认生成的不是有效的，但是当然，没有合法的方法可以这样做......

#include <string>
#include <vector>
using namespace std;

class MyClass {
   public:
    MyClass(const string& str_ref);    //constructor
        MyClass(const MyClass& mc);        //copy constructor

        MyClass operator=(const MyClass& mc);      //operator =

   private:
        string& my_str;
};

MyClass::MyClass(const string& str_ref) :
    my_str(str_ref)
{}

MyClass::MyClass(const MyClass& mc) :
    my_str(mc.my_str)
{}

//not a constructor. should not construct new object
//and return that?
MyClass MyClass::operator=(const MyClass& mc) {
   if (this != &mc) {                 //test for self-assignment.
    my_str(mc.my_str);            //can't reseat refs. this shouldn't work.
   }

   return *this;
}

int main() {

    //create obj and pass in reference
    string s = "hello";
    MyClass my_cls(s);

    //put into vector
    vector<MyClass> vec;
    vec.push_back(my_cls);

    return 0;
}

//THROWS:
//ref2.cpp: In constructor ‘MyClass::MyClass(const string&)’:
//ref2.cpp:18:19: error: invalid initialization of reference of type ‘std::string& {aka //std::basic_string<char>&}’ from expression of type ‘const string {aka const //std::basic_string<char>}’
//ref2.cpp: In member function ‘MyClass MyClass::operator=(const MyClass&)’:
//ref2.cpp:29:18: error: no match for call to ‘(std::string {aka std::basic_string<char>}) //(std::string&)’

那么我是否被迫在这里使用智能指针或引用以外的任何东西？

编辑：这是一个简化。String& 不是被传递的对象，它是一个更复杂的对象，它本身包含一个向量对象。

4

3 回答 3

6

您可以在此处存储原始指针而不是引用。原始指针可以重新定位，因此它们是在 C++ 中模拟可重新定位引用的好方法。

class MyClass
{
public:
  MyClass(const string& str_ref);
  MyClass(const MyClass& mc);
  // by the way, operator= should return a reference
  MyClass& operator=(const MyClass& mc);
private:
  string* my_str;
};

这样，operator=实施起来就轻而易举了。

于 2012-02-04T15:53:53.260 回答
5

怎么用std::reference_wrapper<T>？现在，您不必被迫重构代码以允许使用智能指针，但您也不必使用稍后可能会出现并认为他们应该使用的内部指针delete。

class MyClass 
{
   public:
      MyClass(string &str_ref)
         : my_str(std::ref(str_ref))
      {
      }

   private:
      std::reference_wrapper<std::string> my_str;
};
于 2012-02-04T16:18:17.863 回答
0

如果您希望仍然能够使用您的成员的赋值运算符（即std::string& operator=(std::string const&)），则不能使用std::reference_wrapper. 但是您可以使用复制构造函数从头开始重建对象，因此您的成员实际上可能是原始引用：

MyClass& MyClass::operator=(MyClass const& from) {
  this->~MyClass();
  new(this) MyClass(from);
  return *this;
}
于 2012-09-06T23:57:52.413 回答