C++学习笔记一 —— 两个类文件互相引用的处理情况

　　先记录一些零碎的知识点：

1. 一个类可以被声明多次，但只能定义一次，也就是可以 class B;  class B;  class B; ……;  class B {……};  这样子。

2. 一个类 C 的声明中（函数只声明还没定义）可以使用一个只被声明还没定义的类 B，但只能使用类 B 的指针或引用（用作函数参数或其他等等），不能是完整的对象。

3. 若类 C 的函数中需要使用到类 B 的函数，则类 B 的函数必须已定义好而不能只是声明。

#include<iostream>

class B;
class B;
class B;

class C;
class C;

class B {
public:
    void func() const {   std::cout << "B.func()" << std::endl;   }
    void func(C *c) const;  //  {  /* c->func(); */  }
    // 无法在这里直接使用 c->func()；如果强迫在同一个文件中实现的话代码结构会变得很乱
};

class C {
public:
    C() {}
    void func() const {
        std::cout << "C.func():" << std::endl;
    }
    void func(B *b) const {
        std::cout << "C.func(B *b):" << std::endl;
        b->func();
    }
    void func(const B *b) const {       // 底层 const 可以重载，顶层 const 不可以重载
        std::cout << "C.func(const B *b):" << std::endl;
        b->func();
    }
    void func(const B &b) const {
        std::cout << "C.func2(const B &b):" << std::endl;
        b.func();
    }
};


void B::func(C *c) const {
    std::cout << "B.func(C *c):" << std::endl;
    c->func();
}


int main() {
    C c;
    B b;
    b.func(&c);
    const B cb;

    c.func(&b);
    c.func(&cb);
    c.func(b);
    std::endl(std::cout);
    return 0;
}

　　因此，鉴于以上的种种规则，对于两个互相依赖难以分割的类，我们可以用一些比较规范的方法去组织项目的结构，比如对于两个类 B 和 C：

1. 在 B.h 和 C.h 两个头文件中分别声明好 class B {……} 和 class C {……} ，类内需要引用到另一个类的函数只有声明而暂时没有定义，而把这些函数的定义也就是实现全部写到 B.cpp 和 C.cpp 中（或者把所有函数的定义都放到 .cpp 文件中去）；

2. 在 B.h 头文件的顶端写上 class C; ，在 C.h 头文件的顶端写上 class B; ，也就是为要引用的类作声明，所以两个头文件如下：

class C;

class B {
public:
    void func() const {   std::cout << "B.func()" << std::endl;   }
    void func(C *c) const;
};

　　

class B;

class C {
public:
    C() {}
    void func() const  {   std::cout << "C.func():" << std::endl;   }
    void func(B *b) const ;
    void func(const B *b) const ;
    void func(const B &b) const ;
};

　　相应的 .cpp 文件如下：

void B::func(C *c) const {
    std::cout << "B.func(C *c):" << std::endl;
    c->func();
}

void C::func(B *b) const {
    std::cout << "C.func(B *b):" << std::endl;
    b->func();
}

void C::func(const B *b) const {       // 底层 const 可以重载，顶层 const 不可以重载
    std::cout << "C.func(const B *b):" << std::endl;
    b->func();
}

void C::func(const B &b) const {
    std::cout << "C.func2(const B &b):" << std::endl;
    b.func();
}

　　然后在主函数中，除了 #include "B.h" 和 #include "C.h" 外，还要依次 #include "B.cpp" 和 #include "C.cpp" ：

#include<iostream>
#include "B.h"
#include "C.h"
#include "B.cpp"
#include "C.cpp"

int main() {
    C c;
    B b;
    b.func(&c);
    const B cb;

    c.func(&b);
    c.func(&cb);
    c.func(b);
    std::endl(std::cout);
    return 0;
}

　　注意，必须先 #include 完所有的 .h 头文件才可以 #include *.cpp 文件，否则编译会报错，这是因为 *.cpp 里的都是实现，必须确实地得到相应的类或函数的定义才行，所以必须先把所有的 .h 头文件也就是所有的声明引入才可以，编译器才能按照其规则生成中间代码和进行函数的链接。（好像 cocos2d-x 中也是这样子的？）

　　可以看到，分解后的代码结构更清晰更容易维护，否则只能像第一个 main.cpp 文件一样糅合在一起，当类的数量和规模增多时难以维护。

　　C++ primer ch13 中的 Message 和 Folder 类稍后再整理，休息下准备上课了。