C++复习笔记（一）

以前学习自学完c++时，没有做笔记对自己的学习做一个记录，以至于自己学完c++转学完Python，在回过头来看C++发现自己还有许多地方都不是很清楚，今天开始，每天花上2个小时对自己以前的C++内容进行复习，并做好笔记记录，进行整理，以便后面再次复习。

一、类的访问控制

public：修饰成员变量和成员函数在类的内部和外部都可以进行访问。

protected：修饰类的成员变量和成员函数只能在类的内部和子类中进行访问。

private：修饰类的成员变量和成员函数只能在类的内部使用。

当一个当类的访问控制未声明时，默认为private。

二、类的构造函数

（一）两条基本准则：

1、定义一个类之后，c++编译器会自动为我们提供一个默认构造函数、但是一旦我们重写了构造函数之后、我们写的构造函数一定会被调用、编译器不再为我们提供默认构造函数。

2、类的构造函数在实例化一个对象时会被自动调用。

（二）类的构造函数的分类与调用

1、无参构造函数    2、有参构造  3、拷贝构造

#include<iostream>
using namespace std;
class Test
{
public:
	Test()
	{
		cout << "我是无参构造函数" << endl;
	}
	Test(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "我是有参构造函数" << endl;
	}
	Test(Test &item)
	{
		this->a = item.a;
		this->b = item.b;
		cout << "我是拷贝构造函数" << endl;
	}
protected:
private:
	int a;
	int b;
};

int main()
{
	Test t1; //调用无参构造函数
	Test t2(1, 2); //调用有参构造函数
	//这里本质是初始化法初始化不是等号赋值，等号赋值需要用到拷贝函数(深浅拷贝)
	Test t3 = t2;  //调用拷贝构造函数  
	Test t4(t3);   //调用拷贝构造函数   //参数法初始化
	system("pause");
}

输出：

我是无参构造函数
我是有参构造函数
我是拷贝构造函数
我是拷贝构造函数
请按任意键继续. . .

（三）类的对象做函数参数。

类的对象做函数参数时不会去调用类的构造函数，只有当将类的对象左为实参传递给形参的时候会去调用类的拷贝构造函数。

#include<iostream>
using namespace std;
class Test
{
public:
	int a;
	int b;
	Test()
	{
		cout << "我是无参构造函数" << endl;
	}
	Test(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "我是有参构造函数" << endl;
	}
	Test(Test &item)
	{
		this->a = item.a;
		this->b = item.b;
		cout << "我是拷贝构造函数" << endl;
	}
protected:
private:

};

void func(Test item)
{
	cout << item.a << endl;
	cout << item.b << endl;
}

int main()
{
	Test t2(1, 2);  //调用类的有参构造函数
	func(t2);       //调用类的拷贝构造函数,将实参t2的值赋给形参.
	system("pause");
}

输出：

我是有参构造函数
我是拷贝构造函数
1
2
请按任意键继续. . .

（四）类的对象当做返回值时。

拷贝构造函数调用时机：

当类的对象被挡做函数的返回值时，这种情况最为复杂，牵扯到了匿名对象的生命周期。首先我们先说类的拷贝构造在什么时候被调用。

当我们的函数返回一个类的对象时，在return classObj语句执行的时候，我们C++编译器会将classOb进行一次拷贝构造，提前申请内存空间生成一个匿名对象之后，在将classObj对象进行销毁（即对classObj调用析构函数）之后，函数会将匿名对象返回出去。

#include<iostream>
using namespace std;
class Test
{
public:
	int a;
	int b;
	Test()
	{
		cout << "我是无参构造函数" << endl;
	}
	Test(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "我是有参构造函数" << endl;
	}
	Test(Test &item)
	{
		this->a = item.a;
		this->b = item.b;
		cout << "我是拷贝构造函数" << endl;
	}
	~Test()
	{
		cout << "我是析构函数" << endl;
	}
protected:
private:

};

Test func()
{
	Test t2(1, 2);  //调用类的有参构造函数
	return t2;      //调用拷贝构造，调用析构
}

int main()
{
	//函数返回一个匿名对象，因为没有被接收，返回完后匿名对象调用了析构函数。
	func();       
	system("pause");
}

输出：

我是有参构造函数
我是拷贝构造函数
我是析构函数
我是析构函数
请按任意键继续. . .

匿名对象的生存周期

通过上面的例子与说明，我们已经明白了，类的对象在做函数返回值时，有下面两点：

