跳到主要内容

C++ 指针声明

什么是指针？​

在C++中，指针是一种特殊的变量，它存储的是内存地址，而不是实际的数据值。通过指针，我们可以间接地访问和操作存储在该地址的数据。指针是C++中强大而灵活的特性，但也容易导致错误，因此正确理解和声明指针非常重要。

指针声明的基本语法​

声明一个指针变量的基本语法如下：

cpp
数据类型* 指针变量名;

或者

cpp
数据类型 *指针变量名;

两种写法在功能上完全相同，区别仅在于星号(*)的位置，这是编码风格的选择。

简单示例​

cpp
#include <iostream>
using namespace std;

int main() {
    int* ptr;      // 声明一个指向整数的指针
    double* dptr;  // 声明一个指向双精度浮点数的指针
    char* cptr;    // 声明一个指向字符的指针
    
    cout << "指针变量的大小:" << endl;
    cout << "int* 大小: " << sizeof(ptr) << " 字节" << endl;
    cout << "double* 大小: " << sizeof(dptr) << " 字节" << endl;
    cout << "char* 大小: " << sizeof(cptr) << " 字节" << endl;
    
    return 0;
}

输出结果（在64位系统上）:

指针变量的大小:
int* 大小: 8 字节
double* 大小: 8 字节
char* 大小: 8 字节
备注

在现代计算机系统中，指针的大小通常与系统的地址总线宽度相同。在32位系统上，指针通常是4字节；在64位系统上，指针通常是8字节。无论指针指向什么类型的数据，其自身的大小都是相同的。

指针的初始化​

声明指针后，应该将其初始化，以避免未定义行为。初始化指针有几种方式：

1. 指向已有变量​

cpp
#include <iostream>
using namespace std;

int main() {
    int num = 10;      // 声明一个整数变量
    int* ptr = &num;   // 初始化指针，使其指向num的地址
    
    cout << "num的值: " << num << endl;
    cout << "num的地址: " << &num << endl;
    cout << "ptr存储的地址: " << ptr << endl;
    cout << "ptr指向的值: " << *ptr << endl;
    
    return 0;
}

输出结果:

num的值: 10
num的地址: 0x7ffdcb23c8bc (地址值会因运行环境而异)
ptr存储的地址: 0x7ffdcb23c8bc
ptr指向的值: 10

2. 初始化为nullptr（推荐）​

cpp
#include <iostream>
using namespace std;

int main() {
    int* ptr = nullptr;  // 现代C++推荐使用nullptr初始化指针
    
    if (ptr == nullptr) {
        cout << "指针未指向有效内存" << endl;
    }
    
    return 0;
}

输出结果:

指针未指向有效内存
警告

不要使用未初始化的指针！这可能导致程序崩溃或不可预测的行为。

多个指针的声明​

当在同一行声明多个指针时，需要注意星号(*)的使用：

cpp
#include <iostream>
using namespace std;

int main() {
    // 正确方式：每个变量名前都有星号
    int *p1, *p2, *p3;
    
    // 错误理解：以下只有p4是指针，p5和p6是普通int变量
    int* p4, p5, p6;
    
    int value = 42;
    p4 = &value;
    p5 = 5;  // p5不是指针，是普通int变量
    
    cout << "p4指向的值: " << *p4 << endl;
    cout << "p5的值: " << p5 << endl;
    
    return 0;
}

输出结果:

p4指向的值: 42
p5的值: 5

指针的常见声明形式​

1. 基本类型指针​

cpp
int* iptr;       // 指向整数的指针
double* dptr;    // 指向双精度浮点数的指针
char* cptr;      // 指向字符的指针
bool* bptr;      // 指向布尔值的指针

2. 指向常量的指针​

指向常量的指针表示不能通过该指针修改所指向的数据，但指针本身可以指向其他地址。

cpp
#include <iostream>
using namespace std;

int main() {
    int value = 10;
    const int* ptr = &value;  // ptr是指向常量的指针
    
    // *ptr = 20;  // 错误！不能通过ptr修改value的值
    value = 20;     // 正确，可以直接修改value
    
    int anotherValue = 30;
    ptr = &anotherValue;  // 正确，可以改变ptr指向的地址
    
    cout << "ptr指向的值: " << *ptr << endl;
    
    return 0;
}

输出结果:

ptr指向的值: 30

3. 常量指针​

常量指针表示指针本身不能改变指向的地址，但可以通过该指针修改所指向的数据。

cpp
#include <iostream>
using namespace std;

