Question

(Not sure if this title is the best description…)

Hi all. I need a help with the following code. In process function, I want cc and cc_sub (which is obtained as a field in cc) to show different contents (as they are originally made so) but they show the same. Storage instances are made in makeObj function. Could someone tell me what’s wrong and how to work this around? Thank you.

Int process(const Storage cc) {
    Storage cc_sub = (Storage&) cc.data;  // Here
    cout << ... << endl;         // Contents from cc and cc_sub are the same though they are not supposed to be.
}

class Storage {
    public:
        Storage() {
            this->data = NULL;
        }
        Storage(const Storage& obj) { //Copy Constructor. Result is the same even if I removed this entire clause.
            this->data = obj.data;
        }
        void* data;
        void setData(Storage dPtr) {
            this->data = &dPtr;
        }
};

Storage makeObj(std::string* s) { // I want to keep the return value as value instead of pointer, 
                       // since when it returns pointer the values pointed by reference behaved unexpectedly (guess it's because of temporary object type of error)... 
    Storage cc;
    :
    cc.setData(makeObj(&subString)); 
    return cc;
    :
}

Answer 1

The odd behavior you’re seeing is due to manipulating temporary Storage variables, both within setData and makeObj. The outcome of such manipulation is undefined in C++.

Try the following:

void process(const Storage cc) {
    Storage cc_sub = *((Storage*)cc.data);
    cout << ... << endl;
}

class Storage {
    public:
        Storage() {
            this->data = NULL;
        }

        Storage(const Storage& obj) {
            this->data = obj.data;
        }
        void* data;
        void setData(Storage* dPtr) {
            this->data = dPtr;
        }
};

Storage* makeObj(std::string* s) {
    // Allocate memory on the heap so that cc lives beyond this function call
    Storage* cc = new Storage;
    :
    // Populate the sub-storage with a heap-allocated variable
    cc->setData(makeObj(&subString));
    return cc;
}

Note, the code as currently written makeObj will cause a stack overflow if called as it has no way of ending its recursion…

To cHao’s suggestion here’s a more complete program using shared_ptr (Microsoft Visual Studio 2008 version – you may need to change #include <memory> and/or std::tr1::shared_ptr depending on your compiler). I’ve changed the type of the data from void* to Storage (shared_ptr) and added a string member to better show the differences:

#include <string>
#include <iostream>
#include <memory>

using namespace std;
using namespace std::tr1;

class Storage {
    public:
        Storage() {
        }
        Storage(const Storage& obj) {
            this->data = obj.data;
        }
    string s;
    shared_ptr<Storage> data;
        void setData(shared_ptr<Storage> dPtr) {
            this->data = dPtr;
        }
};

void process(const shared_ptr<Storage> cc) {
    shared_ptr<Storage> cc_sub = cc.get()->data;
    cout << "Parent string: " << cc.get()->s << endl << 
            "Child string: " << cc_sub.get()->s << endl;
    cout << "Parent data pointer: " << cc.get()->data << endl << 
            "Child data pointer: " << cc_sub.get()->data << endl;
}

shared_ptr<Storage> makeObj(string* s) {
    shared_ptr<Storage> cc(new Storage);
    if (s->length() != 0) {
        string subString = s->substr(0, s->length()-1);
        cc->s = subString;
        cc->setData(makeObj(&subString));
    }

    return cc;
}


int main(int argc, char* argv[]) {
    string s = "hello";
    shared_ptr<Storage> storage = makeObj(&s);
    process(storage);
    return 0;
}