1、函数返回值在返回时会的调用一次类的拷贝构造，提前申请内存空间，生成一个匿名对象

2、函数返回值的本质是返回了一个匿名对象。

对于匿名对象，只不过是C++编译器提前为我们申请好的内存空间，以便加开程序的运行速度，因此，匿名对象的去与留，在于我们需不需要使用这块内存，如果需要，匿名对象会被 “ 保留 ” 下来，如果仅仅只是需要里面的值，那么匿名对象就会被析构。

#include<iostream>
using namespace std;
class Test
{
public:
	int a;
	int b;
	Test()
	{
		cout << "我是无参构造函数" << endl;
	}
	Test(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "我是有参构造函数" << endl;
	}
	Test(Test &item)
	{
		this->a = item.a;
		this->b = item.b;
		cout << "我是拷贝构造函数" << endl;
	}
	~Test()
	{
		cout << "我是析构函数" << endl;
	}
protected:
private:

};
Test func()
{
	Test t2(1, 2);  //调用类的有参构造函数
	return t2;      //调用拷贝构造，调用析构
}
void objplay1()
{
	Test t1 = func();   //这一步不是拷贝构造，是匿名对象的内存块变为"有名"(内存块重新命名)
	cout << "objplay1 执行完毕" << endl;
}
void objplay2()
{
	//当类在调用构造函数时申请了内存空间。
	Test t2;   
	t2 = func(); //使用 = 赋值
	cout << "objplay2 执行完毕" << endl;
}
int main()
{
	objplay1();
	objplay2();
	system("pause");
}

输出：

我是有参构造函数
我是拷贝构造函数
我是析构函数
objplay1 执行完毕
我是析构函数
我是无参构造函数
我是有参构造函数
我是拷贝构造函数
我是析构函数
我是析构函数
objplay2 执行完毕
我是析构函数
请按任意键继续. . .

说明：函数从objplay1开始,在objplay1结束之前，调用了一次有参构造，和一次拷贝构造，但是只调用了一次析构函数，所以，内明对象没有被析构。而objplay2 从Test t2;   开始，此时编译器已经对t2申请了内存空间，因此t2 = func();  相当用于 匿名对象作为右值，对变量进行赋值(深拷贝御前拷贝，这里调用系统提供的默认浅拷贝构造函数)。当赋值完后，匿名对象被销毁，因此在objplay2结束之前连续调用了两次析构函数，一次属于func()的返回值的，一次属于匿名对象的。

总结：

如果使用匿名对象初始化另外一个同类型的对象，那么匿名对象会被进行 “ 转正 ” ，变为有名的对象。

如果使用匿名对象去赋值另一个同类型的对象，那么匿名对象，会在赋值结束后被销毁。

三、对象的初始化列表

对象的列表初始化原因：

（1） 若果一个类B的属性是另一个类A的对象，但是A只有有参构造函数，没有默认构造函数，那么当我们实例化类B的对象时，类B无法进行构造。

（2）类成员中如果有const 修饰，必须给在类对象初始化是给const修饰的属性进行赋值。

我们来看下面代码：

#include <iostream>
using namespace std;
class A
{
public:
	A(int _a)
	{
		a = _a;
		cout << "构造函数" << "a" << a << endl;
	}

	~A()
	{
		cout << "析构函数" << "a" << a << endl;
	}

protected:
private:
	int a;
};
//1 构造函数的初始化列表  解决: 在B类中 组合了一个 A类对象 (A类设计了构造函数)
//根据构造函数的调用规则 设计A的构造函数, 必须要用;没有机会初始化A
//新的语法  Constructor::Contructor() : m1(v1), m2(v1,v2), m3(v3)
class B
{
public:
    //初始化列表
	B(int _b1, int _b2) : a1(1), a2(2), c(0)
	{
	}
    //初始化列表
	B(int _b1, int _b2, int m, int n) : a1(m), a2(n), c(0)
	{
		b1 = _b1;
		b2 = _b2;
		cout << "B的构造函数" << endl;
	}
	~B()
	{
		cout << "B的析构函数" << endl;
	}
protected:
private:
	int b1;
	int b2;
	A a2;   //是A的对象
	A a1;
	const int c;  //const修饰的属性
};