int main() {
    int value = 10;
    int anotherValue = 20;
    int* const ptr = &value;  // const修饰指针ptr本身
    
    *ptr = 30;  // 正确，可以修改ptr指向的值
    // ptr = &anotherValue;  // 错误！不能改变ptr指向的地址
    
    cout << "value的值: " << value << endl;
    
    return 0;
}

输出结果:

value的值: 30

4. 指向常量的常量指针​

结合上面两种类型，既不能修改指针指向的地址，也不能通过指针修改所指向的数据。

cpp
#include <iostream>
using namespace std;

int main() {
    int value = 10;
    const int* const ptr = &value;  // 指向常量的常量指针
    
    // *ptr = 30;            // 错误！不能通过ptr修改value
    // ptr = &anotherValue;  // 错误！不能改变ptr的指向
    
    cout << "ptr指向的值: " << *ptr << endl;
    
    return 0;
}

输出结果:

ptr指向的值: 10

指针声明的可视化​

以下是指针与内存关系的简化图示：

指针声明的实际应用场景​

动态内存分配​

cpp
#include <iostream>
using namespace std;

int main() {
    int size;
    cout << "请输入数组大小: ";
    cin >> size;
    
    // 动态分配内存
    int* dynamicArray = new int[size];
    
    // 使用动态数组
    for(int i = 0; i < size; i++) {
        dynamicArray[i] = i * 10;
    }
    
    // 输出数组内容
    cout << "动态数组内容:" << endl;
    for(int i = 0; i < size; i++) {
        cout << dynamicArray[i] << " ";
    }
    cout << endl;
    
    // 释放分配的内存
    delete[] dynamicArray;
    
    return 0;
}

输入/输出示例:

请输入数组大小: 5
动态数组内容:
0 10 20 30 40

函数间传递大型数据结构​

通过指针传递大型数据结构可以避免复制整个结构，提高性能。

cpp
#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    double gpa;
};

// 使用指针接收Student结构体
void displayStudent(Student* s) {
    cout << "学生信息:" << endl;
    cout << "姓名: " << s->name << endl;  // 使用箭头操作符访问成员
    cout << "年龄: " << s->age << endl;
    cout << "GPA: " << s->gpa << endl;
}

int main() {
    // 创建Student对象
    Student alice = {"Alice", 20, 3.9};
    
    // 传递Student的指针给函数
    displayStudent(&alice);
    
    return 0;
}

输出结果:

学生信息:
姓名: Alice
年龄: 20
GPA: 3.9

指针声明的最佳实践​

  1. 总是初始化指针：未初始化的指针包含垃圾值，使用它们会导致未定义行为。

    cpp
    int* ptr = nullptr;  // 良好实践

  2. 优先使用nullptr而非NULL或0：在C++11及以后，推荐使用nullptr替代NULL或0作为空指针。

    cpp
    int* ptr = nullptr;  // C++11之后的推荐用法
    int* ptr = NULL;     // 不推荐
    int* ptr = 0;        // 不推荐

  3. 明确区分指针和它所指向的数据：

    cpp
    int x = 5;
    int* p = &x;  // p是指针，*p是数据

  4. 合理使用const：使用const可以帮助编译器捕获错误并使代码更安全。

    cpp
    const int* p1;      // 不能通过p1修改所指向的数据
    int* const p2 = &x; // p2不能指向其他地址

  5. 避免悬空指针：当指针指向的对象被销毁但指针未更新时，就会出现悬空指针。

    cpp
    int* createAndReturn() {
        int local = 100;
        return &local;  // 错误！返回局部变量的地址
    }

总结​

指针声明是C++编程中的基础知识，正确理解和使用指针对于编写高效、健壮的代码至关重要。本文介绍了指针声明的基本语法、指针的初始化方法、不同类型的指针声明以及实际应用场景。记住，指针功能强大，但使用不当也容易导致问题，因此遵循最佳实践至关重要。

练习​

  1. 声明一个指向整数的指针，并使其指向一个值为42的整数变量。然后通过指针修改这个变量的值为100。

  2. 声明一个指向常量的指针和一个常量指针，并解释它们之间的区别。

  3. 编写一个函数，接收一个整数指针和一个整数作为参数，该函数将指针指向的值增加参数指定的数量。

  4. 声明一个指向整数数组的指针，并使用该指针遍历数组的所有元素。

延伸阅读​

  • 了解指针与引用的区别和使用场景
  • 探索智能指针(std::unique_ptr, std::shared_ptr, std::weak_ptr)如何简化指针管理
  • 学习如何使用指针实现链表、树等数据结构

通过掌握指针声明的基础知识，你就迈出了理解C++内存管理的第一步，这将为你学习更高级的C++概念奠定坚实的基础。