C++指针详解

c++的指针其实和c语言的指针基本相同

我们可以看看c语言的指针：http://t.csdnimg.cn/0PrV7

 什么是指针？

C++中的指针是一个变量，用于存储另一个变量的内存地址。

通过指针，可以间接访问和修改变量的值。

我们口语中的指针是指的是指针变量，指针变量的值是个地址

指针变量的声明需要指定所指向的变量类型，例如int、char等。

指针变量的声明格式为：

指针变量所指向的变量类型 *指针变量名;

*和指针名之间的空格可有可无

与指针相关的运算符

通过取址操作符&，可以获得变量的内存地址。

例如，对于一个整型变量x，可以通过&x表示其内存地址。

解引用操作符*

指针名代表该指针指向的地址，*指针名代表指针指向的对象

比如

int*a=&b;

*a就代表变量b，a代表b的地址

辨别指针的类型和指针指向的类型

指针的类型

把指针声明里的指针名去掉就是指针的类型

比如

int*a;//int*型指针
char*b;//char*指针

 指针指向的类型

把指针声明里的*指针名去掉就是指针指向的类型

比如

int*a;//指向的是int类型
char*b;//指向的是char类型

指针类型的意义

1，指针类型决定了指针在被解引用时访问几个字节；

比如

int*的指针被解引用时只能访问一个int类型的大小（即4个字节）

char*的指针被解引用时只能访问一个char类型大小（即1个字节）

2.指针类型决定了指针加减操作时跳过几个字节

比如

char*a，则a+1时跳过1个字节

int*a，则a+1时跳过4个字节

我们可以看个例子

int n[2] = { 1,2 };
int* w = n;
printf("%d %d", *w, *(w + 1));

运行结果

1 2

 指针的大小

在C语言中，不同类型的指针在内存中占用的大小是相同的，即指针的大小不依赖于指向的数据类型。

无论是指向char、int、float或其他类型的指针，在32位系统上占用4个字节（32位，即x86），在64位系统上占用8个字节（64位，即x64）。

 printf("%zd\n", sizeof(int*));
 printf("%zd\n", sizeof(char*));
 printf("%zd\n", sizeof(float*));

在32位系统（x86）上是

4
4
4

在64位系统（x64）上是

8
8
8

这是因为指针的作用是存储另一个变量的内存地址，而内存地址的大小是由系统的位数决定的。

指针存储的是一个地址值，不论指针指向的数据类型的大小如何，指针本身的大小都是固定的。

指针大小的固定性使得在C语言中可以实现通用的指针操作和类型转换。

需要注意的是，指针变量本身的大小是固定的，但指针所指向的内存区域的大小取决于指针指向的数据类型。对于一个指向int类型的指针，它所指向的内存区域大小是sizeof(int)。指针的大小只是存储指针所需的内存空间，而不是指针所指向的数据的大小。

初始化

在C++中，指针可以通过以下方式进行初始化：

1. 指向已有变量的指针初始化：可以将指针指向已经存在的变量。例如：

int x = 5;
int* ptr = &x;  // ptr指向变量x

1. 动态分配内存初始化：可以使用new操作符动态分配内存，并将指针指向该内存。例如：

int* ptr = new int;  // 动态分配一个int类型的内存空间

1. 初始化为null指针：可以将指针初始化为nullptr，表示它不指向任何有效的内存。例如：

int* ptr = nullptr;  // 或 int* ptr = NULL;

1. 初始化为指向数组的指针：可以将指针初始化为指向数组的首地址。例如：

int arr[5] = {1, 2, 3, 4, 5};
int* ptr = arr;  // ptr指向数组arr的首地址

需要注意的是，在使用指针之前，应该确保指针已经初始化，并且指向了有效的内存地址。

否则就将指针设置为空指针

注意

