Comment transférer une fonction membre d'une classe à utiliser dans une autre classe?

J'en ai fait deux identiques classes de X et Y, avec un pointeur vers chaque autre. Voir le code ci-dessous pour X. h, Y. h est identique à celui de tous X et Y interchangeables. Ce code donne cependant une erreur dans ma méthode Connect (erreur C2027: utilisation de type non défini sur "Y"). Dans X. h, j'ai hâte déclaré la classe Y, mais il ne sait pas que Y a une méthode nommée SetXPointer. Donc j'ai aussi besoin de déclarer avant cette méthode, correct?

Si j'essaie de le faire (ajout de la ligne Y::SetXPointer(X* pX_in); sous la ligne de la classe Y;), j'obtiens une erreur du compilateur C2761: "void A::SetXPointer(X *)' : la fonction de membre de redeclaration pas autorisés. Est-il possible d'utiliser une méthode publique de la classe Y de la classe X?

//X.h

#pragma once

#include "Y.h"

//Forward declaration
class Y;

class X
{
public:
    X(void) : data(24) {};
    ~X(void) {};
    int GetData() { return data; }
    void SetYPointer(Y* pY_in) { pY = pY_in; }
    Y* GetYPointer() { return pY; }
    void Connect(Y* Y_in) { pY = Y_in; Y_in->SetXPointer(this); }
private:
    int data;
    Y *pY;
};

source d'informationauteur physicalattraction

  1. 11

    Ne comprennent pas le corps de la méthode dans le corps de la classe. Écrire les deux classes, et après que les deux classes sont complètes, écrire les implémentations de méthodes:

    class Y;
class X {
  …
  void Connect(Y* Y_in);
  …
};
class Y {
  …
  void Connect(X* X_in);
  …
};
inline void X::Connect(Y* Y_in) {
  pY = Y_in;
  Y_in->SetXPointer(this);
}
inline void Y::Connect(X* X_in) {
  pX = X_in;
  X_in->SetXPointer(this);
}

    De cette façon, une information complète sur la façon dont les objets de la classe sera mis en mémoire est disponible à la fois la Connect méthode est mise en œuvre. Et comme une méthode dans le corps de la classe et une méthode déclarée inline seront intégrées de la même manière, le rendement sera le même.

    Le seul inconvénient est que vous ne serez pas en mesure de séparer ces deux classes de plus de deux en-têtes, d'une manière raisonnable.

  2. 3

    La seule façon de le faire, si vos deux classes ont besoin d'un type complet dans leurs méthodes, est de séparer la mise en œuvre d'un fichier d'implémentation.

  3. 2

    Si vous avez l'intention de partager de grandes parties de la mise en œuvre entre X et Y, vous pouvez le faire à l'aide d'un modèle. Un exemple est la suivante:

    template<bool isX> class XY
{
public:
  typedef XY<!isX> YX; //This is the opposite type to the current one.
  XY(void) : data(24) {};
  ~XY(void) {};
  int GetData() { return data; }
  void SetPointer(YX* pYX_in) { pYX = pYX_in; }
  YX* GetPointer() { return pYX; }
  void Connect(YX* YX_in) { pYX = YX_in; YX_in->SetPointer(this); }
private:
  int data;
  YX *pYX;
};

typedef XY<true> X;
typedef XY<false> Y;

    Comme modèle les méthodes ne sont instanciés lorsque utilisé, vous pouvez éviter le problème décrit ci-dessus, que par le temps qu'ils sont instanciés, les deux types sont connus. Si plus tard vous sur les différences entre X et Yvous pouvez utiliser l'héritage au lieu de typedef.

  4. 2

    Vous pouvez placer de catégorie B en catégorie A

    using namespace std;

class A
{
        public:
        void run()
        {
                B b("hi");
                b.run(this);
        }

        void print(string &msg) { cout << msg << endl; }

        private:
        class B
        {
                public:
                B(string m) : msg(m) {}
                void run(A *a) { a->print(msg); }

                private:
                string msg;
        };
};

int main()
{
        A a;
        a.run();
        return 0;
}