日志20191204(4)

//编译式依赖 类的前置声明 
void test2() {
	int a = 1;
	int b = 2;
	//assert(sizeof(double) == sizeof(int));
	//static_assert(a == b, "error");	//用法错误，编译时期无法确定
	static_assert(sizeof(double) == sizeof(int), "error");
	//assert(a == b);
}

/*
编译式依赖 类的前置声明
总之：如果x.h发生了变化，所有x的对象所在的文件都需要重新编译，
但是如果x.cpp发生了变化而x.h没有发生变化，那么x的对象所在的文件
不需要重新编译。
一句话：尽可能只在.cpp中包含其他类的头文件。
另外：对于c++库，系统函数没有必要尽量只包含在.cpp中，因为c++库不会变化。

对于c++来说，主要分为.h和.cpp文件
当修改某一个.h文件时，所有依赖该.h的文件都需要重新编译
同理修改一个.cpp文件时，所有依赖该.cpp文件都需要重新编译，
然而，.cpp文件编译会生成.o文件，链接时候调用，另一方面，
直接依赖.cpp文件进行编译的比较少，所有修改文件时，尽可能
只在.cpp文件中修改，将其他文件的编译式依赖降到最低。

实例如下：
原型：
//a.h
class A{...};

//b.h
#include "a.h"
class B{
	...
public:
	void func(A a);
private:
	A a;
}

当a.h发生变化时，则b必须要重新编译，b中有A a这个成员，
同理，其他所有依赖a.h的文件都需要重新编译（含A a等）。

方案一：
//a.h
class A{...};

//b.h
class A;
class B{
	...
public:
	void func(A a);
	~B(){ delete a };
private:
	A* a;
}

此时类B就不需要知道A的大小，因为其成员只是一个指针（32位为4字节）。
当a发生修改时，b就不需要重新编译，如果b.cpp中调用了a->func()函数，
b.cpp需要重新编译，b.cpp依赖的是a.o这个库，a发生了改变，需要
重新编译a和b即可，但是所有依赖b.h的文件都不需要编译，避免了连锁反应，
只在一层关系中终止，满足松耦合的关系。
a发生了变化，b依赖a，b需要重新编译，如果c只依赖了b.h，而b.cpp中用到了
a.h，b.h中没有用到a.h，所以c不需要重新编译。

总之：如果x.h发生了变化，所有x的对象所在的文件都需要重新编译，
但是如果x.cpp发生了变化而x.h没有发生变化，那么x的对象所在的文件
不需要重新编译。
一句话：尽可能只在.cpp中包含其他类的头文件。
另外：对于c++库，系统函数没有必要尽量只包含在.cpp中，因为c++库不会变化。

*/

/*
如果想禁止一个类拷贝或者=
class A{
...
private:
	A(const A& rhs);	//只声明，不定义，私有
	A& operator=(const A& rhs);//同上
}
或者
class B{
...
private:
	B(const B& rhs) = delete;
	B& operator=(const B& rhs) = delete;
}

*/


int main() {
	//test2();

	system("pause");
	return 0;
}