建议：初始化所有指针
使用未经初始化的指针是引发运行时错误的一大原因。
和其他变量一样，访问未经初始化的指针所引发的后果也是无法预计的。通常这一行为将造成程序崩溃，而且一旦崩溃，要想定位到出错位置将是特别棘手的问题。
在大多数编译器环境下，如果使用了未经初始化的指针，则该指针所占内存空间的当前内容将被看作一个地址值。访问该指针，相当于去访问一个本不存在的位置上的本不存在的对象。糟糕的是，如果指针所占内存空间中恰好有内容，而这些内容又被当作了某个地址，我们就很难分清它到底是合法的还是非法的了。
因此建议初始化所有的指针，并且在可能的情况下，尽量等定义了对象之后再定义指向它的指针。如果实在不清楚指针应该指向何处，就把它初始化为nullptr或者0，这样程序就能检测并知道它没有指向任何具体的对象了。

赋值

在C++中，指针可以通过以下几种方式进行赋值：

1. 赋值给已经存在的变量的指针：可以将指针指向已经存在的变量。例如：

int x = 5;
int* ptr;
ptr = &x;  // ptr指向变量x

1. 动态分配内存赋值：可以使用new操作符动态分配内存，并将指针指向该内存。例如：

int* ptr;
ptr = new int;  // 动态分配一个int类型的内存空间

1. 指针之间的赋值：可以将一个指针赋值给另一个指针。例如：

int* ptr1;
int* ptr2;
ptr1 = new int;
ptr2 = ptr1;  // ptr2指向ptr1指向的内存空间

1. 赋值为null指针：可以将指针赋值为null，表示它不指向任何有效的内存。例如：

int* ptr;
ptr = nullptr;  // 或 ptr = NULL;

需要注意的是，在进行指针赋值操作时，应确保指针指向的内存是有效的，并且在使用指针之前进行了初始化。同时，指针赋值只是将指针指向的内存地址进行了复制，而不是复制内存中的内容。

赋值和初始化的注意点

给指针赋值或者初始化时，除了两种例外情况，其他所有指针的类型都要和它所指向的对象严格匹配

	int a = 9;
	char *r= &a;//这是不可以的

 

int a = 9;
char *r;
r = &a;//这是不可以的

第一种例外情况 

 第一种例外情况是允许一个指向常量的指针指向一个非常量的变量

	int a = 9;
	const int* b = &a;//可以

	const int c = 8;
	const int* d = &c;//可以

注意这种情况，除了常量属性不同以外，指针的类型都要和它所指向的对象严格匹配

也就是说，下面这种情况是不可以的

int a = 9;
const float* b = &a;//不可以
const char* c = &a;//不可以

第二种例外情况 

第二种例外情况发生在基类和派生类之间

在公有继承中，基类指针可以指向派生类对象（注意只能是公有继承）

class AA{};
class BB:public AA{};

int main()
{
	BB d;
	AA* e = &d;//可以
}

解引用

在C++中，指针解引用是指通过指针获取指针所指向的变量的值。

可以使用*运算符来对指针进行解引用操作。

下面是使用指针解引用的示例：

int num = 10;  // 定义一个整型变量 num
int *ptr = #  // 定义一个指向 num 的指针 ptr

printf("num 的值为：%d\n", num);  // 直接输出 num 的值
printf("ptr 所指向的变量的值为：%d\n", *ptr);  // 通过指针解引用输出 num 的值

在上面的示例中，通过*ptr可以获取指针ptr所指向的变量num的值。在将指针解引用后，可以像操作普通变量一样使用解引用后的值。

需要注意的是，在对指针进行解引用之前，应确保指针指向的内存是有效的。否则，解引用无效的指针可能会导致程序崩溃或未定义的行为。

指针和整数相加

在C++中，指针和整数是可以进行相加的。

当一个指针和一个整数相加时，指针的地址值会根据整数的值进行偏移。偏移的单位是指针所指向类型的字节大小。

例如，如果一个指针指向一个整型变量，该整型变量占用4个字节，则相加操作会根据整数值乘以4来改变指针的地址值。

