关于c++的class(偏c++11以前，构造、静态成员、const、初始化列表、友元、内联、template)

1、构造：

构造分为三种：

1、自定义构造和拷贝构造：

体现为构造函数参数自定义。没什么说的，注意构造函数的调用顺序，当有继承关系时，构造时是从子类到基类，析构时是从基类到子类；构造函数不可以出现任何静态、const、virtual之类的修饰。

这里主要注意的是，构造函数是会隐式构造的，如

		class A {
		public：
			void test () {
				std::cout << std::endl；
			}
		}
		A a;
		a.test();//毫无问题

但如果改成：

		class B {
    			int *data;
		public:
		    B (int n) {
	    	        data = new int[n];
		    }
		    ~B () {
		        delete []data;
		    }
		    void test () {
		        if (data) {
		            std::cout << data << std::endl;
		        }
		    }
		};

现在创建一个对象并调用test方法：

B b = 3;

b.test();

输出：0x613c20

然后再创建一个新对象，用已创建对象拷贝构造，也调用test方法：

B bb = b;

bb.test();

输出：0x613c20，和第一个一样，也就是说如果不自己重载拷贝构造函数，默认的拷贝构造函数，是新对象内数据，是传入对象的引用

至此貌似一切正常，然而执行时发现double free......

用gdb观察：

b和bb，data成员的地址是同一个。。。。。

开启layout观察变量退栈过程，首先看到的是后创建的对象bb的析构，它首先delete []data，然后对象b的析构，二次delete.......

结论：要尽可能自己重载拷贝构造函数，尤其对于类成员变量涉及动态资源的时候。

然后，B b = 3;的创建方式，看起来很奇怪，事实上它等价于：

B b(3);

这个方式是不是看起来感觉很"正常"，这种是显示调用构造函数，而上面的“怪异”的方式是隐式调用构造函数。

结论：尽可能避免隐式调用构造函数，有的时候可能造成错误，也就是程序写成这样，最好不要让它通过编译，方法：加入explicit关键字修饰所有的构造函数：

		class B {
    			int *data;
		public:
		    explicit B (int n) {
	    	        data = new int[n];
		    }
		    ~B () {
		        delete []data;
		    }
		    explicit B (const B &other) {
		        sz = other.sz;
		        data = new int[sz];
		    }
		    void test () {
		        if (data) {
		            std::cout << data << std::endl;
		        }
		    }
		};

2、赋值构造函数：

对于对象的重赋值，即对"="的运算符重载，调用的是赋值构造函数如下：

    C &operator=(const C &other) {
        //must do
        if (&other == this) {
            return *this;
        }

        delete []data;
        int sz = other.GetSize();
        int *_data = other.GetData();
        data = new int[sz];
        size = sz;
        memcpy(data, _data, sizeof(int) * sz);
    }

赋值构造函数最重要的是， 一定不要省略地址比较的部分，否则有可能出现重大问题而且不易发现。