C++中的指针常量、常量指针与常量指针常量详解
<div id="navCategory"><h5 class="catalogue">目录</h5><ul class="first_class_ul"><li>什么是const关键字？</li><li>1. 指针常量（Pointer Constant）</li><ul class="second_class_ul"><li>声明语法</li><li>代码示例</li><li>特点总结</li></ul><li>2. 常量指针（Pointer to Constant）</li><ul class="second_class_ul"><li>声明语法</li><li>代码示例</li></ul><li>特点总结</li><ul class="second_class_ul"></ul><li>3. 常量指针常量（Constant Pointer to Constant）</li><ul class="second_class_ul"><li>声明语法</li><li>代码示例</li><li>特点总结</li></ul><li>快速记忆技巧</li><ul class="second_class_ul"><li>方法一：看const相对于*的位置</li><li>口诀：“左定值，右定向，两边定都定”</li><li>方法二：从右向左读法</li></ul><li>实际应用场景</li><ul class="second_class_ul"><li>1. 函数参数中的使用</li><li>2. 字符串处理</li><li>3. 面向对象编程中的应用</li></ul></ul></div><p>在C++编程中，指针和const关键字的组合使用是每个开发者必须掌握的重要概念。正确理解这些概念不仅能帮助我们编写更安全的代码，还能提升代码的可读性和维护性。本文将深入探讨三种常见的指针与const组合：指针常量、常量指针和常量指针常量。</p><p class="maodian"></p><h2>什么是const关键字？</h2>
<p>在深入讨论之前，我们先简单回顾一下const关键字的作用。const用于定义常量，表示被修饰的变量或对象不可修改。当const与指针结合时，根据其位置的不同，会产生不同的语义。</p>
<p class="maodian"></p><h2>1. 指针常量（Pointer Constant）</h2>
<p>指针常量指的是指针本身是常量，即指针的指向（内存地址）不可改变，但可以通过指针修改指向的值。</p>
<p class="maodian"></p><p class="maodian"></p><p class="maodian"></p><h3>声明语法</h3>
<div class="jb51code"><pre class="brush:cpp;">type* const ptr = 初始地址;
</pre></div>
<p class="maodian"></p><p class="maodian"></p><p class="maodian"></p><h3>代码示例</h3>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
using namespace std;
int main() {
int a = 10, b = 20;
int* const ptr = &a;// 必须在声明时初始化
cout << "初始值: a = " << a << endl;
*ptr = 30;// ✅ 正确：可以修改指向的值
cout << "修改后: a = " << a << endl;
// ptr = &b;// ❌ 错误：不能改变指针的指向
// 编译错误：error: assignment of read-only variable 'ptr'
return 0;
}
</pre></div>
<p class="maodian"></p><p class="maodian"></p><h3>特点总结</h3>
<ul><li>指针的指向固定，不可改变</li><li>可以通过指针修改指向的值</li><li>必须在声明时初始化</li></ul>
<p class="maodian"></p><h2>2. 常量指针（Pointer to Constant）</h2>
<p>常量指针指的是指向的值是常量，不能通过指针修改指向的值，但可以改变指针的指向。</p>
<h3>声明语法</h3>
<div class="jb51code"><pre class="brush:cpp;">const type* ptr;// 或 type const* ptr;
</pre></div>
<h3>代码示例</h3>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
using namespace std;
int main() {
int a = 10, b = 20;
const int* ptr = &a;
cout << "a = " << a << ", *ptr = " << *ptr << endl;
ptr = &b;// ✅ 正确：可以改变指向
cout << "现在指向b: *ptr = " << *ptr << endl;
// *ptr = 30;// ❌ 错误：不能修改指向的值
// 编译错误：error: assignment of read-only location '*ptr'
// 但可以直接修改变量本身
b = 40;
cout << "直接修改b后: *ptr = " << *ptr << endl;
return 0;
}
</pre></div>
<p class="maodian"></p><h2>特点总结</h2>
<ul><li>不能通过指针修改指向的值</li><li>可以改变指针的指向</li><li>不要求在声明时初始化</li></ul>
<p class="maodian"></p><h2>3. 常量指针常量（Constant Pointer to Constant）</h2>
<p>常量指针常量是指针本身和指向的值都是常量，既不能改变指针的指向，也不能通过指针修改指向的值。</p>
<h3>声明语法</h3>
<div class="jb51code"><pre class="brush:cpp;">const type* const ptr = 初始地址;
</pre></div>
<h3>代码示例</h3>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
using namespace std;
int main() {
int a = 10, b = 20;
const int* const ptr = &a;
cout << "a = " << a << ", *ptr = " << *ptr << endl;
// *ptr = 30;// ❌ 错误：不能修改指向的值
// ptr = &b; // ❌ 错误：不能改变指针的指向
// 但可以直接修改变量本身（前提是变量不是const）
a = 40;
cout << "直接修改a后: *ptr = " << *ptr << endl;
return 0;
}
</pre></div>
<h3>特点总结</h3>
<ul><li>指针的指向固定，不可改变</li><li>不能通过指针修改指向的值</li><li>必须在声明时初始化</li></ul>
<p class="maodian"></p><h2>快速记忆技巧</h2>
<p class="maodian"></p><h3>方法一：看const相对于*的位置</h3>
<div class="jb51code"><pre class="brush:cpp;">const int* ptr1; // const在*左边 → 常量指针（指向常量）
int const* ptr2; // const在*左边 → 常量指针（指向常量）
int* const ptr3; // const在*右边 → 指针常量（指针是常量）
const int* const ptr4; // 两边都有const → 常量指针常量
</pre></div>
<p class="maodian"></p><h3>口诀：“左定值，右定向，两边定都定”</h3>
<ul><li>const在*左边：指向的值是常量</li><li>const在*右边：指针本身是常量</li><li>两边都有const：都不可变</li></ul>
<p class="maodian"></p><h3>方法二：从右向左读法</h3>
<div class="jb51code"><pre class="brush:cpp;">int* const ptr; // ptr is a const pointer to int
const int* ptr; // ptr is a pointer to const int
const int* const ptr;// ptr is a const pointer to const int
</pre></div>
<p class="maodian"></p><h2>实际应用场景</h2>
<p class="maodian"></p><h3>1. 函数参数中的使用</h3>
<div class="jb51code"><pre class="brush:cpp;">// 常量指针：保护数据不被意外修改
void printArray(const int* arr, int size) {
for (int i = 0; i < size; i++) {
cout << arr << " ";
// arr = 0;// ❌ 错误：不能修改
}
cout << endl;
}
// 指针常量：固定操作某个对象
void incrementValue(int* const ptr) {
*ptr += 1;// ✅ 可以修改值
// ptr = nullptr;// ❌ 错误：不能改变指向
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int value = 10;
printArray(arr, 5);
incrementValue(&value);
cout << "value = " << value << endl;
return 0;
}
</pre></div>
<p class="maodian"></p><h3>2. 字符串处理</h3>
<div class="jb51code"><pre class="brush:cpp;">#include <iostream>
#include <cstring>
using namespace std;
int main() {
char str1[] = "Hello";
char str2[] = "World";
// 常量指针：指向字符串常量
const char* message = "Immutable string";
// *message = 'h';// ❌ 错误：字符串常量不可修改
// 指针常量：固定指向某个字符串
char* const fixedPtr = str1;
fixedPtr = 'h';// ✅ 可以修改内容
// fixedPtr = str2;// ❌ 错误：不能改变指向
cout << message << endl;
cout << fixedPtr << endl;
return 0;
}
</pre></div>
<p class="maodian"></p><h3>3. 面向对象编程中的应用</h3>
<div class="jb51code"><pre class="brush:cpp;">class MyClass {
private:
int data;
public:
MyClass(int d) : data(d) {}
// 常量成员函数：不能修改成员变量
int getData() const {
return data;
}
void setData(int d) {
data = d;
}
};
int main() {
MyClass obj(100);
const MyClass constObj(200);
// 指向常量的指针
const MyClass* ptr1 = &constObj;
cout << ptr1->getData() << endl;// ✅ 可以调用const成员函数
// ptr1->setData(300);// ❌ 错误：不能调用非const成员函数
// 指针常量
MyClass* const ptr2 = &obj;
ptr2->setData(150);// ✅ 可以修改对象
// ptr2 = &constObj;// ❌ 错误：不能改变指向
return 0;
}
</pre></div>
<p>到此这篇关于C++中的指针常量、常量指针与常量指针常量详解的文章就介绍到这了,更多相关C++ 指针常量、常量指针与常量指针常量内容请搜索琼殿技术社区以前的文章或继续浏览下面的相关文章希望大家以后多多支持琼殿技术社区！</p>
<div class="art_xg">
<b>您可能感兴趣的文章:</b><ul><li>C++ 指针常量和常量指针的区别小结</li><li>如何理解C++指针常量和常量指针</li><li>C++常量指针,指针常量,指向常量的常指针详解</li><li>简单总结C++中指针常量与常量指针的区别</li><li>C++ 常量指针与指针常量的实现示例</li></ul>
</div>
</div>
<!--endmain-->
頁:
[1]