下面是一个示例：

int arr[] = {1, 2, 3, 4, 5};  // 定义一个整型数组
int *ptr = arr;              // 定义一个指向数组的指针，初始指向数组的第一个元素

// 将指针向前移动两个元素
ptr = ptr + 2;

printf("ptr 所指向的值为：%d\n", *ptr);  // 输出 ptr 所指向的值（即数组的第三个元素）

ptr+2和&arr[2]等价

在上面的示例中，ptr指向整型数组arr的第一个元素。通过将ptr与整数2相加，可以使指针向前移动两个元素的偏移量，即指向数组的第三个元素。通过对指针进行解引用，可以获取到新的位置的值。

需要注意的是，指针与整数相加时，结果的类型仍然是指针类型。根据指针所指向的数据类型的大小，相加的整数会根据数据类型的大小进行调整。

指针和整数相减

在C++中，指针减去一个整数的操作被称为指针的算术运算。其规则如下：

当一个指针减去一个整数时，整数的值将乘以指针指向的数据类型的大小，然后将所得结果从指针的值中减去。最终的结果是一个新的指针，指向原来指针所指向的位置减去整数的大小。

例如，假设有一个指针p指向一个int类型的数据，它的地址是0x1000，那么p - 2的结果将是一个新的指针，指向地址为0x1000 - 2 * sizeof(i的位置。nt)

看个例子

 int arr[] = { 1, 2, 3, 4, 5 };  // 定义一个整型数组
 int* ptr = &arr[2];              // 定义一个指向数组的指针，初始指向数组的第一个元素

 // 将指针向前移动两个元素
 ptr = ptr -2;

 printf("ptr 所指向的值为：%d\n", *ptr);

这里ptr-2相当于&arr[0]

运行结果是 

ptr 所指向的值为:1

同样需要注意，进行指针的算术运算时，必须确保指针指向的内存是有效的，否则结果是未定义的。此外，指针的算术运算还要遵守指针的合法性和边界条件，以避免访问非法内存。

递增指针

在C++中，可以使用递增操作符（++）来递增指针。

递增指针会使指针指向下一个元素或下一个位置。

示例代码如下所示：

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;  // 指向数组的第一个元素

ptr++;  // 递增指针，指向数组的第二个元素

printf("%d\n", *ptr);  // 输出：2

在上述示例中，开始时，指针ptr指向数组的第一个元素。通过递增操作符（++），指针ptr的值增加了一个元素的大小（假设int类型占4个字节），指针现在指向了数组的第二个元素。

需要注意的是，递增操作符（++）不仅可以递增指针，还可以递增指向数组、字符串或者任何连续内存块的指针。另外，递增操作也可以应用于指针变量本身，而不仅仅是指向的内容。

示例代码如下所示：

int x = 10;
int *ptr = &x;  // 指向整型变量x

ptr++;  // 递增指针，指向下一个整型变量的地址

printf("%d\n", *ptr);  // 输出：未定义，因为ptr指向了未经初始化的内存

在上述示例中，指针ptr开始时指向整型变量x。通过递增操作符（++），指针ptr的值增加了一个整型变量的大小（假设int类型占4个字节），指针现在指向了未经初始化的内存。因此，对指针解引用会产生未定义的行为。

递减指针

在C++中，可以使用递减操作符（--）来递减指针。递减指针会使指针指向上一个元素或上一个位置。

示例代码如下所示：

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = &arr[4];  // 指向数组的最后一个元素

ptr--;  // 递减指针，指向数组的倒数第二个元素

printf("%d\n", *ptr);  // 输出：4

在上述示例中，开始时，指针ptr指向数组的最后一个元素。通过递减操作符（--），指针ptr的值减少了一个元素的大小（假设int类型占4个字节），指针现在指向了数组的倒数第二个元素。

