c++学习笔记十六——指针及深复制浅复制

什么是指针？
我们前面学习过一些基本的数据类型，如int,float,char…等等，其中int变量 存放整型数据，float类型变量存放浮点型数据，char存放字符型数据。而指针类型变量存放地址类型数据。
如何理解“地址”？
计算机的存储器被划分为一各个储存单元，储存单元按照一定的规则编号，这个编号就是储存单元的地址。地址编码的基本单元是字节，一个字节由八位二进制数组成，也就是说每一个字节是一个基本的内存单元，有一个地址。

储存结构简图
指针变量声明
指针变量用来存放内存单元地址，通过变量名访问变量属于直接访问，通过地址访问一个变量属于间接访问，声明指针的基本语句为

数据类型 * 标识符

其中，数据类型所说的是该指针地址存放的数据类型，例如

int *a;//定义一个指向整型数据的指针变量

地址相关操作符 “ * ” 和“ & ”
其中"*"称为指针运算符，也称作解析运算符，表示取指针所指向的变量值；比如 *a 则表示a指针指向的整型数据的值。“&”为取地址运算符，也是一个一元操作符，用来得到一个对象的地址。例如&i，表示取变量 i的地址。
值得注意的是以上两个运算符在声明语句和执行语句意义是不同的，“ * ”在声明语句中表示这是一个指针型的变量，例如

int * a;//声明一个指向整型数据的指针

而在执行语句中则表示若有以下语句

*a

则表示取出指针指向变量的值，同理 “&”在声明语句，表示引用。而在执行语句中则 表示取变量的地址。
指针的赋值
指针赋值的格式为
数据类型 * 变量名 = 初始地址
以下举例说明指针变量名的赋值。

int a=3;//声明整型变量并将赋值为3
int * a1= &a;//取变量a地址
//
int a[10]={0,0,0........};
int * a2=a;
//数组名为一个地址可将数组名直接赋值给整型指针变量

声明指向常量的指针

const int *p1=&a;
int b;
p1=&b;//正确，p1本身的值可以改变
*p1=3;//错误，指向常量的指针不可以改变值

使用指向常量的指针可以确保指针所指向的变量不被意外修改。
声明指针类型常量

int * const p1=&a;
p1=&b//错误，常量指针无法改变指向变量

在日常的指针声明中，为防止指针内存异常情况我们通常在声明指针时赋予初始值，如果没有初始值将指针指向空值。

int * a= NULL;

指针数组
一个数组每个元素都是指针变量，这个数组就是指针数组，指针数组每个元素必须事同一个类型的指针。

声明格式 ：
数据类型  *数组名 [下标表达式]

下面举例利用指针数组输出单位矩阵

#include <iostream>
using namespace std;
int main()
 {   
	int a1[] = {1,0,0};
	int a2[] = { 0,1,0 };
	int a3[] = { 0,0,1 };
	int * a[3] = {a1,a2,a3};
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 3; j++)
		{

		//	cout << a[i][j]<< " ";
				
			cout << a*(*(a + i) + j) << " ";
		}

		cout << endl;
	}	
}

运行结果如下

其中我定义了指针数组并以数组对其进行初始化， 上面写了两种输出方式，其中*((a + i) + j)与a[i][j]一致，其中(*(a + i) + j)表示先取出指针数组的第i个值也就是定义的每个数组的名字，接着在输出第i个数组后面的第j个值。因此需要掌握用指针访问二维数组。

指向函数的指针
故名思意，上文所介绍的指针均以指向数据的指针为主，包括指向int ,float ,char 等类型的数据，其实指针也可以指向函数。我们首先要知道，每个函数都有自己的函数名，每个函数名存放的是函数代码的首地址。而函数指针可以存放函数代码的首地址，因此可以用指针名来代替函数名。定义的格式如下：

数据类型（* 函数指针名）（形参表）

数据类型说明函数指针所指向的函数返回值类型，第一个原括号中内容指明一个函数指针的名称，形参表则列出该指针所指向函数的形参类型和个数。
以上是函数指针声明的格式以及各个参数的含义，我们会发现如果每次使用上述声明格式会显得很繁琐，因此我们可以使用typedef，格式如下：

typedef int (* DoubleIntFunction)(double);

声明了 DoubleIntFunction是一个有double形参，返回类型为int的函数的指针类型的别名，当再次需要声明这一类型的变量时可以直接使用。

 DoubleIntFunction funcptr;

