0

这是我的问题，

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

但是，如何使这个有效？

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

编辑

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

那么我该如何以原始数组样式做到这一点呢？

4

4 回答 4

2 
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));
}
于 2013-02-25T13:08:18.933 回答
1

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

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.
}
于 2013-02-25T13:08:05.333 回答
1

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

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

于 2013-02-25T13:13:54.403 回答
1

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

如果你真的想手动做，你也必须手动复制。使用 eg std::vectorandstd::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);

如您所见，它的代码更多，这使得跟踪和调试变得更加困难，并且出错的可能性也更大。而且不像我上面说的那么“有效”。

于 2013-02-25T13:08:33.027 回答