Question

C++两个类如何通过指针相互调用对方的函数？

代码如下，编译提示m_pB->funB();这句有错误，怎么改？多谢~
#include <iostream>
class A;
class B;
class A
{
B* m_pB;
public:
A()
{
m_pB=nullptr;
}
void Set(B* pB)
{
m_pB=pB;
}
void funA()
{
std::cout<<"类A的funA被调用"<<std::endl;
m_pB->funB();
}
};

class B
{
A* m_pA;
public:
B()
{
m_pA=nullptr;
}
void Set(A* pA)
{
m_pA=pA;
}
void funB()
{
std::cout<<"类B的funB被调用"<<std::endl;
m_pA->funA();
}
};

int main()
{
A a;
B b;
a.Set(&b);
b.Set(&a);
a.funA();
b.funB();
return 0;
}

Answer 1

交叉引用一般有两种方法
class B ;
class A
{
B* pb ;
void funA() ;
} ;

class B
{
A* pa ;
void funB() ;
}

void A::funA() { pb->funB() ; } // warning of infinite loop here
void B:: funB() { pa->funA() ; } // warning of infinite loop here
这是最常见的方式
------------------------------------------------
但上面方式有个严重的缺陷, 必须要把类的定义和实现分开.这就意味着,
你不能类的实现放在.h中(并被多个.cpp包含), 不然就等着编译器在链接时抱怨"符号重定义"
因为类的定义作用域是单模块, 而函数的定义是扩模块的.
我平时写类库, 最怕的就是为个.h要写个.cpp,文件,太繁琐.

所以可以使用方法2
template< class B >
class A
{
B* pb ;
void funA() { pb->funB() ; } // warning of infinite loop here
} ;

class B
{
A* pa ;
void funB() { pa->funA() ; } // warning of infinite loop here
}
这种C++ idiom虽然说要让A引入策略B做为模板参数, 有些"做作"
但是交叉引用这种设计很多时候隐含着, 你的class A确实需要依赖策略B中的语义.
所以模板并不是单纯解决"双重引用"这个机制而诞生的, 而是class A在概念上对于策略B的自然依赖. 只是策略B除了用class B初始化, 还可以用其他类初始化

Answer 2

需要完整的类声明。就是正常的头文件的作用了。

#include <iostream>

class A;
class B
{
    A *m_pA;
public:
    B();
    void Set(A *pA);
    void funB();
};

class A
{
    B* m_pB;
public:
    A()
    {
        m_pB=nullptr;
    }
    void Set(B* pB)
    {
        m_pB=pB;
    }
    void funA()
    {
        std::cout<<"类A的funA被调用"<<std::endl;
        m_pB->funB();
    }
};

B::B()
{
    m_pA=nullptr;
}
void B::Set(A* pA)
{
    m_pA=pA;
}
void B::funB()
{
    std::cout<<"类B的funB被调用"<<std::endl;
    m_pA->funA();
}

int main()
{
    A a;
    B b;
    a.Set(&b);
    b.Set(&a);
    a.funA();   // 这里就退不出来了。互相调用一直循环在里面。
    b.funB();
    return 0;
}

顺便说，你这程序这样写会死循环。a.funA 里面调用 m_pB->funB，而 b的funB 里又调用 m_funA。

Answer 3

交叉引用一般有两种方法
class B ;
class A
{
B* pb ;
void funA() ;
} ;

class B
{
A* pa ;
void funB() ;
}

void A::funA() { pb->funB() ; } // warning of infinite loop here
void B:: funB() { pa->funA() ; } // warning of infinite loop here
这是最常见的方式

Answer 4

#include <iostream>
//class A;
class B;
class A
{
	B* m_pB;
public:
	A()
	{
		m_pB = nullptr;
	}
	void Set(B* pB);
	void funA();
};

class B
{
	A* m_pA;
public:
	B()
	{
		m_pA = nullptr;
	}
	void Set(A* pA);
	void funB();
};

void A::Set(B* pB)
{
	m_pB = pB;
}

void A::funA()
{
	std::cout << "类A的funA被调用" << std::endl;
	m_pB->funB();
}

void B::Set(A* pA)
{
	m_pA = pA;
}

void B::funB()
{
	std::cout << "类B的funB被调用" << std::endl;
	m_pA->funA();
}

int main()
{
	A a;
	B b;
	a.Set(&b);
	b.Set(&a);
	a.funA();
	b.funB();
	return 0;
}

你这个程序会永无止境的循环调用下去，自己编译运行看看效果吧。

Answer 5

那是因为在此处。B类还没有定义，只有前向声明。所以只能使用B的指针，而不能使用B的对象中的任何成员。

修改你的逻辑吧。