MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++常指针与指向常变量指针的差异剖析

2024-10-055.9k 阅读

C++ 常指针与指向常变量指针的概念区分

常指针的定义与特性

在 C++ 中，常指针是指指针本身的值不能被修改，也就是说它始终指向同一个内存地址。其定义语法为 type* const pointer_name = &variable;，其中 type 是指针所指向的数据类型，pointer_name 是指针变量名，variable 是同类型的变量。例如：

int num1 = 10;
int num2 = 20;
int* const ptr = &num1;
// 以下操作是不允许的，因为常指针ptr的值不能被修改
// ptr = &num2;

上述代码中，ptr 被定义为常指针，它初始化为指向 num1，之后不能再让它指向 num2。但是，通过常指针所指向的变量的值是可以修改的，比如：

*ptr = 15; 
std::cout << "num1的值: " << num1 << std::endl;

执行上述代码后，num1 的值会变为 15，这表明常指针只是限制了指针本身的指向不能改变，而对所指向变量的值的修改没有限制。

指向常变量指针的定义与特性

指向常变量的指针，意味着指针指向的变量的值不能通过该指针进行修改，其定义语法为 const type* pointer_name = &variable; 或者 type const* pointer_name = &variable;，这两种写法是等价的。例如：

int num3 = 30;
const int* ptr2 = &num3;
// 以下操作是不允许的，因为ptr2指向的是常量，不能通过ptr2修改其值
// *ptr2 = 35;

这里 ptr2 是指向常变量的指针，虽然它可以指向不同的 int 类型变量，但是不能通过 ptr2 来修改其所指向变量的值。然而，指向常变量的指针本身的值（即所指向的地址）是可以改变的，例如：

int num4 = 40;
ptr2 = &num4;

上述代码中，ptr2 原本指向 num3，之后可以重新指向 num4，这展示了指向常变量指针在指针指向方面的灵活性，只是对所指向变量的值修改进行了限制。

从内存角度理解两者差异

常指针的内存模型

常指针在内存中的存储方式决定了其特性。当定义一个常指针 int* const ptr = &num1; 时，内存中会为 ptr 分配一块固定大小的内存空间（在 32 位系统中通常为 4 字节，64 位系统中通常为 8 字节），这块空间用于存储 num1 的地址。由于 ptr 被声明为常指针，其存储的地址值一旦初始化后就不能再改变，这就好比在内存中给这个指针指向的地址“上了锁”。

从汇编层面来看，对于常指针的赋值操作，编译器会生成相应的指令来确保地址的不可更改性。例如，在 GCC 编译器下，对于上述常指针定义的汇编代码片段可能如下（简化示意）：

mov eax, offset num1 
mov [ptr], eax

这里 mov [ptr], eax 指令将 num1 的地址存入 ptr 所对应的内存位置，并且后续代码如果试图修改 ptr 的值，编译器会检测到并报错。而对于通过常指针修改所指向变量的值，汇编指令则相对简单，比如 mov dword ptr [ptr], 15，这条指令将 15 写入 ptr 所指向的内存地址，也就是修改了 num1 的值。

指向常变量指针的内存模型

指向常变量的指针在内存中的布局与常指针有所不同。当定义 const int* ptr2 = &num3; 时，同样会为 ptr2 分配内存空间来存储 num3 的地址。但是，与常指针不同的是，这个地址值是可以改变的。

从汇编角度，当改变指向常变量指针的指向时，编译器会生成指令来更新指针所存储的地址。例如，当执行 ptr2 = &num4; 时，汇编代码可能如下（简化示意）：

mov eax, offset num4 
mov [ptr2], eax

然而，当试图通过 ptr2 修改所指向变量的值时，编译器会阻止这种操作。这是因为在定义 ptr2 时，编译器会在符号表中标记 ptr2 所指向的内存区域为只读，任何试图通过 ptr2 进行写操作的汇编指令都会被编译器视为非法操作而报错。

函数参数传递中的差异

常指针作为函数参数

当常指针作为函数参数时，它保留了常指针的特性，即指针本身的值在函数内部不能被修改，但可以通过该指针修改所指向变量的值。例如：

void modifyValue(int* const ptr) {
    *ptr = 50; 
}
int main() {
    int num = 10;
    int* const ptr = &num;
    modifyValue(ptr);
    std::cout << "num的值: " << num << std::endl; 
    return 0;
}

