const ， 拷贝构造函数，赋值操作符重载

	int a1 = 0;
	const int b1 = 1;

	int* p0;				// 普通指针
	const int* p1;			// 可修改所指对象，但不可修改所指对象的值
	int const* p2;			// 可修改所指对象，但不可修改所指对象的值 （与上面等价）
	int *const p3 = &a1;	// 不可修改所指对象，但可修改所指对象的值 (初始化赋值)
	
	const int *const p4 = &a1; // 即不可修改所指对象，又不但可修改所指对象的值

	/* “*”前面有const ：不可修改所指对象的值 */
	/* “*”后面有const ：不可修改所指对象 */

	p0 = &b1;	// error
	p1 = &b1;	// correct

刚开始学C++的时候总搞混，现在好久不用C++还是会忘记，好记星不如烂笔头

class TestC
{

private:
	vector< vector<int> > testVecVec;

public:
	TestC ()
	{
		vector<int> vec1;
		vec1.push_back(1);
		vec1.push_back(2);

		vector<int> vec2;
		vec2.push_back(10);
		vec2.push_back(20);

		testVecVec.push_back(vec1);
		testVecVec.push_back(vec2);
	}

	void Print () const
	{
		std::cout << testVecVec[0][0] << testVecVec[0][1] << testVecVec[1][0] << testVecVec[1][1] << std::endl;
	}

	const vector<int>& GetVectorNoConst (int index) {return testVecVec[index];}
	const vector<int>& GetVector (int index) const {return testVecVec[index];}	
};

void TestFunc (const TestC& c1)
{
	const vector<int>& v1 = c1.GetVector(0);			// correct
	const vector<int>& v2 = c1.GetVectorNoConst(0);		// error
	c1.Print();
}

1.成员函数声明后跟const ：函数内this指针为const指针，不可修改this成员变量

2.类实例作为const引用传参数，只能调用const成员函数（因为const限定不可修改）

class A
{
protected:
	int a;
	float b;
public:
	A()
	{
		std::cout << "A:构造" << std::endl;
	}

	A(int a) : a(a)
	{
		std::cout << "A:构造 a" << std::endl;
	}

	A (float b) : b(b)
	{
		std::cout << "A:构造 b" << std::endl; 
	}

	A (const A& a)
	{
		std::cout << "A:复制" << std::endl;
	}

	A& operator = (const A& a)
	{
		std::cout << "A:=" << std::endl;
		return *this;
	}
};

class B : public A
{
public:
	B()
	{
		std::cout << "B:构造" << std::endl;
	}

	B(int a)
	{
		std::cout << "B:构造 a" << std::endl; 
	}

	B(float b) : A (b)
	{
		std::cout << "B:构造 b" << std::endl;
	}


	B (const B& a)
	{
		std::cout << "B:复制" << std::endl;
	}

	B& operator = (const B& b)
	{
		std::cout << "B:=" << std::endl;
		return *this;
	}
};

子类构造函数不显示调用父类构造函数，则会默认调用无参构造函数

赋值构造函数也算构造函数，所以机制是一样的

不主动调用父类赋值构造函数会默认调用父类的无参构造函数

有点值得注意的是 A a2 = B(b)这里父类到子类的转换好像是先使用B(b)构造出一个B对象然后再调用了A的复制构造生成了a2对象

操作符重载的话，就跟普通的函数一样效果，不过可以在子类B中加一行代码

A::operator= (a)，实现父类部分的赋值操作，类似C#中调用base.()方法

发现都是些最基础的东西，自己也不算新手了，基础都不够扎实，还是要多总结然后记下来，以前总懒得做这些事情，然而现在发现想要成长还是要靠细节的积累，思考然后总结，所以打算以后多在博客中记下来工作中学习到的知识点，这个记下来的过程才会思考的更具体更全面印象也更深一点，就算忘记了也有一个回头翻阅并再迭代总结的过程。