Dwie klasy pokazujące na siebie - jak to powinno wyglądać?

Witam,
problem wydaje mi się prosty, ale jakoś nie mogę go obejść O_o.

Mam dwie klasy (tak na prawdę to trzy, ale mniejsza z tym :P). Każda z tych klas pokazuje na drugą (jest wskaźnik do drugiej klasy). Wygląda to mniej więcej tak:

//plikA.h
#include "plikB.h"
class klasaA
{
KlasaB* klasab;
//...
};

//plikB.h
#include "plikA.h"
class klasaB
{
klasaA* klasaa;
//...
};

No i problem jest taki, że coś jest nie tak z kompilacją... Wiem, że muszę gdzieś dodać class klasaA; lub class klasaB; przed deklaracją klasy, ale jak to zrobiłem i chciałem skorzystać z zadeklarowanego wskaźnika tj. np. klasab->jakas_funkcja(); to wywala mi błąd...

Czy może mi ktoś powiedzieć jak to powinno prawidłowo wyglądać? PLZ

ale jak to zrobiłem i chciałem skorzystać z zadeklarowanego wskaźnika tj. np. klasab->jakas_funkcja(); to wywala mi błąd...

Jaaaaakiiiiii, błąd? ...

//plikA.h
#pragma once
#include "plikB.h"
class KlasaB;
class klasaA
{
KlasaB* klasab;
//...
};
 
//plikB.h
#pragma once
#include "plikA.h"
class klasaB
{
klasaA* klasaa;
//...
};

http://ideone.com/igaCwk

prosze. Oczywiscie NIE mozesz w konstruktorze inicjowac obiektu (czyli w A nie mozesz inicjowac obiektu w B a w B inicjowac obiektu A) bo wtedy program sie zapetli. Mozesz zrobic w jedna strone czyli w A zainicjowac B ale juz nie robisz w drugiej. Lub zainicjowac w B, A, ale A zostawiasz. Mozesz takze zrobic metody

-> CreateBObject
-> CreateAObject

wywolujac to bedzesz inicjalizowal te pola.

Mozesz zrobic w konstruktorze, ale potrzebujesz zmiennej statycznej cos na zasadzie couter a konstruktor zrobic z ifem na zasadzie if (!counter) {//utrzow obiekt}

Ok, jeśli chodzi o błędy to są one następujące:

error C2143: błąd składniowy : brakuje ";" przed "*"
error C4430: brak specyfikatora typu - założono, że int. Uwaga C++ nie obsługuje domyślnie typu int

Nawet kopiując kod @_13th_Dragon wywala mi te błędy...

Po wprowadzeniu w obu klasach deklaracji klasy przed klasą tworzoną wstępnie wyeliminowało problem. Problem pojawił się troszkę później, gdy chciałem w obu klasach wywołać funkcję z drugiej klasy.
Cały kod wygląda następująco:

//plik KlasaA.h
#pragma once
#include "KlasaB.h"
class KlasaB;

class KlasaA
    {
    public:
        KlasaA();
        ~KlasaA();
        void checkA(){}

        void check1(){
            B->checkB();
            }

    private:
        KlasaB* B;
    };

//plik KlasaB
#pragma once
#include "KlasaA.h"
class KlasaA;

class KlasaB
    {
    public:
        KlasaB();
        ~KlasaB();
        void checkB(){}
        void check2(){
            A->checkA(); //po wprowadzeniu tej klasy wywala mi errory...
            }

    private:
        KlasaA* A;
    };

Po utworzeniu takich klas mam następujące błędy:

error C2027 : wykorzystywanie niezdefiniowanego przez użytkownika typu "KlasaA"
errorC2227 : po lewej "->checkA" musi wskazywać typ class/struct/union/generic

i analogiczne błędy dla drugiej klasy

//plik KlasaA.h
#pragma once
#include "KlasaB.h"
class KlasaB;
 
class KlasaA
    {
    public:
        KlasaA();
        ~KlasaA();
        void checkA(){}
 
        void check1();
    private:
        KlasaB* B;
    };

//plik KlasaA.cpp
 #include "KlasaA.h"
void KlasaA::check1(){
            B->checkB();
            }

//plik KlasaB.h
#pragma once
#include "KlasaA.h"
class KlasaA;
 
class KlasaB
    {
    public:
        KlasaB();
        ~KlasaB();
        void checkB(){}
        void check2();
 
    private:
        KlasaA* A;
    };

//plik KlasaB.cpp
#include "KlasaB.h"
void KlasaB::check2(){
            A->checkA();
            }

Dziękuję Ci bardzo @_13th_Dragon - w ten sposób rzeczywiście działa. Ale czy to oznacza, że w takim przypadku nie ma możliwości zastosowania funkcji inline?

Kowallo napisał(a):

Dziękuję Ci bardzo @_13th_Dragon - w ten sposób rzeczywiście działa. Ale czy to oznacza, że w takim przypadku nie ma możliwości zastosowania funkcji inline?

Można:

//plik KlasaA.h
#pragma once
class KlasaB;
class KlasaA
  {
   public:
   KlasaA();
   ~KlasaA();
   void checkA(){}
   void check1();
   private:
   KlasaB* B;
  };
#include "KlasaB.h"
inline void KlasaA::check1() { B->checkB(); }

//plik KlasaB.h
#pragma once
class KlasaA; 
class KlasaB
  {
   public:
   KlasaB();
   ~KlasaB();
   void checkB(){}
   void check2();
   private:
   KlasaA* A;
  };
#include "KlasaA.h"
inline void KlasaB::check2() { A->checkA(); }

tylko po kiego?

Rzeczywiście O_o - byłem przekonany, że inline można stosować tylko w pliku nagłówkowym...
Dziwi mnie tylko to, że kompilator wymusza umieszczenie definicji tych funkcji w pliku .cpp -> nie ma możliwości ich zdefiniowania w pliku .h...

Dzięki jeszcze raz!

Oraju, rzeczywiście się da ;].
Przepraszam bardzo za moją niekumatość :D
Jeszcze raz bardzo dziękuję!!!