在上述代码中，modifyValue 函数接受一个常指针参数 ptr，在函数内部可以通过 ptr 修改其所指向的 num 的值，但是不能改变 ptr 本身的指向。这种特性在函数参数传递中可以确保函数不会意外改变指针的指向，同时允许对所指向的数据进行操作，常用于需要保证指针指向稳定性的场景，比如在一些涉及内存管理的函数中，确保传入的指针不会被误修改指向，避免内存泄漏等问题。

指向常变量指针作为函数参数

指向常变量指针作为函数参数时，函数不能通过该指针修改所指向变量的值，但指针本身的值可以改变。例如：

void printValue(const int* ptr) {
    std::cout << "值: " << *ptr << std::endl; 
    // 以下操作是不允许的，不能通过ptr修改值
    // *ptr = 60; 
}
int main() {
    int num1 = 10;
    int num2 = 20;
    const int* ptr = &num1;
    printValue(ptr);
    ptr = &num2; 
    printValue(ptr);
    return 0;
}

在 printValue 函数中，参数 ptr 是指向常变量的指针，函数只能读取 ptr 所指向的值，不能修改它。在 main 函数中，可以看到 ptr 的指向可以在不同的 const int 类型变量之间切换。这种参数传递方式常用于函数只需要读取数据而不需要修改数据的场景，比如在一些用于数据展示或计算的函数中，保证数据的完整性和只读性。

类型兼容性与转换

常指针的类型兼容性

常指针在类型兼容性方面有其特定规则。如果有两个指针类型 type1* const 和 type2* const，只有当 type1 和 type2 相同或者存在合法的类型转换关系时，才可以进行赋值操作。例如：

class Base {};
class Derived : public Base {};
Base* const basePtr = new Base();
// 以下赋值是合法的，因为Derived*可以隐式转换为Base*
Derived* const derivedPtr = new Derived();
basePtr = derivedPtr;

在上述代码中，由于 Derived 类继承自 Base 类，Derived* 类型的常指针 derivedPtr 可以赋值给 Base* 类型的常指针 basePtr。然而，如果没有这种继承关系或者其他合法的类型转换关系，赋值操作会导致编译错误。

指向常变量指针的类型兼容性

指向常变量指针的类型兼容性规则相对复杂一些。对于 const type1* 和 const type2*，除了 type1 和 type2 相同或者存在合法的类型转换关系外，还需要考虑 const 修饰符的影响。例如：

int num = 10;
const int* constPtr1 = &num;
int* normalPtr = &num;
// 以下赋值是不允许的，普通指针不能直接赋值给指向常量的指针
// constPtr1 = normalPtr; 
const int num2 = 20;
constPtr1 = &num2;

在上述代码中，普通指针 normalPtr 不能直接赋值给指向常量的指针 constPtr1，因为这样可能会破坏数据的常量性。但是，constPtr1 可以指向另一个 const int 类型的变量 num2。此外，如果存在继承关系，例如：

class Base {};
class Derived : public Base {};
const Base* basePtr = new Base();
const Derived* derivedPtr = new Derived();
// 以下赋值是合法的，因为const Derived*可以隐式转换为const Base*
basePtr = derivedPtr;

这里 const Derived* 类型的指针 derivedPtr 可以赋值给 const Base* 类型的指针 basePtr，这是因为继承关系下的类型转换在 const 修饰的指针类型中同样适用，并且这种转换不会破坏数据的常量性。

应用场景分析

常指针的应用场景

  1. 内存管理相关函数：在一些涉及动态内存分配和释放的函数中，常指针非常有用。例如，在一个自定义的内存分配函数 allocateMemory 中，为了确保传入的指针在函数内部不会被意外修改指向，导致内存管理混乱，可以使用常指针作为参数。
void allocateMemory(int* const ptr, size_t size) {
    *ptr = new int[size]; 
    // 这里不能修改ptr的指向
}
  1. 链表操作：在链表相关的操作函数中，常指针可以用于确保链表节点指针在操作过程中不会被误修改指向。比如在链表的插入函数中，如果使用常指针指向当前节点，就可以保证在插入新节点的过程中，当前节点的指针不会被意外改变，从而维护链表结构的完整性。