需要注意的是，递减操作符（--）不仅可以递减指针，还可以递减指向数组、字符串或者任何连续内存块的指针。另外，递减操作也可以应用于指针变量本身，而不仅仅是指向的内容。

示例代码如下所示：

int x = 10;
int *ptr = &x;  // 指向整型变量x

ptr--;  // 递减指针，指向上一个整型变量的地址

printf("%d\n", *ptr);  // 输出：未定义，因为ptr指向了未经初始化的内存

在上述示例中，指针ptr开始时指向整型变量x。通过递减操作符（--），指针ptr的值减少了一个整型变量的大小（假设int类型占4个字节），指针现在指向了未经初始化的内存。因此，对指针解引用会产生未定义的行为。

指针求差

在C++中，可以使用减法操作符（-）来计算两个指针之间的差值。这个差值表示两个指针之间相隔的元素个数，而不是它们之间的字节数。

具体用法如下：

int arr[5] = {1, 2, 3, 4, 5};
int *ptr1 = &arr[1];  // 指向数组的第二个元素
int *ptr2 = &arr[4];  // 指向数组的最后一个元素

int diff = ptr2 - ptr1;  // 计算指针之间的差

printf("%d\n", diff);  // 输出：3

在上述示例中，ptr1指向数组的第二个元素，ptr2指向数组的最后一个元素。通过将ptr2减去ptr1，可以得到它们之间的差值，即3。这表示从ptr1移动到ptr2需要3个元素的距离。

需要注意的是，两个指针只有在指向同一数组（或数组的结尾位置）中的元素时，才能进行指针相减操作。否则，结果将是未定义的。

另外，指针相减的结果是一个整数类型，表示两个指针相差的单位个数，并不是指向元素的实际大小。

指针关系运算

在C++中，指针比较的规则如下：

1. 相等性比较：使用"=="运算符可以比较两个指针是否指向同一个内存地址。如果两个指针指向同一个内存地址，比较的结果为真（1），否则为假（0）。

2. 不等性比较：使用"!="运算符可以比较两个指针是否指向不同的内存地址。如果两个指针指向不同的内存地址，比较的结果为真（1），否则为假（0）。

3. 大小比较：使用">"、">="、"<"和"<="等运算符可以比较两个指针所指向的内存地址的大小关系。这里的比较是基于内存地址的值的大小。

   • 如果两个指针指向数组中的不同元素，那么比较的结果取决于它们指向的元素在数组中的相对位置。
   • 如果两个指针指向同一个数组中的不同元素，那么比较的结果取决于它们指向的元素在数组中的索引位置。
   • 如果两个指针都指向不同的数组，那么它们之间的比较没有定义。

需要注意的是，指针比较操作只有在指针指向的内存地址属于同一个数组或同一个对象时才有意义。否则，比较的结果是未定义的。因此，在进行指针比较之前，应该确保指针引用的对象是有效的。

下面是一些C++中指针关系运算的例子：

1. 判断两个指针是否相等：

int* p1 = NULL;
int* p2 = NULL;
if (p1 == p2) {
  // 两个指针相等
}

1. 判断两个指针是否不相等：

int* p1 = NULL;
int* p2 = NULL;
if (p1 != p2) {
  // 两个指针不相等
}

1. 比较两个指针的大小关系：

int arr[5] = {1, 2, 3, 4, 5};
int* p1 = &arr[0];
int* p2 = &arr[2];
if (p1 < p2) {
  // p1指向的元素在p2指向的元素之前
}
if (p1 > p2) {
  // p1指向的元素在p2指向的元素之后
}
if (p1 <= p2) {
  // p1指向的元素在p2指向的元素之前或相等
}
if (p1 >= p2) {
  // p1指向的元素在p2指向的元素之后或相等
}

这些例子演示了C++中指针关系运算符的用法。需要注意的是，在进行指针关系运算之前，必须确保指针是有效的，即它指向的内存是有效的。否则，结果是未定义的。

空指针

