Initializing an object in c++

Question

A.hh

#ifndef A_HH
#define A_HH

#include <iostream>
#include <string>

using namespace std;

class A {
private:
int size;
string name;

public:
A();
~A();
int Load(int, string);

int getSize();
string getName();

/* data */
};

#endif

A.cc:

#include "A.hh"


A::A() {

}


int A::Load(int _size, string _name) {
size = _size;
name = _name;
return 0;
}

int A::getSize() {
return size;
}

string A::getName() {
return name;
}

A::~A() {

}

B.hh:

#ifndef B_HH
#define B_HH

#include "A.hh"
#include <string>

class B {
private:
A* objectA;

public:
B();
B(A*);
~B();

A* getA();

/* data */
};
#endif

B.cc:

#include "B.hh"

B::B() {

}

B::B(A* obj) {
objectA = obj;
}

A* B::getA() {
return objectA;
}

B::~B() {

}

C.cc

#include "C.hh"

C::C() {

}


int C::doSomething() {
cout<<"size = "<<getA()->getSize()<<endl;
cout<<"name = "<<getA()->getName()<<endl;

return 0;
}


C::~C(){

}

C.hh

#ifndef C_HH
#define C_HH
#include "B.hh"


class C : public B {
public:
C();
~C();

int doSomething();
/* data */
};

#endif 

main.cc

#include "A.hh"
#include "B.hh"
#include "C.hh"

int main() {
A* objA = new A();
objA->Load(1, "Hello Drew Dormann :)");

B* objB = new B(objA);

C* objC = new C();
objC->doSomething();

return 0;
}

Why am I getting a segfault on doSomething()?

I'm using the child of B to handle the object parsed into B. Also I have to use B's child to handle A because this is part of something much bigger and this is the only way to simplify it.

I don't understand why this happens.

Answer 1

There seems to be a misconception of how objects work and are constructed behind this question.

C* objC = new C();

Creates brand new C. The C constructor does absolutely nothing beyond allocating storage, so absolutely nothing is initialized. Because C inherits from B, C's constructor will call the default constructor for B, which does nothing, but calls the default constructor for its parent, A. A's default constuctor does not initialize name and size so their values are undefined. B's default constuctor does not initialize objectA so it is undefined, leading to the segfault.

This C was created by new comes out of some pool of memory, typically the heap, and needs to be returned to this pool with delete when no longer needed. If it is not the program will lose the memory used by C.

The same sample can be performed without dynamic allocation.

C objC;

Creates a C, but does it on the stack. When the stack unrolls at the end of the function or code block (search term: variable scope) the C will be popped off and automatically destroyed. This is typically the better way to operate as it requires no additional memory management. The C looks after itsef and can be considered "fire-and-forget."

Back on topic...

objC->doSomething();

Do something calls the getA method inherited from B which dutifully returns the uninitialized objectA. objectAis promptly used to call getSize with objectA as the concealed this parameter. Since Crom only knows what objectA is actually pointing at it would be a minor miracle if this->size wasn't somewhere crash-provoking.

If the OP expects

A* objA = new A();
objA->Load(1, "Hello Drew Dormann :)");

and

B* objB = new B(objA);

to have some bearing on the state of C. The OP is incorrect. objA and objB are their own entities. They are different objects and every object has its own state.

In order to have C initialize B with something other than the default constructor, you need your C constructor to look more like this:

C::C(A* obj) : B(obj)
{

}

This assigns a pointer to A passed into C to B, using B's B(A*); constructor.

C::C(A* obj, 
     int size,
     string name) : B(obj, size, name)
{

}

B::B(A* obj, 
     int size,
     string name) : A(size, name)
{

}

Cascades all of the parameters needed to fully specify a C all the way down to A.

As B needs to have objectA initialized, I recommend removing B and C's default constructors to force initialization to a meaningful value. If B and C require default constructors for some other purpose, such as storage in a standard container, either getA() needs to be a lot smarter or B's default constructor must initialize objectA to some safe value.

This still leaves the great question of why B contains a pointer to a parent. I'll leave that to the OP to work out.

And while The OP is at it, I recommend reading this: What is The Rule of Three?. Because the next question is likely to be "Dude! Who deleted my objectA"?

Also using namespace std in a header is very super bad. Read here: Why is "using namespace std" considered bad practice?

Answer 2

Your problem is that objectA in objC points to invalid memory hence in doSomething() you are trying to call the member access operator on an invalid pointer. You can change the default constructor of B to construct an object and have objectA point to it, make sure to free your memory as well!

#include <iostream>
#include <string>

/*#################
// !! class A !! //
#################*/
class A 
{
private:
    int size = 0;
    std::string name;

public:
    int Load(int, const std::string&);

    int getSize() { return size; }
    std::string getName() { return name; }
};

int A::Load(int _size, const std::string &_name)
{
    size = _size;
    name = _name;
    return 0;
}

/*#################
// !! class B !! //
#################*/
class B
{
private:
    A* objectA;

public:
    B() : objectA(new A()) { }
    B(A* obj) : objectA(new A(*obj)) { }

    A* getA() { return objectA; }
    virtual ~B() { delete objectA; }
};

/*#################
// !! class C !! //
#################*/
class C : public B
{
public:
    C() = default;
    int doSomething();
};


int C::doSomething()
{
    // Problem: objectA points to invalid memory
    std::cout << "size = " << getA()->getSize() << std::endl;
    std::cout << "name = " << getA()->getName() << std::endl;

    return 0;
}

/*#################
// !!! main !!!  //
#################*/
int main()
{
    A* objA = new A();
    objA->Load(1, "Hello Drew Dormann :)");

    B* objB = new B(objA);

    C* objC = new C();
    objC->doSomething();
    // free your memory!!!
    delete objA;
    delete objB;
    delete objC;

    return 0;
}