CODEWITHSUNDEEP
c++visual-c++memory-leaks
mr5
mr5

Reputation: 588

copy local objects by reference

Here's my problem,

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

It will cause a RT error because the *obj diminishes after the end of the function body.

But, how can make this one valid?

I like to initialized first an object before assigning it to other class.

EDIT

I don't want to use storage classes or something here, I just want a raw array since it is very expensive for me to use. Its functionality will not lessen my problem here.

So how do I do that in a raw-array style?

Upvotes: 0

Views: 96

Answers (4)

Some programmer dude
Some programmer dude

Reputation: 409404

Stop using raw arrays, and use either std::vector or std::array. Then you don't have to worry about it anymore.

If you really want to do it manually, you have to copy is manually as well. Using e.g. std::vector and std::move is more effective, but here you go:

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

As you can see, it's a lot of more code, which makes it harder to follow and debug, and also larger possibility of errors. And not as "effective" as I said above.

Upvotes: 1

juanchopanza
juanchopanza

Reputation: 227498

It is not completely clear what you are trying to do, but you could store a collection of objects instead of a pointer:

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

then

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

Upvotes: 1

Olaf Dietsche
Olaf Dietsche

Reputation: 74078

In your example, you store a pointer to a local array. If the method ends, the array goes out of scope and doesn't exist anymore.

This is the reason, your pointer is not valid anymore. If you want to solve this, learn about the scope of variables in C++.

Upvotes: 1

111111
111111

Reputation: 16168

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

Upvotes: 2

Related Questions