C++ Appeler une fonction d'une autre classe

Très novice en c++ de la difficulté à l'appel d'une fonction à partir d'une autre classe.

Classe B inherites de la Classe A , et j'ai envie de catégorie A à être en mesure d'appeler une fonction créée dans la classe B.

using namespace std;

class B;

class A 
{

public:

    void CallFunction ()
    {
        B b;
        b.bFunction();
    }

};

class B: public A
{
public:
    virtual void bFunction()
        {
            //stuff done here
        }

};

Il semble tout à fait correcte à l'écran (pas d'erreurs évidentes), mais lorsque j'essaie de compiler, je reçois une erreur C2079 'b' utilise pas défini de classe B.

J'ai essayé de faire d'eux des pointeurs/friends mais j'obtiens le même message d'erreur,

pouvez-vous montrer le code complet?
ne fonctionne pas, il hérite de la classe A... Il doit partager son interface et de sa mise en œuvre, respectivement, dans .h et .fichiers cpp. Et #include "B.h" dans A.cpp
Ressemble à une dépendance cyclique. Classe B nécessite des fonctionnalités de classe A depuis il hérite A. Toutefois, la catégorie A nécessite des fonctionnalités de classe B afin d'utiliser correctement le CallFunction méthode. L'une de ces classes doivent être définies au préalable.

InformationsquelleAutor CM99 | 2013-01-05

c++class function

10
```
    void CallFunction ()
    {   //<----- At this point the compiler knows
        //       nothing about the members of B.
        B b;
        b.bFunction();
    }
```
Ce qui se passe pour la même raison que les fonctions de C ne peut pas s'appeler les uns les autres sans au moins l'un d'entre eux d'être déclaré comme un prototype de fonction.

Pour résoudre ce problème, nous devons nous assurer que les deux classes sont déclarées avant leur utilisation. Nous avons séparé la déclaration de la définition. Cet article MSDN explique plus en détail sur les déclarations et les définitions.
```
class A
{
public:
    void CallFunction ();
};

class B: public A
{
public:
    virtual void bFunction()
    { ... }
};

void A::CallFunction ()
{
    B b;
    b.bFunction();
}
```
- merci à ceux qui ont travaillé un régal 🙂
InformationsquelleAutor nishantjr
3

Ce que vous devez faire, est de mettre CallFunction en *.fichier cpp, où vous incluez B. h.

Après editer les fichiers de ressembler à:

B. h:
```
#pragma once //or other specific to compiler...
using namespace std;

class A 
{
public:
    void CallFunction ();
};

class B: public A
{
public:
    virtual void bFunction()
        {
            //stuff done here
        }
};
```
B.cpp
```
#include "B.h"
void A::CallFunction(){
//use B object here...
}
```
Référencement de votre explication, que vous avez essayé de changer B b; dans pointeur - il serait bon, si vous ne l'utilisez pas au même endroit. Vous pouvez utiliser le pointeur de indéfinie de la classe(mais déclarée), parce que TOUS les pointeurs ont fixé la taille en octets(4), de sorte que le compilateur n'a pas de problèmes avec ça. Mais il ne sait rien à propos de l'objet qu'ils désignent(tout simplement: connaît la taille/de limites, pas le contenu).

Tant et aussi longtemps que vous êtes à l'aide de la connaissance, que tous les pointeurs sont de même taille, vous pouvez les utiliser n'importe où. Mais si vous voulez utiliser l'objet, ils se dirigent à, la classe de cet objet doit être déjà définis et connus par le compilateur.

Et dernière précision: les objets peuvent varier en taille, contrairement aux pointeurs. Pointeur est un nombre, un index, ce qui indique l'endroit dans la mémoire RAM, où quelque chose est stocké(par exemple index: 0xf6a7b1).
- Je pense qu'il est important d'expliquer pourquoi cela fonctionne plutôt que la manière de le faire fonctionner
- Je l'ai expliqué sur le fond.
- grâce Dupadupa, votre réponse en fait trop mais njr a moins de frappe 😛 merci beaucoup pour votre aide.
- ok 🙂 je voulais juste expliquer le pourquoi vous pouvez mettre des pointeurs, mais pas des objets 🙂
InformationsquelleAutor therealszaka
0

dans Un vous avez utilisé une définition de B qui n'est pas donné jusqu'alors , c'est pourquoi le compilateur est de donner à l'erreur .

InformationsquelleAutor Anirudh Kumar
0

Déclarer avant class B et de swap afin de A et B définitions: 1er B et 2ème A. Vous ne pouvez pas appeler les méthodes de l'avant a déclaré B classe.

InformationsquelleAutor Leonid Volnitsky
0

de la classe B est à seulement déclaré mais pas défini au début, qui est ce que le compilateur se plaint. La cause est que dans la catégorie A de la Fonction d'Appel, vous faites référence à l'instance b de type B, qui est incomplète et indéfini. Vous pouvez modifier la source comme cela, sans introduire de nouveau fichier(par souci de simplicité, n'est pas recommandé dans la pratique):
```
using namespace std;

class A 
{
public:

    void CallFunction ();
};

class B: public A
{
public:
    virtual void bFunction()
    {
        //stuff done here
    }
};


 //postpone definition of CallFunction here

 void A::CallFunction ()
 {
     B b;
     b.bFunction();
 }
```
- C'est un peu vrai, mais un peu trompeur. Il a effectivement une dépendance cyclique. Il tente d'appeler une méthode d'une classe héritée de sa classe de base.
- vous avez raison, je suis juste au milieu de compléter：）
InformationsquelleAutor Hui Zheng

Vous devez vous connecter pour publier un commentaire.

B. h:

B.cpp