Weird thing while trying to avoid pointers in C++

[ct]

I had this weird thing while I was trying to avoid pointers and just create objects on the stack.

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <cstdio>
using namespace std;
 
class Node {
    public:
        string move;
        int state[10];
        Node(const Node &p) {
            move = "";
            memcpy(state,p.state,sizeof(int)*10);
        }
        Node(){
            move = "";
            for(int i = 0;i<10;i++){
                state[i] = i;
            }
        }
        void AddNode(Node p){
            this->childNode.push_back(p);
        }
        Node GetChild(int i) {
           return childNode[i];
        }
        int GetCount() {
            return this->childNode.size();
        }
    protected:
        vector<Node> childNode;
};
 
class Move {
public:
    Move() {
 
    }
    void run() {
        Node n;
        n.move = "A100";
        operate(n);
    }
 
    void operate(Node &n) {
 
        Node c(n);
        c.move = "B100";
        n.AddNode(c);
        cout << "Output : " << endl;
        Node t = n.GetChild(n.GetCount() - 1); 
        //Node t = n.childNode[0];   
        for(int i = 0;i<10;i++)
               cout << t.state[i];
 
 
        cout << endl << t.move; // doesn't display B100 ????
 
    }
 
};
 
int main(int argc,char** argv) {
 
    Move m;
    m.run();
    return 0;
}

#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <cstdio>
using namespace std;

class Node {
    public:
        string move;
        int state[10];
        Node(const Node &p) {
            move = "";
            memcpy(state,p.state,sizeof(int)*10);
        }
        Node(){
            move = "";
            for(int i = 0;i<10;i++){
                state[i] = i;
            }
        }
        void AddNode(Node p){
            this->childNode.push_back(p);
        }
        Node GetChild(int i) {
           return childNode[i];
        }
        int GetCount() {
            return this->childNode.size();
        }
    protected:
        vector<Node> childNode;
};

class Move {
public:
    Move() {

    }
    void run() {
        Node n;
        n.move = "A100";
        operate(n);
    }

    void operate(Node &n) {

        Node c(n);
        c.move = "B100";
        n.AddNode(c);
        cout << "Output : " << endl;
        Node t = n.GetChild(n.GetCount() - 1); 
        //Node t = n.childNode[0];   
        for(int i = 0;i<10;i++)
               cout << t.state[i];


        cout << endl << t.move; // doesn't display B100 ????

    }

};

int main(int argc,char** argv) {

    Move m;
    m.run();
    return 0;
}

To copy to clipboard, switch view to plain text mode 

Here is a sample of something that I'm trying to do. My question is why isn't B100 move displayed ? Do I need an assignment operator in the Node class ? I believed push_back takes references and that the node with move value B100 should be stored in the vector. Correct state array is stored but the move string is not, any suggestions ?

[high_flyer]

... where to begin...

believed push_back takes references and that the node with move value B100 should be stored in the vector.

Programming is not a religion.
You don't believe stuff, you read the docs!
Since your definition of your vector was not with reference, it takes copies, not references.
I am not sure even why this code compiles, since you are trying to assign c to t but you didn't define an '=' operator for your Node class.

Node t = n.GetChild(n.GetCount() - 1); //I don't know why this compiles, it should not

Node t = n.GetChild(n.GetCount() - 1); //I don't know why this compiles, it should not

To copy to clipboard, switch view to plain text mode 

maybe a default assignment operator is called, but it knows nothing about your Node members, so it can't possibly copy inner members of your Node members such as 'move'.

[ct]

Well it does take reference.

void push_back ( const T& x );

void push_back ( const T& x );

To copy to clipboard, switch view to plain text mode 

However, even if it takes copy, shouldn't there be a value of move in the vector ?

I added the assignment operator

Node& operator=(const Node &r) {
 
            if(&r != this) {
                memcpy(this->state,r.state,sizeof(int)*10);
                this->move = r.move;
 
            }
 
            return *this;
        }

Node& operator=(const Node &r) {

            if(&r != this) {
                memcpy(this->state,r.state,sizeof(int)*10);
                this->move = r.move;

            }

            return *this;
        }

To copy to clipboard, switch view to plain text mode 

But still There is no output.

[stampede]

Take a look at your copy constructor:

Node(const Node &p) {
move = ""; //!< change this to p.move
memcpy(state,p.state,sizeof(int)*10);
}

Node(const Node &p) {
move = ""; //!< change this to p.move
memcpy(state,p.state,sizeof(int)*10);
}

To copy to clipboard, switch view to plain text mode 

When you take out an object from vector, it's copy is made and previously assigned string is cleared in your copy-constructor.

------------------
ok, maybe i was not clear enough, i mean this line:

Node t = n.GetChild(n.GetCount() - 1);

Node t = n.GetChild(n.GetCount() - 1);

To copy to clipboard, switch view to plain text mode 

this is copy - construction, its not the same as:

Node t;
t = n.GetChild(n.GetCount() - 1);

Node t;
t = n.GetChild(n.GetCount() - 1);

To copy to clipboard, switch view to plain text mode 

Assignment operator is not called anywhere in your code ( add cout's to see it yourself ).

[high_flyer]

Well it does take reference.

That is true, however think about it:
If it really only took a reference, and left it as a reference, all the original objects you would assign to it would need to stay alive, which is not the case.
So it takes a reference, but internally it creates a copy.

[Zlatomir]

Unless you define the vector as QVector<MyObject&> - then it indeed will take references.

I'm pretty sure you can't do that, since references in C++ have their "oddies" (like the reference is for all it's life bound to an object and it should be set at declaration)

So the remaining solution is QVector<MyObject*>

[high_flyer]

You are correct Zlatomir.
I have never tried it before actually, because it never made any practical sense.
I just assumed it is possible.
Now I tried it, and indeed, the compiler complains.
Thanks for the heads up!

[wysota]

I am not sure even why this code compiles, since you are trying to assign c to t but you didn't define an '=' operator for your Node class.

Node t = n.GetChild(n.GetCount() - 1); //I don't know why this compiles, it should not

Node t = n.GetChild(n.GetCount() - 1); //I don't know why this compiles, it should not

To copy to clipboard, switch view to plain text mode 

This is equivalent to:

Node t(n.GetChild(n.GetCount()-1));

Node t(n.GetChild(n.GetCount()-1));

To copy to clipboard, switch view to plain text mode 

The copy constructor kicks in here. Besides if you don't declare your own default constructor, copy constructor or assignment operator, the compiler will provide them for you.

Well it does take reference.

void push_back ( const T& x );

void push_back ( const T& x );

To copy to clipboard, switch view to plain text mode 

No, it takes a const reference. That's two totally different things.

[ct]

Thanks, I got it. The copy constructor was being called all the time. I got the difference now.

[ct]

One more thing on the topic though. Is it a good practice to avoid using pointers and use the stack space instead of heap ? That way there would be no memory leaks.

[SixDegrees]

No; that will quickly lead to convoluted code in all but the simplest applications. Pointers are fundamental to C/C++; there is no reason to avoid them.

If you're really worried about memory leaks, have a look at the STL auto_ptr class. Or run your code through a tool like valgrind to check for memory leaks, which is something you really ought to be doing anyway.