How to define class constructor inside another class header file?

Question

This is a basic question but gives me hard time. I have class A and in the header file I want to define another class constructor B from another header file. I tried this code below which I'm sure that's not the correct way.

A.h

class A{
public:
    A();
    B b();  //Constructor from another Class that defined in another header file
    void Operation();
};

I need to call the constructor B in A.h so I can call the constructor B inside constructor A and also use function in Class B inside A::Operation().

A.cpp

#include "A.h"
#include "B.h"
A::A{
    b();  //call constructor b
}

void A::Operation(){
    b.someFunction();  //use function from class B, error here
}

As expected, the error I got is at b.someFunction()

expression must have class type

Anyone know how to define another class's constructor inside another class header file properly? And call the other constructor inside main class constructor and use the other class's function globally? Sorry for basic and confusing question.

[`B b();` is a function declaration](https://en.wikipedia.org/wiki/Most_vexing_parse) — Aykhan Hagverdili, Mar 20 '19 at 09:38
I think your terminogy is a bit off. It looks more like you want to define a member variable (not a constructor) and then initialise that member (not call a constructor). There is a list of good books [here](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list). — molbdnilo, Mar 20 '19 at 09:41

Michael Veksler · Accepted Answer · 2019-03-20T10:04:06.273

5

This is not a constructor:

class A{
public:
    A();
    B b();  //This is a function named b, returning an object of type B
    void Operation();
};

Same here:

A::A{
    b();  //call function b from above, that returns a B object
}

And same here:

void A::Operation(){
    b.someFunction();  // Without invoking method b, you apply the dot operator on the method - which is illegal.
}

You probably want an object of type B, and call someFunction method on it. Maybe you want:

class A{
public:
    A();
    B b; // this is object named b, of type B
    void Operation();
};

And then, if the constructor of B requires parameters, you can:

A::A () : b(constructor parameters) {
}

If there is no need to pass parameters, you can just omit the construction of b, and the language will simply use the default constructor of B (without parameters).

A::A ()  {
}

edited Mar 20 '19 at 10:04

answered Mar 20 '19 at 09:42

Michael Veksler

8,217
1
20
33

Thanks for extra explanation using parameter. So `A::A () : b(constructor parameters)` this is called constructor delegation right? – gameon67 Mar 21 '19 at 01:17
@gameon67 no, this is member initializer list. Constructor delegation is when a name of class itself is used, but `b` is a name of a member variable. For example`A::A(int x) : A(), b(x) {}` is constructor delegation – Michael Veksler Mar 21 '19 at 02:42
I see, thanks for the clarification. constructor delegation is a new thing for me so I miss interpreted it with other term – gameon67 Mar 21 '19 at 03:31

Peter · Answer 2 · 2019-03-21T09:05:05.773

The way to invoke or call a constructor of B is to create an instance of B.

The process of creating an instance of B involves calling/invoking a constructor of B. The implementation (aka compiler) takes care of the mechanics of calling the constructor in the process of creating an object. The job of the constructor is to ensure the object is initialised for subsequent use.

Practically speaking, it does not make sense to call a constructor in any context other than object construction. There are some advanced use cases in which a constructor is effectively called manually (e.g. using a placement new expression to initialise a block of memory so it contains an object). However that is done to create an object from the specified memory. This is completely different from what you are seeking.

To construct a B within (code in) a header file a.h, the header file a.h needs to provide visibility of a declaration of B and its constructors.

For example, assuming b.h declares the class B, the header a.h might do

#include "b.h"

class A
{
   public:
       A() : b()  {} ;
       void Operation();
   private:
       B b;      //  A contains an instance of B
};

In the above (working bottom up) the declaration B b specifies that A has a member of type B, named b.

The definition of As constructor

A() : b()  {} ;

uses an initialiser list to initialise (construct) that member b. This assumes the class B has a constructor that can accept no arguments.

The declaration you had within class A (which I have removed from the sample I provided above)

B b();  //Constructor from another Class that defined in another header file

is not what you describe. It is actually a declaration of a member function of class A, which is named b() and returns a B. Calling such a function generally requires B to have a working constructor (typically a copy or move constructor). Such a declaration, however, is not a constructor of B.

M. Khalil · Answer 3 · 2019-03-20T09:57:15.547

0

just #include "B.h" in A.h and have B b; object in A.h.

#include "B.h"
class A{
  A();
  B b;
  void operation();
}

this way the compiler will have all the information needed from class B constructors and other functions as well for this compilation unit A.cpp and linker will do its job later linking the function name to its logic in other compilation unit B.cpp .

edited Mar 20 '19 at 09:57

answered Mar 20 '19 at 09:41

M. Khalil

43
1
8

How to define class constructor inside another class header file?

3 Answers3