C++，类的前置声明，c++继承，c++子类访问父类成员变量，c++头文件相互包含

假设声明两个类A和B，如果需要在A.h中定义B类对象，B b_; 势必要包含# include “B.h”，而B类中需要定义A类对象A a_; 也要包含B.h，但是相互包含是不允许的，称为环形引用，这时候就用到了前向声明

1，a.h 类A中实例化类B的对象

#ifndef __A_H__
#define __A_H__

#include <iostream>
#include <stdio.h>
#include "b.h" //类A中要实例化一个类B的对象

class BasicA {
protected:
    int m_a = 1;
public:
    void print_a2() {
        std::cout << "a2:" << m_a << std::endl; 
    };
};

class A : public BasicA {
private:
    B m_b;//例化一个类B的对象
public:
    A();
    ~A();
    void print_a();
    void print_this();
};
#endif

2，a.cpp 可以调用类B对象的方法

A::A() {
    std::cout << "this->p:" << (void *)&m_a << std::endl;
    m_b.set_a(this); //将类A的真实指针传给类B
}
A::~A(){
}
void A::print_a() {
    m_a = 2;
    std::cout << "a:" << m_a << std::endl; 
    m_b.print_b(); //调用类B对象的方法
}
void A::print_this() {
    std::cout << "a this" << std::endl;
}

3，b.h 类B中不能实例化类A的对象

#ifndef __B_H__
#define __B_H__
#include <iostream>

class A; //类A的前置声明

class B{
private:
    int m_b = 1;
    A *m_a; //定义一个类A的指针，用作占位
public:
    B();
    ~B();
    void set_a(A *a); //用于将实际的类A的指针传进来
    void print_b();
};
#endif

4，b.cpp 中包含a.h，这样就可以使用类A对象中的方法

#include "b.h"
#include "a.h"

B::B(){}
B::~B(){}

void B::set_a(A *a) {
    m_a = a;
    std::cout << "ma->p:" << (void *)m_a << std::endl;
}

void B::print_b() {
    std::cout << "b:" << m_b << std::endl; 

    m_a->print_this(); //使用类A对象的方法
}

5，main.cpp

#include <iostream>
#include "a.h"

int main() {
    A a;
    a.print_a2();
    a.print_a();
    std::cout << "111111111111111111111111" << std::endl;
}

6，运行