Question

这是我的问题，

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在函数体结束后减弱。

但是，如何使这个有效？

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

修改

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

那我该怎么做一个原始数组样式？

Answer 1

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));
}

Answer 2

目前还不完全清楚你要做什么，但你可以存储一组对象而不是一个指针：

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.
}

Answer 3

停止使用原始数组，并使用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);

正如您所看到的，它是更多的代码，这使得更难以跟踪和调试，并且更大的错误可能性。并不像我上面说的那样“有效”。

Answer 4

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

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

通过引用复制本地对象

4 个答案: