各类指针的使用与技巧(C++)

文章目录

1. 内存地址

2. 指针

3. 使用指针

4. Null 指针

5. 指针的算术运算

递增一个指针

递减一个指针

指针的比较

6. 指针和数组

7. 指针数组

8. 指向指针的指针（多级间接寻址）

9. 传递指针给函数

---

1. 内存地址

通过指针，可以简化一些 C++ 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。请看下面的实例，它将输出定义的变量地址：

代码示例：

#include <iostream>
 
using namespace std;
 
int main ()
{
   int  var1;
   char var2[10];
 
   cout << "var1 变量的地址： ";
   cout << &var1 << endl;
 
   cout << "var2 变量的地址： ";
   cout << &var2 << endl;
 
   return 0;
}

var1 变量的地址： 0xbfebd5c0
var2 变量的地址： 0xbfebd5b6

通过上面的实例，了解了什么是内存地址以及如何访问它。

2. 指针

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

type *var-name;

在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

3. 使用指针

使用指针时会频繁进行以下几个操作：定义一个指针变量，把变量地址赋值给指针，访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。

代码示例：

#include <iostream>  
using namespace std;  

int main() {  
    double number = 45.6;  // 实际变量的声明  
    double *ptr;           // 指针变量的声明  

    ptr = &number;  // 在指针变量中存储 number 的地址  

    // 输出实际变量的值  
    cout << "Value of number variable: ";  
    cout << number << endl;  

    // 输出指针变量中存储的地址  
    cout << "Address stored in ptr variable: ";  
    cout << ptr << endl;  

    // 通过指针访问值  
    cout << "Value of *ptr variable: ";  
    cout << *ptr << endl;  

    // 修改指针指向的值  
    *ptr = 99.9;  
    cout << "New value of number after modifying through *ptr: ";  
    cout << number << endl;  

    return 0;  
}

Value of number variable: 45.6  
Address stored in ptr variable: 0x7ffeee1bd648  
Value of *ptr variable: 45.6  
New value of number after modifying through *ptr: 99.9

4. Null 指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量。

代码示例：

#include <iostream>

using namespace std;

int main ()
{
   int  *ptr = NULL;

   cout << "ptr 的值是 " << ptr ;
 
   return 0;
}

ptr 的值是 0

在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

如需检查一个空指针，您可以使用 if 语句，如下所示：

if(ptr)     /* 如果 ptr 非空，则完成 */
if(!ptr)    /* 如果 ptr 为空，则完成 */

因此，如果所有未使用的指针都被赋予空值，同时避免使用空指针，就可以防止误用一个未初始化的指针。很多时候，未初始化的变量存有一些垃圾值，导致程序难以调试。

5. 指针的算术运算

指针是一个用数值表示的地址。因此可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-。

代码示例：

假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数：

ptr++

执行 ptr++ 后，指针 ptr 会向前移动 4 个字节，指向下一个整型元素的地址。这是由于指针算术运算会根据指针的类型和大小来决定移动的距离。在这种情况下，由于是一个 32 位整数指针，每个整数占据 4 个字节，因此 ptr++ 会将指针 ptr 向前移动 4 个字节，指向下一个整型元素的地址。

如果 ptr 指向一个地址为 1000 的字符，执行 ptr++ 指针 ptr 的值会增加，指向下一个字符元素的地址，由于 ptr 是一个字符指针，每个字符占据 1 个字节，因此 ptr++ 会将 ptr 的值增加 1，执行后 ptr 指向地址 1001。

指针算术运算的解析：

• 加法运算：可以对指针进行加法运算。当一个指针p加上一个整数n时，结果是指针p向前移动n个元素的大小。例如，如果p是一个int类型的指针，每个int占4个字节，那么p + 1将指向p所指向的下一个int元素。

• 减法运算：可以对指针进行减法运算。当一个指针p减去一个整数n时，结果是指针p向后移动n个元素的大小。例如，如果p是一个int类型的指针，每个int占4个字节，那么p - 1将指向p所指向的前一个int元素。

• 指针与指针之间的减法运算：可以计算两个指针之间的距离。当从一个指针p减去另一个指针q时，结果是两个指针之间的元素个数。例如，如果p和q是两个int类型的指针，每个int占4个字节，那么p - q将得到两个指针之间的元素个数。

• 指针与整数之间的比较运算：可以将指针与整数进行比较运算。可以使用关系运算符（如<、>、<=、>=）对指针和整数进行比较。这种比较通常用于判断指针是否指向某个有效的内存位置。

递增一个指针

在C++中，指针是一个变量，它存储一个内存地址。递增一个指针意味着将指针指向下一个内存位置，这通常是指向下一个数组元素。递增一个指针会根据指针所指向的数据类型自动调整指针的值。

例如，如果指针指向一个 int 类型的数组元素，那么递增指针将使其指向下一个 int 元素。

代码示例：

#include <iostream>
 
int main() {
    // 定义一个数组
    int arr[] = {10, 20, 30, 40, 50};
    
    // 定义一个指向数组第一个元素的指针
    int* ptr = arr;
    
    // 输出指针指向的元素
    std::cout << "指针当前指向的元素: " << *ptr << std::endl;
    
    // 递增指针
    ptr++;
    
    // 输出指针指向的元素
    std::cout << "递增指针后指向的元素: " << *ptr << std::endl;
    
    return 0;
}

指针当前指向的元素: 10
递增指针后指向的元素: 20

在这个示例中，指针 ptr 最初指向数组 arr 的第一个元素。通过执行 ptr++，指针 ptr 被递增以指向数组的下一个元素（即第二个元素）。

递增指针时，指针的值将增加一个偏移量，该偏移量等于指针所指向数据类型的大小。例如，如果指针是 int* 类型，每次递增指针将增加4个字节（假设 int 类型占4个字节）。

需要注意的是，当使用指针操作时，要确保指针指向有效的内存区域，否则可能会导致未定义行为或程序崩溃。在操作数组时，尤其要小心避免指针超出数组的范围。

递减一个指针

在C++中，指针不仅可以递增，也可以递减。递减一个指针意味着将指针指向前一个内存位置。与递增指针类似，递减指针也会根据指针所指向的数据类型自动调整指针的值。

下面是一个简单的示例，演示了如何递减一个指针：

#include <iostream>
 
int main() {
    // 定义一个数组
    int arr[] = {10, 20, 30, 40, 50};
    
    // 定义一个指向数组第二个元素的指针
    int* ptr = &arr[1];
    
    // 输出指针当前指向的元素
    std::cout << "指针当前指向的元素: " << *ptr << std::endl;
    
    // 递减指针
    ptr--;
    
    // 输出指针递减后指向的元素
    std::cout << "递减指针后指向的元素: " << *ptr << std::endl;
    
    return 0;
}

指针当前指向的元素: 20
递减指针后指向的元素: 10

 

在这个示例中，指针 ptr 最初指向数组 arr 的第二个元素。通过执行 ptr--，指针 ptr 被递减以指向数组的第一个元素。

递减指针时，指针的值将减少一个偏移量，该偏移量等于指针所指向数据类型的大小。例如，如果指针是 int* 类型，每次递减指针将减少4个字节（假设 int 类型占4个字节）。

指针的比较

在C++中，指针的比较操作可以用于确定两个指针是否指向相同的位置、一个指针是否指向的位置在另一个指针之前或之后等。指针的比较主要包括以下几种：

• 相等性比较 (== 和 !=)
• 关系比较 (<, <=, >, >=)

相等性比较

相等性比较用于检查两个指针是否指向相同的位置。

代码示例：

#include <iostream>

int main() {
    int a = 10;
    int b = 20;
    int* ptr1 = &a;
    int* ptr2 = &a;
    int* ptr3 = &b;

    // 比较指针是否相等
    if (ptr1 == ptr2) {
        std::cout << "ptr1 和 ptr2 指向相同的位置" << std::endl;
    } else {
        std::cout << "ptr1 和 ptr2 指向不同的位置" << std::endl;
    }

    if (ptr1 != ptr3) {
        std::cout << "ptr1 和 ptr3 指向不同的位置" << std::endl;
    } else {
        std::cout << "ptr1 和 ptr3 指向相同的位置" << std::endl;
    }

    return 0;
}

ptr1 和 ptr2 指向相同的位置
ptr1 和 ptr3 指向不同的位置

关系比较

关系比较用于确定一个指针是否指向的位置在另一个指针之前或之后。这通常在指针指向同一个数组的元素时有意义。

#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int* ptr1 = &arr[1]; // 指向数组的第二个元素
    int* ptr2 = &arr[3]; // 指向数组的第四个元素

    // 比较指针的相对位置
    if (ptr1 < ptr2) {
        std::cout << "ptr1 指向的元素在 ptr2 指向的元素之前" << std::endl;
    } else {
        std::cout << "ptr1 指向的元素不在 ptr2 指向的元素之前" << std::endl;
    }

    if (ptr2 > ptr1) {
        std::cout << "ptr2 指向的元素在 ptr1 指向的元素之后" << std::endl;
    } else {
        std::cout << "ptr2 指向的元素不在 ptr1 指向的元素之后" << std::endl;
    }

    return 0;
}

ptr1 指向的元素在 ptr2 指向的元素之前
ptr2 指向的元素在 ptr1 指向的元素之后

• 同一数组范围内的比较： 关系比较（如 <, >, <=, >=）在同一数组的元素之间进行是有意义的。如果指针不属于同一个数组，关系比较的结果是未定义的。

• 指针为空： 在比较指针之前，确保指针不是空指针（nullptr），否则可能会导致未定义行为。

6. 指针和数组

指针和数组是密切相关的。事实上，指针和数组在很多情况下是可以互换的。例如，一个指向数组开头的指针，可以通过使用指针的算术运算或数组索引来访问数组。

代码示例：

#include <iostream>
 
using namespace std;
const int MAX = 3;
 
int main ()
{
   int  var[MAX] = {10, 100, 200};
   int  *ptr;
 
   // 指针中的数组地址
   ptr = var;
   for (int i = 0; i < MAX; i++)
   {
      cout << "var[" << i << "]的内存地址为 ";
      cout << ptr << endl;
 
      cout << "var[" << i << "] 的值为 ";
      cout << *ptr << endl;
 
      // 移动到下一个位置
      ptr++;
   }
   return 0;
}

var[0]的内存地址为 0x7fff59707adc
var[0] 的值为 10
var[1]的内存地址为 0x7fff59707ae0
var[1] 的值为 100
var[2]的内存地址为 0x7fff59707ae4
var[2] 的值为 200

 

然而，指针和数组并不是完全互换的。例如：

#include <iostream>
 
using namespace std;
const int MAX = 3;
 
int main ()
{
   int  var[MAX] = {10, 100, 200};
 
   for (int i = 0; i < MAX; i++)
   {
      *var = i;    // 这是正确的语法
      var++;       // 这是不正确的
   }
   return 0;
}

把指针运算符 * 应用到 var 上是完全可以的，但修改 var 的值是非法的。这是因为 var 是一个指向数组开头的常量，不能作为左值。

由于一个数组名对应一个指针常量，只要不改变数组的值，仍然可以用指针形式的表达式。例如，下面是一个有效的语句，把 var[2] 赋值为 500：

*(var + 2) = 500;

上面的语句是有效的，且能成功编译，因为 var 未改变。

7. 指针数组

把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。

int *ptr[MAX];

代码示例：

下面的实例用到了三个整数，它们将存储在一个指针数组中，

#include <iostream>  
using namespace std;  

const int MAX = 3;  

int main() {  
    int var[MAX][MAX] = {  
        {1, 2, 3},  
        {4, 5, 6},  
        {7, 8, 9}  
    };  
    int *ptr[MAX];  

    // 将指针指向二维数组中的每一行的首地址  
    for (int i = 0; i < MAX; i++) {  
        ptr[i] = var[i];  
    }  

    // 遍历指针数组并输出二维数组中的值  
    cout << "二维数组的值：" << endl;  
    for (int i = 0; i < MAX; i++) {  
        for (int j = 0; j < MAX; j++) {  
            cout << "Value of var[" << i << "][" << j << "] = ";  
            cout << *(ptr[i] + j) << endl;  
        }  
    }  

    return 0;  
}

二维数组的值：  
Value of var[0][0] = 1  
Value of var[0][1] = 2  
Value of var[0][2] = 3  
Value of var[1][0] = 4  
Value of var[1][1] = 5  
Value of var[1][2] = 6  
Value of var[2][0] = 7  
Value of var[2][1] = 8  
Value of var[2][2] = 9

也可以用一个指向字符的指针数组来存储一个字符串列表。

#include <iostream>  
using namespace std;  

const int MAX = 3;  

int main() {  
    // 声明一个字符串数组  
    const char* sentences[MAX] = {  
        "这是一句中文。",  
        "这是第二句中文。",  
        "这是第三句中文。"  
    };  

    // 使用循环输出每个字符串  
    for (int i = 0; i < MAX; i++) {  
        cout << "Value of sentences[" << i << "] = ";  
        cout << sentences[i] << endl;  
    }  

    return 0;  
}

Value of sentences[0] = 这是一句中文。  
Value of sentences[1] = 这是第二句中文。  
Value of sentences[2] = 这是第三句中文。

8. 指向指针的指针（多级间接寻址）

指向指针的指针是一种多级间接寻址的形式，或着说是一个指针链。指针的指针就是将指针的地址存放在另一个指针里面。

通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。

一个指向指针的指针变量必须加下述符号，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：

int **var;

当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符。

代码示例：

#include <iostream>  
using namespace std;  