在C++中，空指针是指没有指向任何有效对象或函数的指针。空指针用NULL宏表示，其实质是一个整型常量0。

以下列出几个生成空指针的方法：

int *pl = nullptr; //等价于int *pl = 0；
int *p2 =0； // 直接将p2初始化为字面常量0
// 需要首先#include <cstdlib>
int *p3 = NULL; //等价于int *p3=0；

nullptr，0，NULL可以赋给任意类型的指针
 

得到空指针最直接的办法就是用字面值nullptr来初始化指针，这也是C++11新标准刚刚引入的一种方法。nullptr是一种特殊类型的字面值，它可以被转换成任意其他的指针类型。

另一种办法就如对p2的定义一样，也可以通过将指针初始化为字面值0来生成空指针。
过去的程序还会用到一个名为NULL的预处理变量(preprocessor variable)来给指针赋值，这个变量在头文件cstdlib中定义，它的值就是0。

当用到一个预处理变量时，预处理器会自动地将它替换为实际值，因此用NULL初始化指针和用0初始化指针是一样的。

在新标准下，现在的C++程序最好使用nullptr，同时尽量避免使用NULL。

把int变量直接赋给指针是错误的操作，即使int变量的值恰好等于0也不行。

int zero=0；
pi = zero; //错误：不能把int变量直接赋给指针

需要注意的是，对空指针进行解引用操作（如*ptr）是非法的，会导致程序崩溃或未定义行为。因此，在使用指针之前，应始终确保它不为空。

void*指针

void*是一种特殊的指针类型，可用于存放任意对象的地址。一个void*指针存放着一个地址，这一点和其他指针类似。不同的是，我们对该地址中到底是个什么类型的对象并不了解：
 

double obj = 3.14, *pd = &obj；
// 正确：void*能存放任意类型对象的地址
void *pv = &obj; // obj可以是任意类型的对象
pv = pd; // pv可以存放任意类型的指针

利用void*指针能做的事儿比较有限：拿它和别的指针比较、作为函数的输入或输出，或者赋给另外一个void*指针。不能直接操作void*指针所指的对象，因为我们并不知道这个对象到底是什么类型，也就无法确定能在这个对象上做哪些操作。
 

概括说来，以void*的视角来看内存空间也就仅仅是内存空间，没办法访问内存空间中所存的对象

指向任意非常量的指针都能被转换为void*；指向任意对象的指针都能被转换为const void*

const与指针

在C++中，const关键字可以与指针结合使用，用于声明指向常量的指针或常量指针。

指向常量的指针：

使用const修饰指针所指向的内容，表明指针所指向的内容是不可修改的。

const int* p; // 指向常量的指针，p指向的内容不可修改，但p本身可修改
int num = 5;
p = # // 合法
*p = 10; // 非法，指针指向的内容不可修改

p可改，*p不可改

常量指针：

使用const修饰指针本身，表明指针本身是不可修改的。即指针指向的地址不可修改。

int* const p; // 常量指针，p本身不可修改，但p指向的内容可修改
int num = 5;
p = &num // 非法，不可改变指针指向
*p = 10; // 合法，指针指向的内容可修改

p不可改，*p可改

指向常量的常量指针：

既不允许修改指针本身，也不允许修改指针所指向的内容。

const int* const p; // 指向常量的常量指针，p本身和p指向的内容都不可修改
int num = 5;
p = &num // 非法，指针本身不可修改
*p = 10; // 非法，指针指向的内容不可修改

p和*p都不可改

通过使用const关键字可以灵活地控制指针所指向的内容是否可修改，以及指针本身是否可修改。常量指针和指向常量的指针在函数参数传递中特别有用，可以避免不必要的修改。

顶层const和底层const

用名词顶层 const 表示指针本身是个常量，而用名词底层const表示指针所指的对象是一个常量。

更一般的，顶层const可以表示任意的对象是常量，这一点对任何数据类型都适用，如算术类型、类、指针等。