//2 先执行 被组合对象的构造函数 
//如果组合对象有多个,按照定义顺序, 而不是按照初始化列表的顺序
//析构函数 : 和构造函数的调用顺序相反
//3 被组合对象的构造顺序 与定义顺序有关系 ,与初始化列表的顺序没有关系.
//4 初始化列表 用来 给const 属性赋值 
void obj10play()
{
	//1参数传递 
	//B ojbB(1, 2);  //正确，会调用两个参数的构造函数
	B ojbB2(1, 2, 3, 4); //调用四个参数的构造函数
	//2 调用顺序
	return;
}

void main()
{
	obj10play();
	system("pause");
}

四、申请内存malloc、new和释放内存free，delete

这四个关键字语法的使用，应该都会，这里只说下其中的区别：

1、malloc申请的内存可以使用delete进行释放，new申请的内存可以使用free释放

2、new 会调用类的构造函数，而malloc不会；delete会调用类的析构函数，而free不会。

五、类的静态成员变量与静态成员方法。

类的静态成员变量：

类的静态成员变量是属于整个类的，所有该类(继承该类)的对象共同使用同一块内存(存放静态属性变量的内存)。类的静态成员变量需要对静态成员变量进行声明与初始化。

代码：

#include <iostream>
using namespace std;
class BB
{
public:
	void printC()
	{
		cout << "c:" << c << endl;
	}
	void AddC()
	{
		c = c + 1;
	}
protected:
public:
	static int c; //静态成员变量的声明
};
int BB::c = 10;   //静态成员变量的初始化


void main()
{
	BB b1, b2, b3;
	b1.printC(); //10
	b2.AddC();   //11
	b3.printC(); //11
        cout<<BB::c<< endl; //11
	system("pause");
	return;
}

输出：

c:10
c:11
11
请按任意键继续. .

类的静态成员方法：

1、静态成员方法也是属于整个类的而不是某个对象，是由同一类中的所有对象共用，因此它没有this指针。

2、在类外调用静态成员函数用 “ 类名:: ”作限定词，或通过对象调用。

3、静态成员函数不能访问非静态成员函数和非静态数据成员。

4、出现在类体外的函数定义不能指定关键字static；

#include <iostream>
using namespace std;
class BB
{
public:
	void printC()
	{
		cout << "c:" << c << endl;
	}
	void AddC()
	{
		c = c + 1;
	}
	static void getC() //静态成员函数 
	{
		cout << "c:" << c << endl;
		//请在静态成员函数中,能调用 普通成员属性  或者 普通成员函数吗?
		//cout << "a:" << a << endl; //error C2597: 对非静态成员“BB::a”的非法引用
	}
protected:
public:
	int a;
	int b;
	static int c; //静态成员变量
};
//静态函数中 不能使用 普通成员变量 普通成员函数 ..
int BB::c = 10;

void main()
{
	BB b;
	//静态成员函数的调用方法
	b.getC(); //用对象.
	BB::getC();//类::
	system("pause");
	return;
}

输出：

c:10
c:10
请按任意键继续. . .

类的静态成员方法，只能调用类的静态成员变量和静态成员方法，不能调用类的普通成员变量与方法，因为他不知道这些普通成员变量与方法是属于哪一个对象的(每个对象在创建时都会拥有所有类的普通成员变量与方法)。

造成这种现象的本质是类的普通成员变量和方法存储的位置与静态的成员变量与方法存储的位置不大一样：

普通成员变量：存储于对象之中，与struct变量有相同的内存布局和字节对齐方式。

静态成员变量：存储于全局数据区。

成员函数：存储于代码区中。

六、友元函数和友员类。

1、友员函数和友员类的声明位置(public、private、protected)与访问描述无关、也就是说类的访问控制无法控制友员函数和友员类

2、友员函数可以通过对象参数去访问类的私有数据成员。

3、如果类B是类A的友员类，那么类B中的所有方法都是类A的友员函数。

4、友员函数和友员类的声明：

      友员函数：在类内使用friend+函数声明 关键字例如

class Test
{
public:
	//友员函数的声明
	friend void getnum(Test &iteam);
protected:

private:
	int a;
};
//友员函数的实现
void getnum(Test &iteam)
{
	cout << iteam.a << endl;
}

  友员类：在类内使用friend+类名关键字例如

using namespace std;
class Test
{
public:
	//友员类的声明
	friend class B;
protected:
private:
	int a;
};
//友员类的实现
class B
{
public:
	//类B中的所有方法都是类Test的友元函数
	void getnum(Test &iteam)
	{
		cout << iteam.a << endl;
	}
protected:
private:
	int a;
};