int main() {  
    float value = 7.5;  
    float *pt1;  
    float **pt2;  
    float ***pt3;  

    // 设置各级指针  
    pt1 = &value;  
    pt2 = &pt1;  
    pt3 = &pt2;  

    // 使用三级指针访问值并修改  
    cout << "Value before modification: " << ***pt3 << endl;  
    ***pt3 = 15.75;  
    cout << "Value after modification: " << value << endl;  

    // 输出中间指针地址和值  
    cout << "Address stored in pt1: " << pt1 << endl;  
    cout << "Value pointed to by pt1: " << *pt1 << endl;  
    cout << "Address stored in pt2: " << pt2 << endl;  
    cout << "Value pointed to by pt2: " << **pt2 << endl;  
    cout << "Address stored in pt3: " << pt3 << endl;  
    cout << "Value pointed to by pt3: " << ***pt3 << endl;  

    return 0;  
}

Value before modification: 7.5  
Value after modification: 15.75  
Address stored in pt1: 0x7ffee178a9c8  
Value pointed to by pt1: 15.75  
Address stored in pt2: 0x7ffee178a9f0  
Value pointed to by pt2: 15.75  
Address stored in pt3: 0x7ffee178a9f8  
Value pointed to by pt3: 15.75

 

9. 传递指针给函数

C++ 允许传递指针给函数，只需要声明函数参数为指针类型即可。

代码示例：

下面的示例中，传递一个无符号的 long 型指针给函数，并在函数内改变这个值：

#include <iostream>  
#include <ctime>  
using namespace std;  

// 在写函数时应先声明函数，然后在定义函数  
void getSeconds(unsigned long *par);  

int main() {  
    unsigned long seconds;  

    getSeconds(&seconds);  

    // 输出实际值  
    cout << "当前秒数为: " << seconds << endl;  

    return 0;  
}  

// 定义获取当前时间函数  
void getSeconds(unsigned long *par) {  
    // 获取当前的秒数  
    *par = time(NULL);  
    return;  
}

当前秒数为: 1294450468

能接受指针作为参数的函数，也能接受数组作为参数。

#include <iostream>  
using namespace std;  

// 函数声明  
double calculateAverage(int *arr, int size);  

int main() {  
    // 包含 5 个元素的整数类型数组  
    int numbers[5] = {10, 20, 30, 40, 50};  
    double average;  

    // 将数组元素作为参数传递给函数  
    average = calculateAverage(numbers, 5);  

    // 输出返回值  
    cout << "平均值为: " << average << endl;  

    return 0;  
}  

// 定义函数计算平均值  
double calculateAverage(int *arr, int size) {  
    int sum = 0;  

    // 计算数组元素的和  
    for (int i = 0; i < size; ++i) {  
        sum += arr[i];  
    }  

    // 返回平均值  
    return static_cast<double>(sum) / size;  
}

平均值为: 30

10. 从函数返回指针

C++ 中，为了从函数返回指针，必须声明一个返回指针的函数，如下所示：

int* myFunction() {  
    // 代码  
}

另外，C++ 不支持在函数外返回局部变量的地址，除非定义局部变量为 static变量。

现在来看下面的函数，它会生成 10 个随机数，并使用表示指针的数组名（即第一个数组元素的地址）来返回它们：

#include <iostream>  
using namespace std;  

// 函数声明  
int* createArray(int size);  

int main() {  
    int size = 5;  

    // 调用函数并获取返回的数组指针  
    int* array = createArray(size);  

    // 输出返回的数组元素  
    cout << "数组元素为：" << endl;  
    for (int i = 0; i < size; ++i) {  
        cout << "array[" << i << "] = " << array[i] << endl;  
    }  

    // 释放动态分配的内存  
    delete[] array;  

    return 0;  
}  

// 定义函数返回动态数组的指针  
int* createArray(int size) {  
    // 动态分配内存  
    int* arr = new int[size];  

    for (int i = 0; i < size; ++i) {  
        arr[i] = (i + 1) * 10;  // 将数组初始化为 10, 20, 30, 40, 50  
    }  

    return arr;  
}

1. 函数声明：

   • int* createArray(int size); 声明一个返回 int 指针并接受一个 int 参数 size 的函数。

2. 数组初始化：

   • int size = 5; 定义数组的大小。
   • int* array = createArray(size); 调用函数并获取返回的指向数组的指针。

3. 函数定义：

   • int* createArray(int size)：定义创建并返回数组指针的函数。
   • 使用 new 操作符动态分配内存并返回指针。
   • 设置数组的每个元素的值，通过 arr[i] = (i + 1) * 10; 这样的初始化。

4. 输出数组：

   • 使用 for 循环遍历数组并输出每个元素的值。

5. 释放内存：

   • delete[] array; 释放动态分配的内存，避免内存泄漏。

 

数组元素为：  
array[0] = 10  
array[1] = 20  
array[2] = 30  
array[3] = 40  
array[4] = 50