下面进行举例，我编写三个不同的输出函数，分别用函数指针指向各个函数，并且使用typedef简化函数指针的声明形式，并在定义一个函数指针，之后将该指针指向一个函数输出结果，具体代码如下

#include <iostream>
using namespace std;
void print(int)
{
	cout << "这里是第一测试函数" << endl;

}

void print1(int y)
{
	cout << "这里是第二测试函数" << y <<endl;
}
void print2(int y)
{
	cout << "这里是第三测试函数" << y << endl;
}

int main()
 {   
	void(*test)(int x);//定义一个函数指针
	test = print;//将该函数指针指向第一个测试函数
	test(1);
	test = print1;//将该函数指针指向第二个测试函数
	test(1);
	test = print2;//将该函数指针指向三个测试函数
	test(1);
	typedef void(*test1)(int y);//为了方便可以将上述函数指针简化为 test1定义形式简化
	test1 a1;//定义函数指针
	a1 = print2;//将该函数指针指向第三个测试函数
	a1(3);//输出第三个测试函数
	
}

运行结果如下

可以看到输出结果上述代码只是进行简单的举例，需要掌握两个要点
1）函数指针的定义格式

数据类型 (*指针名)(指向函数形参表 )

2）使用 typedef可以简化定义步骤。

深复制与浅复制
我们在前文提到的类其中有一个复制构造函数，当时的默认复制构造函数可以满足值一一复制的要求，可以实现对象间值得一一复制。所以一直对复制构造函数的必要性一直心存疑问，事实上默认的构造函数只是浅复制，何为浅复制呢，我们通过以下例子说明

#include<cassert>
#include <iostream>
using namespace std;
class Point {
public:
	Point() : x(0), y(0) {
		cout << "DefaultConstructorcalled." << endl;
	}
	Point(int x1, int y) :x(x1), y(y) {
		cout << "Constructorcalled." << endl;
	}
	~Point() { cout << "Destructor called." << endl; }
	int getX()const { return x; }
	int getY()const{return y;}
void move(int newX,int newY) {
		x = newX;
		y = newY;
		}
private:
	int x;
	int y;
};
class ArrayofPoints {
public:
	ArrayofPoints(int size) :size(size) {
		points=new Point[size];//初始化建立动态数组1
	}
	~ArrayofPoints() {
		cout << "deleting......" << endl;
		delete[] points;//析构函数释放内存
	}
Point &element(int index) {
		assert(index >= 0 && index < size);//如果数组下标越界，程序中止
		return points[index];
	}
private:
	Point *points;
	int size;
	};

int main()
 {   
	int count;
	cout << "please input your count" << endl;
	cin >> count;
	ArrayofPoints pointsarray1(count);
	pointsarray1.element(0).move(5, 10);
	pointsarray1.element(1).move(15, 20);
	cout << "初始化化以后" << endl;
	cout << pointsarray1.element(0).getX() << endl;
	cout << pointsarray1.element(1).getX() << endl;
	ArrayofPoints pointsarray2(pointsarray1);//创建对象副本
	//输出相应元素的值
	cout << "输出复制副本对应的值" << endl;
	cout << pointsarray2.element(0).getX() << "\n" << pointsarray2.element(0).getY() << endl;
	cout << pointsarray2.element(1).getX() << "\n" << pointsarray2.element(1).getY() << endl;
	//改变原稿的值
	//pointsarray1.element(0).move(10, 50);
	//pointsarray1.element(1).move(15, 25);
	经过改变后在输出原来的值
	//cout << "再次输出值" << endl;
	//cout << pointsarray2.element(0).getX << "\n" << pointsarray2.element(0).getY << endl;
	//cout << pointsarray2.element(1).getX << "\n" << pointsarray2.element(1).getY << endl;


}

按照我以上写的代码代码会进入 ”Destructor called“，进入了死循环，造成这样的情况就是由于复制构造函数只是简单的进行值复制，若想解决该问题解决的办法是要进行地址的复制，解决办法为编写自己的复制构造函数；代码如下

ArrayofPoints::ArrayofPoints(const ArrayofPoints &v) {
	size = v.size;
	points = new Point[size];
	for (int i = 0; i < size; i++)
	{
		points[i] = v.points[i];
	}
};

按照上述复制构造函数编写可以进行地址的深复制，进行地址的复制，可以避免错误。
简单的概括深复制与浅复制可以这样理解，深复制是复制地址，浅复制只是简单的值复制。