底层const则与指针和引用等复合类型的基本类型部分有关。

比较特殊的是，指针类型既可以是顶层const也可以是底层const，这一点和其他类型相比区别明显：

我们先看看顶层const的例子

int i= 0;
int *const pl = &i; // 不能改变p1 的值，这是一个顶层const
const int ci = 42;//不能改变ci的值，这是一个顶层const

再看看底层const的例子

const int *p2 = &ci; //允许改变p2的值，这是一个底层const
const int* const p3= p2;//靠右的const是顶层const，靠左的是底层
const int &r = ci; // 用于声明引用的const 都是底层 const

当执行对象的拷贝操作时，常量是顶层const还是底层const区别明显。

其中顶层const不受什么影响：

	int i = 0;
	int* const pl = &i;
	const int ci = 42;
		const int* p2 = &ci;
	const int* const p3 = p2;

	i = ci; // 正确：拷贝ci的值，ci是一个顶层const，对此操作无影响 
	p2 = p3; // 正确：p2和p3指向的对象类型相同，p3顶层const的部分不影响

执行拷贝操作并不会改变被拷贝对象的值，因此，拷入和拷出的对象是否是常量都没 const影响。

另一方面，底层const的限制却不能忽视。

当执行对象的拷贝操作时，拷入和拷出的对象必须具有相同的底层const资格，或者两个对象的数据类型必须能够转换。

一般来说，非常量可以转换成常量，反之则不行：

	int i = 0;
	int* const pl = &i;
	const int ci = 42;
		const int* p2 = &ci;
	const int* const p3 = p2;

	int* p = p3; //错误：p3包含底层const的定义，而p没有
		p2 = p3; // 正确：p2和p3都是底层const
	p2 = &i; // 正确：int*能转换成const int*
	int& r = ci; // 错误：普通的int&不能绑定到int常量上
		const int& r2 = i; // 正确：const int&可以绑定到一个普通 int上

p3既是顶层const也是底层const，拷贝p3时可以不在乎它是一个顶层const，但是必须清楚它指向的对象得是一个常量。

因此，不能用p3去初始化p，因为p指向的是个普通的(非常量)整数。另一方面，p3的值可以赋给p2，是因为这两个指针都是底层const，尽管p3同时也是一个常量指针(顶层const)，仅就这次赋值而言不会有什么影响。

二级指针

在C++中，二级指针（double pointer）也称为指向指针的指针。它本质上是一个指针变量，存储的是另一个指针的地址。

语法上，二级指针的声明和使用方式如下：

int** ptr2;  // 声明一个二级指针

int main() {
    int num = 10;
    int* ptr1 = #  // 声明一个指针并将其指向变量num的地址
    int**ptr2 = &ptr1;     // 将指向ptr1的地址赋给二级指针ptr2

    printf("Value of num: %d\n", **ptr2);   // 通过二级指针访问变量num的值
    printf("Address of ptr1: %p\n", *ptr2); // 通过二级指针访问指针ptr1的地址

    return 0;
}

在上面的例子中，我们声明了一个二级指针ptr2，它存储了指向ptr1的地址。

通过二级指针ptr2可以访问ptr1所指向的地址和值。通过两次解引用操作**ptr2，我们可以获得指向的变量num的值。通过一次解引用操作*ptr2，我们可以获得指针ptr1的地址。

二级指针通常用在需要传递指针的地址作为参数的函数中，可以通过传递二级指针来修改原始指针的值。

指针传参

一级指针传参

假如一个函数的原型如下

void A(int*d);

则下面几种传参方式都是对的

int a=10;
A(&a);//可以

int arr[2];
A(arr);//可以

int*b=&a;
A(b);//可以

二级指针传参

假如函数形参是二级指针

void B(int**a);

则下面几种传参方式都是对的

int*a;
B(&a);//可以

int**b=&a;
B(b);//可以

int*c[10];
B(c);//可以