Default constructor not called if classes devided into separate files

Question

UPDATE:

Now I have this, and it does not compile: A.h:

#ifndef A_H
#define A_H

class A {
private:
    int foo;

public:
    A();
    int getfoo();
};

#endif

A.cpp:

#include "A.h"

A::A() {
    foo = 5;
}

int A::getfoo(){
    return foo;
}

B.h:

#ifndef B_H
#define B_H

class B {
private:
    A myA;

public:
    B();
    int getAvalue();
};

#endif

B.cpp:

#include "A.h"
#include "B.h"

int B::getAvalue(){
    return myA.getfoo();
}

Errors:

b.h line 6: C2146: missing ';' before identifier 'myA'
b.h line 6: C4430: missing type specifier - int assumed
b.h line 6: C4430: missing type specifier - int assumed

END UPDATE

I have written 2 classes in different cpp and header files: class A and class B. Class B uses class A as a private variable and the default constructor of class A is never called. Here is my code:

A.h:

class A {
public:
    A();
    int getfoo();
};

A.cpp:

class A {
private:
    int foo;
public:
    A();
    int getfoo();
};

A::A() {
    foo = 5;
}

int A::getfoo(){
    return foo;
}

B.h:

class B {
public:
    int getAvalue();
};

B.cpp:

#include "A.h"

class B {
private:
    A myA;
public:
    int getAvalue();
};

int B::getAvalue(){
    return myA.getfoo();
}

classtest.cpp:

#include "stdafx.h"
#include <iostream>
#include "B.h"

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    B stackB;
    cout << stackB.getAvalue() << endl;

    B* storeB = new B();
    cout << storeB->getAvalue() << endl;

    cin.get();
    return 0;
}

The output is never 5 and the breakpoint inside the constructor A::A() is never triggered. It doesn't matter if I use B globally or locally. This sample works totally fine if I put the classes and functions in one single file.

If I add an empty default constructor to class B, the default constructor of class A gets called, but then Visual Studio 2008 complains about stack corruption around variable stackB.

What am I doing wrong?

Answer 1

Just with this class alone:

A.h:

class A {
public:
    A();
    int getfoo();
};

A.cpp:

class A {
private:
    int foo;
public:
    A();
    int getfoo();
};

A::A() {
    foo = 5;
}

int A::getfoo() {
    return foo;
}

You are declaring class A in A.h.

Then in your implementation(cpp) file, you are then again declaring class A. You are also forgetting to include A.h in A.cpp. If you included the header into the cpp; the compiler would of thrown out errors telling you what was wrong. You are also missing either header guards, or the pragma directive.

---

Your class should look like this:

A.h

#ifndef A_H
#define A_H

class A {
private:
    int foo;
public:
    A();
    int getFoo() const;  // const to return member and prevents modification
};

#endif // !A_H

A.cpp

#include "A.h" // you forgot to include the header

A::A() : // class constructor using it's member initializer list
    foo( 5 ) {
} 

int A::getFoo() const { 
    return foo; 
}

Now once you fix your class, then working on class B should not be a problem. However there is one thing to be careful of when including a header file of one class into another; you can end up with circular includes. The best way to prevent that is to use a class prototype in the header and include its header in the containing class's cpp file. There are some cases where a class proto type will not work, but I'll leave that up to you to do the research.

How to use Class Prototype in C++

---

Class B might look like this:

B.h

#ifndef B_H
#define B_H

// #include "A.h"  // uncomment this if prototype below doesn't work.
class A; // class prototype may not work in all cases;
// If the above prototype does not work; comment it out
// and replace it with #include "A.h".


class B {
private:
    A myA;

public:
    B(); // remove default
    int getAValue() const;
};

#endif // !B_H

B.cpp

#include "B.h"
#include "A.h" // If class A's prototype in the header does not work
// then comment this out and place it in this class B's header by
// replacing it with the prototype.

B::B() {} // default constructor (should make this complete type)

int B::getAValue() const { 
    return myA.getFoo(); 
}

And this should help to fix your problems. If using the class prototype does not work in the header because in some cases it may not; you can remove the prototype declaration from the header and replace it with the include directive of that class and remove its include from the cpp file.