Вчера видимо перепил маленько, весь день не могу разобрать, где ошибка?


//------------------------------main.cpp------------------------------
#pragma once

#include "A.h"
#include "B.h"

void main()
{


}


//------------------------------A.h------------------------------
#pragma once

#include "B.h"

class A
{
float plus(B &op);

};



//------------------------------B.h------------------------------
#pragma once

#include "A.h"

class B
{
float plus(A &op);

};

Здравствуйте, Аноним, Вы писали:

А>Вчера видимо перепил маленько, весь день не могу разобрать, где ошибка?


А>//------------------------------main.cpp------------------------------
А>#pragma once

А>#include "A.h"
А>#include "B.h"

А>void main()
А>{


А>}


А>//------------------------------A.h------------------------------
А>#pragma once

А>#include "B.h"

А>class A
А>{
А> float plus(B &op);

А>};



А>//------------------------------B.h------------------------------
А>#pragma once

А> class A;

А>class B
А>{
А> float plus(A &op);

А>};

Вместо включения в заголовке а заголовка б, ограничься предварительным объявлением класса class B;(ведь определение функции у тебя не в заголовке же? вот там,
где оно, и включай). Ну и в б не включай а, а используй предварительное объявление class A.
А то у тебя мешанина какая-то с попыткой циклического включения
да еще и с прагмой.

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>Вместо включения в заголовке а заголовка б, ограничься предварительным объявлением класса class B;(ведь определение функции у тебя не в заголовке же? вот там,
L_L>где оно, и включай). Ну и в б не включай а, а используй предварительное объявление class A.
L_L>А то у тебя мешанина какая-то с попыткой циклического включения
L_L>да еще и с прагмой.


Определение функции у меня как раз в заголовке (инлайница она у меня)

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>>Вместо включения в заголовке а заголовка б, ограничься предварительным объявлением класса class B;(ведь определение функции у тебя не в заголовке же? вот там,
L_L>>где оно, и включай). Ну и в б не включай а, а используй предварительное объявление class A.
L_L>>А то у тебя мешанина какая-то с попыткой циклического включения
L_L>>да еще и с прагмой.


А>Определение функции у меня как раз в заголовке (инлайница она у меня)

Тогда никак.

Что, обе в заголовках определены?

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>Что, обе в заголовках определены?

Да, определены все в заголовках.
Внизу приведен законченный пример. Как поступить в этом случае?
Я хотел бы знать, по какому правилу компилятор ругается?


//------------------------------main.cpp------------------------------
#include "A.h"
#include "B.h"

void main()
{


}

//------------------------------A.h------------------------------
#pragma once

#include "B.h"

class A
{
void plus(B &op);

float f;
};

inline void A::plus(B &op)
{
f += op.f;
}


//------------------------------B.h------------------------------
#pragma once

#include "A.h"

class B
{
void plus(A &op);

float f;
};

inline void B::plus(A &op)
{
f += op.f;
}

Тут уже однажды кто-то зафигачил себе один заголовок, который подключал остальные, да еще с внешними гардами, да еще с циклическими зависимостями. Помнится, пару
недель его глюкало, никак не хотал смириться. Если тебя интересует "почему" :

(прагмы я заменил стражами включения)
A.h

#ifndef A_INCLUDED
#define A_INCLUDED

#include "B.h"

class A
{
public:
   void fun(B b)
   {
       b.some();
   }
   void some(){}
};
#endif

B.h

#ifndef B_INCLUDED
#define B_INCLUDED

#include "A.h"

class B
{
public:
   void fun(A a)
   {
       a.some();
   }
   void some(){}
};
#endif

стрелкой показаны подключенные файлы, составляющие в итоге единицу трансляции
main.cpp

#include "A.h" ----->  #ifndef A_INCLUDED //да, истина, включаем текст A.h
                                 #define A_INCLUDED

                                 #include "B.h"-----------------------------> #ifndef B_INCLUDED //да, истина, включаем текст B.h
                                                                                              #define B_INCLUDED
 
                                                                                              #include "A.h"----------------------------------------------->#ifndef A_INCLUDED //уже определен, не текст не включается
                                                                                             
                                                                                              class B{
                                                                                              public: 
                                                                                                   void fun(A a){a.some();} //все, ошибка, что такое А - неизвестно.


#endif
Дальше уже неважно.

Здравствуйте, Аноним, Вы писали:
А>Да, определены все в заголовках.
А>Внизу приведен законченный пример. Как поступить в этом случае?

Если так нужны inline-функции, то от одной из функций-членов придется отказаться, заменив ее на обычную:

А>//------------------------------main.cpp------------------------------
А>#include "A.h"
А>#include "B.h"

А>void main()
А>{


А>}

А>//------------------------------A.h------------------------------
А>#pragma once

А>#include "B.h"

А>class A
А>{
А>    void plus(B &op);

А>    float f;
А>};

А>inline void A::plus(B &op)
А>{
А>    f += op.f;
А>}


А>//------------------------------B.h------------------------------
А>#pragma once


class A;
А>class B
А>{
А>    friend void plus(B& b, A &op);

А>    float f;
А>};

А>//------------------------------AB.h------------------------------

#include "A.h"
#include "B.h"

А>#pragma once

А>inline void plus(B& b, A &op)
А>{
А>    b.f += op.f;
А>}