通过引用复制本地对象

copy local objects by reference

本文关键字：对象 复制本 引用      更新时间：2023-10-16

这是我的问题，

Class MClass {
public:
    void Add(OtherClass* objects) {
        _objects = objects;
    }
private:
    OtherClass* _objects;
}
//otherfile.cpp

void Setup() {
    MClass myObj;
    OtherClass obj[NUMBER_OF_OBJECTS];
    //obj initialization here
    //...
    myObj.Add(obj);
}

这将导致RT错误，因为*obj在函数体结束后减小。

但是，如何使这个有效？

我喜欢先初始化一个对象，然后再将其分配给其他类。

编辑

我不想在这里使用存储类或其他东西，我只想要一个原始数组，因为它对我来说非常昂贵。它的功能不会减轻我的问题。

那么，如何在原始数组样式中做到这一点呢？

Class MClass {
public:
    void Add(std::vector<OtherClass> objects) {
        _objects = std::move(objects);
    }
private:
    std::vector<OtherClass> _objects;
}
//otherfile.cpp
void Setup() {
    MClass myObj;
    std::vector<OtherClass> obj(NUMBER_OF_OBJECTS);
    myObj.Add(std::move(obj));
}

在您的示例中，您存储了一个指向本地数组的指针。如果该方法结束，则该数组将超出范围，不再存在。

这就是为什么，您的指针不再有效。如果您想解决这个问题，请了解C++中变量的范围。

虽然还不完全清楚您要做什么，但您可以存储对象集合而不是指针：

class MClass 
{
 public:
    void Add(const std::vector<OtherClass>& objects) {
        objects_ = objects;
    }
    void Add(std::vector<OtherClass>&& objects) {
        objects_ = std::move(objects);
    }
 private:
    std::vector<OtherClass> objects_;
};

然后

void Setup() 
{    
    MClass myObj;
    std::vector<OtherClass> obj(NUMBER_OF_OBJECTS);
    //obj initialization here
    //...
    myObj.Add(std::move(obj)); // move obj's contents onto myObs's objects.
}

停止使用原始数组，并使用std::vector或std::array。那你就不用再担心了。

如果真的想手动完成，那么也必须手动复制。使用例如std::vector和std::move更有效，但现在开始：

Class MClass {
public:
    MClass()
        : _objects(nullptr), _count(0)
    {}
    MClass(const MClass& other)
        : _objects(nullptr), _count(0)
    {
        Add(other._objects, other._count);
    }
    ~MClass()
    {
        if (_objects != nullptr)
            delete [] _objects;
    }
    void Add(const OtherClass* objects, const size_t count)
    {
        if (_objects != nullptr)
            delete [] _objects;
        _objects = new [count];
        for (size_t i = 0; i < count; i++)
            _objects[i] = objects[i];
        _count = count;
    }
    MClass& operator=(const MClass& other)
    {
        Add(other._objects, other._count);
    }
private:
    OtherClass* _objects;
    size_t _count;
};
// ...
myObj.Add(obj, NUMBER_OF_OBJECTS);

正如您所看到的，它包含了更多的代码，这使得跟踪和调试变得更加困难，而且出现错误的可能性也更大。而且没有我上面说的那么"有效"。

相关文章：