C'est une question fondamentale mais me donne du fil à retordre. J'ai la classe A et dans le fichier d'en-tête, je veux définir un autre constructeur de classe B à partir d'un autre fichier d'en-tête. J'ai essayé ce code ci-dessous dont je suis sûr que ce n'est pas la bonne façon.

Ah

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

Je dois appeler le constructeur B dans A.h pour pouvoir appeler le constructeur B à l'intérieur du constructeur A et aussi utiliser la fonction de la classe B à l'intérieur de {{X5 }}.

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
}

Comme prévu, l'erreur que j'ai obtenue est à b.someFunction()

l'expression doit avoir un type de classe

Quelqu'un sait comment définir correctement le constructeur d'une autre classe dans un autre fichier d'en-tête de classe? Et appeler l'autre constructeur dans le constructeur de la classe principale et utiliser globalement la fonction de l'autre classe? Désolé pour la question basique et déroutante.

1
gameon67 20 mars 2019 à 12:35

3 réponses

Meilleure réponse

Ce n'est pas un constructeur:

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

Pareil ici:

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

Et même ici:

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

Vous voulez probablement un objet de type B, et appelez la méthode someFunction dessus. Vous voulez peut-être:

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

Et puis, si le constructeur de B nécessite des paramètres, vous pouvez:

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

S'il n'est pas nécessaire de passer des paramètres, vous pouvez simplement omettre la construction de b, et le langage utilisera simplement le constructeur par défaut de B (sans paramètres).

A::A ()  {
}
3
Michael Veksler 20 mars 2019 à 10:04

La façon d'appeler ou d'appeler un constructeur de B est de créer une instance de B.

Le processus de création d'une instance de B implique l'appel / l'invocation d'un constructeur de B. L'implémentation (alias compilateur) prend en charge les mécanismes d'appel du constructeur lors du processus de création d'un objet. Le travail du constructeur est de s'assurer que l'objet est initialisé pour une utilisation ultérieure.

En pratique, cela n'a aucun sens d'appeler un constructeur dans un contexte autre que la construction d'objet. Il existe des cas d'utilisation avancés dans lesquels un constructeur est effectivement appelé manuellement (par exemple, en utilisant une nouvelle expression de placement pour initialiser un bloc de mémoire afin qu'il contienne un objet). Cependant, cela est fait pour créer un objet à partir de la mémoire spécifiée. Ceci est complètement différent de ce que vous recherchez.

Pour construire un B dans (code dans) un fichier d'en-tête a.h, le fichier d'en-tête a.h doit fournir la visibilité d'une déclaration de B et de ses constructeurs.

Par exemple, en supposant que b.h déclare la classe B, l'en-tête a.h pourrait faire

#include "b.h"

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

Dans ce qui précède (de bas en haut), la déclaration B b spécifie que A a un membre de type B, nommé b.

La définition du constructeur de A

A() : b()  {} ;

Utilise une liste d'initialisation pour initialiser (construire) ce membre b. Cela suppose que la classe B a un constructeur qui ne peut accepter aucun argument.

La déclaration que vous aviez dans la classe A (que j'ai supprimée de l'exemple que j'ai fourni ci-dessus)

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

N'est pas ce que vous décrivez. C'est en fait une déclaration d'une fonction membre de la classe A, qui est nommée b() et renvoie un B. L'appel d'une telle fonction nécessite généralement B de avoir un constructeur fonctionnel (généralement un constructeur de copie ou de déplacement). Une telle déclaration, cependant, n'est pas un constructeur de B.

2
Peter 21 mars 2019 à 09:05

Juste #include "B.h" dans A.h et avoir B b; objet dans A.h .

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

De cette façon, le compilateur aura toutes les informations nécessaires des constructeurs class B et d'autres fonctions ainsi que pour cette unité de compilation A.cpp et l'éditeur de liens fera son travail plus tard en liant le nom de la fonction à sa logique dans une autre unité de compilation B.cpp .

0
M. Khalil 20 mars 2019 à 09:57