清华大学C++语言程序设计（第六单元随堂笔记指针）

指针

指针是c++从c语言中继承过来的极其重要的数据类型，它提供了一种极为直接的地址操作手段。

指针变量的声明

指针也是一种数据类型，具有指针类型的变量称为指针变量，指针变量是用来储存内存单元的地址的。

声明指针的语法是：

数据类型 *标识符

”*“表示声明的是一个指针类型的变量。数据类型可以是任意类型的，指的是指针所指向的对象的类型。

如：

int * ptr;

”*“指针运算符

”&“取地址符 ”&”出现在变量声明的左边时表示的是引用。 “&”放在等号右边或者是在执行语句中作为一元运算符出现时。表示取对象的地址。

可以声明指向常量的指针，但是不能通过指针来改变所指对象的值，但是指针本身可以改变，可以指向另外的对象。

int a;
const int *pi=&a;
int b;
pi=&b;   //pi的值本身可以改变
*pi=1;  //不能通过更改pi来更改pi所指值的对象

指针类型的常量

int *const p2=&a;
p2=&b;   //错误,p2是指针常量但不能改变

指向const常量的指针

#include<iostream>
using namespace std;
int main() {
	const int a = 2;
	int *ptr = &a;   //报错int类型的指针不能兼容const int数据

}

###上边两个例子好好对比一下，可以看出来这两个区别

指针的运算

指针是一种数据类型。与其他数据类型相似，指针变量也可以参加部分运算，包括算数运算，关系运算，和赋值运算。

指针可以进行加减运算，但是运算的规则是比较特殊的。p1+n1它表示的是指针p1当前所指位置的前n1个数的地址。它可以写作：p1[n1]同理也有减法。

空指针的指定：

int *p;
p=0;    //将p设为空指针，不指向任何地址
或者
p=NULL;

#如果不便于用一个有效的地址给一个指针变量赋初值，那么用当前0作为它的初值，从而避免指向一写极其神奇的值

用指针处理数组

#include<iostream>
using namespace std;
int main() {
	int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
	for (int *i = a; i < (a + 10); i++) {
		cout << *i << endl;
	}
}

指针数组

语法形式：

数据类型 *数组名[下标表达式];

下列语句：

int *pa[3]; //说实在的这个等于一个二维数组

**注意：**由于指针数组的每一个元素都是一个指针，必须先赋值后引用，因此，声明数组之后，对指针元素赋值是必不可少。

例：6-8 利用指针数组输出单位元素

#include<iostream>
using namespace std;
int main() {
	int line[] = { 1,2,3,4,5 };
	int line1[] = { 1,2,3,4,5 };
	int line2[] = { 1,2,3,4,5 };
	int line3[] = { 1,2,3,4,5 };
	int *array[4] = { line, line1,line2,line3 };
	for (auto e : array) {
		for (int *i = e; i < (e+5); i++) {
			cout << *i << " ";
		}
		cout << endl;
	}
}

用指针作为函数参数

例：分离整数小数

