移动破坏原始指针的运算符

Question

我正在尝试一个指向内存位置的指针。然后，如果我修改原始的赋值变量指向相同位置的人也必须受到该变化的影响。

但是，问题是，有两个函数调用，发生在线路上：

a = Data("New data");

调用

1. Data(const char* cdata)构造函数
2. 调用Data operator=(Data&& data)移动运算符

编辑：我知道以下内容：

• std:：shared_ptr<gt
• std:：make_shared<gt

但是，我正在尝试在没有这些新功能的情况下实现这一点。我完全清楚。

我的C++代码：

class Data 
{
private:
char* local_data;
int _size = 0;
int length(const char* c)
{
int i = 0;
while(c[++i] != '');
return i;
}
public:
Data() {
local_data = new char[_size];
}

Data(const char* cdata){
_size = length(cdata);
local_data = new char[_size];
memcpy(local_data, cdata, _size);
}

int size() { return _size; }
char* data() { return local_data; }
const char* data() const { return local_data; }

Data& operator=(const Data& data){}
Data& operator=(Data&& data){

if(this == &data)
return *this;

_size = std::move(data.size());
local_data = std::move(data.data());
return *this;
}
};
int main(){

Data a("Some data");
auto dptr = a.data(); // Gives a pointer to the original location
a = Data("New data"); // Must modify both a and dptr
assert(dptr == a.data()); // Should pass successfully, else fail
return 0;
}

Answer 1

您似乎想要std::shared_ptr<std::string>:

class Data 
{
private:
std::shared_ptr<std::string> local_data = std::make_shared<std::string>();
public:
Data() = default;

Data(const char* cdata) : local_data(std::make_shared<std::string>(cdata)) {}

int size() const { return local_data->size(); }
char* data() { return local_data->data(); }
const char* data() const { return local_data->c_str(); }

Data operator=(const Data& rhs) {
if (this == &data)
return *this;

*local_data = *rhs.local_data;
return *this;
}
};
int main(){

Data a("Some data");
auto dptr = a.data(); // Gives a pointer to the original location
a = Data("New data"); // Must modify both a and dptr
assert(dptr == a.data()); // Should pass successfully
}

Answer 2

您的class Data存在一些问题。首先，它从不调用delete[] local_data，因此会泄漏内存。添加析构函数：

~Data() {
delete[] local_data;
}

然后确保您的移动分配操作符工作正常。不要使用std::move(data.data())，这实际上不会在从移动到nullptr的对象中设置指针。此外，请确保正确清理this->local_data。最简单的方法是：

Data& operator=(Data&& data){
std::swap(local_data, data.local_data);
std::swap(_size, data._size);
return *this;
}

它交换指针，所以没有内存泄漏。移动后，data的销毁将确保旧的this->local_data被删除。

您的复制赋值运算符是空的，您应该解决这个问题，如果您有一个移动赋值运算符，您可能还想实现一个移动构造函数。最后：

assert(dptr == a.data()); // Should pass successfully, else fail

这是错误的；dptr不应与a.data()相同，因为dptr是指向移动分配之前数据的指针的副本。除非明确修改dptr，否则dptr的值不会更改。