struct ListNode {
    int value;
    ListNode* next;
};
void insertNode(ListNode* const current, int newValue) {
    ListNode* newNode = new ListNode{newValue, current->next};
    current->next = newNode; 
}

指向常变量指针的应用场景

  1. 数据读取与展示函数：在一些只用于读取数据并展示的函数中，指向常变量指针是理想的选择。例如，在一个用于显示数组元素的函数 displayArray 中，使用指向常变量指针可以保证数组数据不会被函数意外修改。
void displayArray(const int* arr, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}
  1. 函数接口设计：当设计一个函数接口，其目的是提供对数据的只读访问时，使用指向常变量指针作为参数可以明确传达这一意图。例如，一个用于计算数组元素总和的函数 calculateSum，它不需要修改数组元素的值，使用指向常变量指针可以提高代码的安全性和可读性。
int calculateSum(const int* arr, size_t size) {
    int sum = 0;
    for (size_t i = 0; i < size; ++i) {
        sum += arr[i];
    }
    return sum;
}

常见错误与陷阱

常指针相关错误

  1. 试图修改常指针的值：这是最常见的错误之一。如前文所述，常指针一旦初始化指向某个地址，就不能再改变其指向。例如：
int num1 = 10;
int num2 = 20;
int* const ptr = &num1;
// 以下操作会导致编译错误
ptr = &num2;

编译器会检测到这种非法操作并报错，提示常指针的值不能被修改。 2. 常指针类型不匹配：在进行赋值操作时，如果常指针的类型不兼容，也会导致错误。例如：

class A {};
class B {};
A* const aPtr = new A();
// 以下赋值会导致编译错误，因为A和B之间没有继承或合法转换关系
B* const bPtr = new B();
aPtr = bPtr;

这种情况下，编译器会指出类型不匹配的错误，开发者需要确保在进行常指针赋值时，类型之间存在合法的转换关系。

指向常变量指针相关错误

  1. 试图通过指向常变量指针修改值：由于指向常变量指针的特性，不能通过它来修改所指向变量的值。例如：
int num = 10;
const int* ptr = &num;
// 以下操作会导致编译错误
*ptr = 15;

编译器会阻止这种试图修改常量值的操作，报错提示不能通过指向常量的指针修改值。 2. 指针类型与常量性不匹配：在进行指针赋值时，如果没有正确处理常量性，也会引发错误。例如：

int num = 10;
int* normalPtr = &num;
const int* constPtr = &num;
// 以下赋值是错误的，普通指针不能直接赋值给指向常量的指针
normalPtr = constPtr;

这种错误可能不太容易察觉，因为从语法上看似乎没有问题，但实际上它破坏了指针的常量性规则，编译器会给出相应的类型不匹配错误提示。开发者需要仔细检查指针类型和常量性，确保赋值操作的正确性。

总结与对比

常指针总结

常指针具有指针指向不可变，但所指向变量值可变的特性。在内存中，常指针所存储的地址值一旦确定就不能更改，这在函数参数传递、内存管理和链表操作等场景中有重要应用。它通过限制指针的指向改变，提高了代码的稳定性和安全性，避免了因指针误修改指向而导致的内存错误等问题。然而，由于其指向的固定性，在使用上相对不够灵活，需要在初始化时就明确其指向。

指向常变量指针总结

指向常变量的指针则允许指针本身的指向改变，但不允许通过该指针修改所指向变量的值。这种特性在数据读取、函数接口设计等只读操作场景中发挥重要作用，它通过保证数据的常量性，防止函数意外修改数据，提高了代码的可靠性。在类型兼容性方面，指向常变量指针需要特别注意 const 修饰符对类型转换的影响。

两者对比

从指针指向的可变性来看，常指针固定指向一个内存地址，而指向常变量指针可以改变指向。从对所指向变量值的可修改性来看，常指针允许修改所指向变量的值，而指向常变量指针则禁止这种操作。在应用场景上，常指针更侧重于保证指针指向的稳定性，而指向常变量指针侧重于保证数据的只读性。在实际编程中，正确理解和运用这两种指针类型的差异，对于编写高效、安全、可靠的 C++ 代码至关重要。开发者需要根据具体的需求和场景，选择合适的指针类型，以避免常见的错误和陷阱，提升代码质量。