#include<iostream>
using namespace std;
void splitfloat(float x, float &intpart, float &fracpart) {
	intpart = static_cast<int>(x);
	fracpart = x - intpart;
}
void splitfloat2(float x, float *intpart, float *fracpart) {
	*intpart = static_cast<int>(x);
	*fracpart = x - *intpart;
}
int main() {
	float intpart;
	float fracpart;
	splitfloat(2.8, intpart, fracpart);
	cout << "整数部分为：" << intpart << ",小数部分为：" << fracpart << endl;
	float *intpart1=NULL;
	float *fracpart1=NULL;
	splitfloat2(3.2, intpart1, fracpart1);
	cout << "整数部分为：" << *intpart1 << ",小数部分为：" << *fracpart1;

#这两个函数可以对比一下区分一下这个区别

指针型函数

指针型函数的一般定义形式是：

数据类型 *函数名(参数表){

函数体；

}

这样可以返回一个指针函数

指向函数的指针

在程序执行的过程中，不仅数据需要占据内存空间，执行程序的代码也被调入内存并且占据一定的空间。没以恶搞函数都有一个函数名（除了lamba函数除外），实际这个函数名就表示代码在内存中的起始地址。

声明一个函数指针时，也需要说明函数的返回类型，第一个圆括号中的内存指明一个函数指针的名称，形参数列表，其一般语法如下：

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

给复杂的函数起别名：

###*typedef int(fuction1)(int,int);

fuction1 fuc1;####

例：指向函数的指针的应用

#include<iostream>
using namespace std;
typedef int(*fuction1)(int,int);
int sum(int x, int y) {
	return x + y;

}
int dif(int x, int y) {
	return x - y;
}
int main() {
	fuction1 fuc1;
	int(*func2)(int, int);
	fuc1 = sum;
	int x=1, y=2;
	cout << "第一个func函数" << fuc1(x, y)<< endl;
	fuc1 = dif;
	cout << "第二个func函数" << fuc1(x, y)<< endl;
	func2 = sum;
	cout << "func2函数输出结果" <<func2(x,y) <<endl;
}

对象指针

一般语法格式：

类名 *对象指针名；

例：

point &p1;
point p2;
pi=&p2;

就像通过对象名访问对象的成员一样，使用对象指针一样可以方便的访问对象成员，语法形式为：

对象指针->成员名

例：利用指针去访问成员

#include<iostream>
using namespace std;
class Point {
public:
	Point(float x1, float y1) {
		x = x1;
		y = y1;
	}
	float getx() {
		return x;
	}
	float gety() {
		return y;
	}
	void change(int x1, int y1) { x = x1, y = y1; };
private:
	float x;
	float y;
};
int main() {
	Point *p1;
	Point p2(1,2);
	p1 = &p2;
	p1->change(3, 4);
	cout << "点更改后的值(" << p2.getx() << "," << p2.gety() << ")";
}

前向引用的另一个解决方法：

class Fred;
class BARNEY{
    Fred *x;   //错误，fred的定义不完善
}
class Fred{
	BARNEY y;
}

改后
    class Fred;
class BARNEY{
    Fred *x;   
}
class Fred{
	BARNEY y;
}
//这个如果换成一个指针的话，就可以解决了。

this指针

this指针是一个隐含于每一个类的非静态成员函数中的特殊指针（包括构造函数和析构函数）它用于指向被成岩函数操作的对象。

而类的成员函数调用，私有函数成员的过程可以看成一个this->私有函数成员，而成员函数可以看成多了一个参数，如：点类中 getx()可以看作 getx(this->x)

this指针明确指出了成员函数当前操作的数据所属的对象。实际可以看成this指针为类的隐藏参数。

##当局部函数和类成员函数重名是可以通过this调用来唯一标识

Point(int x,int y){
    this->x=x;
    this->y=y;
}

指向类的非静态成员的指针

这个和指向对象的指针一样，不在细细阐述来个例子吧。

#include<iostream>
using namespace std;
class Point {
public:
	Point(float x1, float y1) {
		x = x1;
		y = y1;
	}
	float getx() {
		return x;   
	}
	float gety() {
		return y;
	}
	void change(int x1, int y1) { x = x1, y = y1; };
	static void show() { //静态函数成员很标准的一个特征是不能出现私有的x和y
		cout <<"这是一个静态成员函数";
	}
	 
private:
	float x;
	float y;
};

int main() {
	void (*funcptr)() = Point::show;
	float (Point::*funcptr)()  = &Point::getx;
 //这两种成员函数的指针需要好好考虑一番

}

动态分配内存

简而言之就是堆对象的操作。

动态分配内存的两个十分重要的运算符：new， delete

运算符new的功能是动态分配内存，或者称为动态创建堆对象，语法格式为：
new 数据类型 （初始化参数）;

该语句在程序运行的过程中申请分配用于存放只当类型数据的内存空间，并且根据初始化参数列表中给出的值进行初始化。如果申请内存成功，new运算便会返回一个指向新分配内存首地址的类型的指针，可以通过这个指针对堆对象进行访问；

如：

int *point;
point=new int[2];  //申请一个int内存，并把初值设为2
point=new int;   //分配内存空间但是不希望其有初值
point=new int();  //用零对该对象初始化

#注意：#在用new建立一个类的对象时，如果该类存在在用户定义的默认构造函数，则“new T”和“new T()”的效果是相同的都会调用这个默认构造函数。但，若调用用户未定义的默认构造函数，使用“new T”创建对象时，会调用系统默认生成的隐含构造函数，若用“new T（）”系统会额外未基本数据类型和指针类型成员用0赋值，而且这一过程是递归的。也就是说，如果该对象的某个成员对象也没有用户定义的默认构造函数，那么对该成员对象的基本数据类型和指针类型的成员，同样也会被以0赋初值。#

运算符delete用来删除由new建立的对象，释放指针所指向的内存空间。格式为：

delete 指针名;

如果删除的是对象，则该对象的析构函数会被调用。对于new创建的对象，只能使用delete进行一次删除操作，反之会导致运行出错。

#注意：new对象分配的内存，必须用delete删除加以释放，否则可能会导致动态分配的内存无法回收，使程序占的内存越来越大（是不是可以利用这一点创建一个占内存的病毒？）

使用new也可以创建数组类型的对象，这时候需要给出数组的结构说明，用new运算创建一维数组的语法形式：
new 类型名 [数组长度];

#这个后面也可以加小括号但是括号不能加任何参数，加小括号意味这全部以0赋值#

用new创建的数组，用delete删除时在指针前面加“[]"，格式如下：

delete [] 指针名

深复制和浅复制

简单而说深复制和浅层复制就是由指针指向而产生的问题，如果用指针在类里面，会出现复制的类的指针仍然指向原先的地址，但是，实际上，应该指向的是一个新分配的地址，这就是浅复制和深复制的区别。

解决这样的问题的方法，就是在构造函数中，要为指针类型的成员，分配专门的空间。以这条规则构建的复制，称作为深复制！

Test(const Test& C)
    {
        a=C.a;
        str=new char[strlen(C.str)+1];   //给str分配一个新的内存空间
        strcpy(str,C.str);               //把str给c.str
    }
    ~Test()
    {
        delete []str;                  //把str对象删除
    }

string类和vector类

这两个类看开发者文档即可，开发者文档才是yyds

一个关于vector很好的博客