const int * p与int * const p

最新推荐文章于 2025-10-31 17:13:47 发布
原创 最新推荐文章于 2025-10-31 17:13:47 发布 · 389 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

本文探讨了C++中指针与常量的结合使用，包括int*const p、int const*p和const int*p的含义。它们都限制了对指针所指向的数据进行修改，但约束点有所不同。理解这些用法对于编写安全且可维护的C++代码至关重要。

const int * p, int const * p, int * const p
int * const p:意义表示p可以改变其指向字符串的值，但是不能改变p指针的指向。
int const * p与 const int * p是等价的，只是两者写法不同。c++中无const * 运算符。表示指针可以有不同的指向，但是不能改变原有字符串数据的值。

const char const p 两者皆限定为只读，不能改写。

const int* 和 int const*的区别？
杨鑫newlife的专栏
11-25 2438
Thinking in C++ 看到了第八章，讲的是指针。 这里提出这两个的区别是： 1、const int* 指向const的指针 对于这个的解释是：     const int* u;       //u是一个指针， 它指向一个const int.这里不需要初始化，因为u可以是指向任意标识符（也就是说它不是一个const），但是它的值是不能被改变的。 2、int const*这个
C++ const char *a、char * const a、char const *a、const char * const a 解析
love、reading的博客
08-20 8242
1、const char *a：声明(*a)，(*a)是const char类型的。a被一个解引用运算符修饰，故a是个普通的指针，可以修改，但是a所指向的数据(即*a)由于const的修饰而不可通过指针a去修改。但可以通过其它方式修改a所指向的数据 #include<iostream> using namespace std; int main() { char n='...
const int *p 和 int *const p
热门推荐
weixin_45045906的博客
01-21 1万+
网上很多帖子以及很多相关书籍对指针的命名都很粗暴地从右往左读，本人初学时也的确被“吓”到了，尤其是const int *p指针常量，而int *const p常量指针。偶然看到了一篇文章对其有详细的解释。 const int *p：指向常量的指针 int *const p：本身是常量的指针 ...
const int *p和int * const p的区别（常量指针与指向常量的指针）
u010949971的博客
09-15 4615
对于指针和常量，有以下三种形式都是正确的：const char * myPtr = &char_A;//指向常量的指针 char * const myPtr = &char_A;//常量的指针 const char * const myPtr = &char_A;//指向常量的常量指针 下面依次对这三种类型进行介绍。因为*操作符是左操作符，左操作符的优先级是从右到左，对于1.常量指针(Cons
【C++面试必看】const int *p 和 int * const p 有什么区别？一文彻底搞懂！
qq_49724550的博客
10-31 403
const int *p 和 int * const p 还在傻傻分不清？面试官一笑，offer可能就与你无缘了！本文拒绝死记硬背，用一个“靠近谁就锁定谁”的终极口诀，配上清晰的代码示例，让你一分钟彻底搞懂C++常量指针与指针常量的区别，轻松拿下面试，告别指针困惑！
分清int*const p, int const*p ,const int* p
2301_79894844的博客
02-03 886
如何分清int*const p, int const*p ,const int* p呢？说说我发现的小规律， 被const修饰的之后的值不变,并且 int const* p与const int* p是等价的。
const int * p和 int * const p
aiiye的博客
03-04 750
int a = 10; int * const p = &a; //const 修饰的是指针p，因此指针p的内容无法改变，即p只能指向a，不能指向其他地方，但是*p不是常量，因此可通过*p修改a的值 int b = 11; const int * p = &b; //const 修饰的是‘int * p’,也即a，把这个表达式声明为常量，因此无法通过*p = 12；改变a的值，但是p本身不是常量，因此p可以指向其他地方 //仅仅是一个记忆方法 ...
C语言中const int *p和int *const p
承蒙关照！
10-16 1642
表示p是一个指向const int类型的指针，即。表示p是一个指向int类型的const指针，即。，但是指针p所指向的内存空间的值可以被修改。：看const后边修饰的是什么，，但是指针p本身可以被修改。指针p本身的值不能被修改。内存空间的值不能被修改。
深入const int *p与int * const p的区别详解(常量指针与指向常量的指针)
01-20
对于指针和常量，有以下三种...常量指针(Constant Pointers) 代码如下:int * const p先看const再看* ，是p是一个常量类型的指针，不能修改这个指针的指向，但是这个指针所指向的地址上存储的值可以修改。实例1： 代码
const int *a int * const a区别实例
08-11
const int r = 100; ``` 此处，r 是一个整型常量，编译器会将其替换为 100。注意，const 变量必须在定义时初始化，否则会导致编译错误。 const 指针 const 指针是指向常量的指针，例如： ```cpp const int *a; ```...
const int *p 和 int *const p的区别
YueXuan_521的博客
04-10 1110
完全固定指针和数据，适用于只读且地址固定的场景（如全局常量）。用于固定指针的指向地址，但允许修改数据（如硬件寄存器操作）。是两种不同的指针声明方式，它们的核心区别在于 const。用于保护数据不被意外修改，常用于函数参数传递只读数据。与指针的组合使用，能有效提升代码的安全性和可读性！，导致指针的行为不同。的地址不可变（指针本身是常量）。可以指向不同的内存地址。
const int * p与int *const p的详解
tianmo2010的专栏
09-25 2024
1） const int *p 与int const *p： 需要记得   const     和     type   的位置是可以互换的， const   不能修饰   type   ， 而是修饰后面的变量，所以： const   int*   p;   ＝＝》int   const   *   p;   const修饰了   *p， *p表示一个指针指向的值，那么   cons
const int *p与int *const p
心有猛虎，细嗅蔷薇
12-19 415
引自《C++ Primer》第5版 指针本身是不是常量以及指针所指的是不是一个常量是两个相互独立的问题。用名词顶层const（top-level const）表示指针本身是个常量，而用名词底层const（low-level const）表示指针所指的对象是一个常量。 当执行对象的拷贝操作时，常量是顶层const还是底层const区别明显。其中，顶层const不受什么影响：执行拷贝操作并不会
const int *p 和 int * const p
m0_62668348的博客
06-27 494
const int *p: const 修饰 *p，*p 是地址中的值，所以const int *p是指向可以发生改变（p的指向可以发生改变），指向的值不可以变（不可以通过*p 改变地址中的值）；如图一，标红色波浪线表示出错，语法不允许。int *const p: const 修饰 p，p 是一个地址，所以int *const p是指向不可以发生改变（p的指向不可以发生改变），指向的值可以变（可以通过*p来改变其中的值）；如图二，标红色波浪线表示出错，语法不允许。
const int * p （或 int const* p） 和 int * const p以及const int * const p（或int const * const p）区别
qq_28816873的博客
01-10 4120
const int p 与 int const p 和const int const *p区别 一、何为const const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。也就是说const常量，具有不可变性。 例如： const int Max=100; Max++会产生错误; 二、 指针常量与常量指针 1、指针常量 指针就是内存单元中的地址，所谓指针常量，也就是这个指针变...
const int* p 和 int* const p
incipe
11-22 388
主要讲下这两者的区别及用法！ 高能区 const int* p 和 int const* p是完全等价的！ const int* const p 和 int const const* p 是完全等价的！ 下面举几个例子来分析： int x = 100, y = 100; const int* p = &x; int* const m = &y; p = &y; /...
关于const
vividly的学习小站
04-18 805
const是C语言中的一个常量修饰符，就是说它修饰的对象为常量。如果想阻止一个变量被改变，那么可以选择使用const关键字。在为一个变量加上const修饰符的同时，通常需要对它进行初始化，在之后的程序中就不能再去改变它。 接下来介绍const修饰符的几种使用方法。 1，const修饰符在函数体内修饰局部变量。 const int a; int const a; const int *a;
常指针和指向常量的指针 const int *p;int * const p ;const int * const p
好奇>鱼角尖
10-21 781
来聊聊一个有点绕的问题：常指针;指向常量的指针;指向常量的常指针 先给声明： const int *p ----->    指向常量的指针（指针指向的数据不能改变，但是指针可以指向其他数据） int * const p   ----->    常指针（指针不可变，即指针不能指向其他数据，指针目前指向的数据可被改变） const int * const p  ----->    指向常量的常
const int *p;int *const p;int const *p;const int *const a;
King8611的博客
01-30 365
const int *p;和int const *p; 二者是一样的，其中const 修饰的是int，表示指针所指的对象不可以通过该指针被改变（但是不代表这个对象不可以通过其他途径改变），但是指针本身可以被改变。 eg: #include<bits/stdc++.h> usingnamespacestd; inta=1; intb=2; intconst*x=&am...
const int* p与int *const p的区别
最新发布
12-13
<think>我们正在讨论C++中两种指针声明方式的区别：`const int* p` 和 `int* const p`。 根据引用内容，我们可以总结如下： 1. `const int* p` （或等价的 `int const* p`）是指向常量的指针（pointer to constant）。这意味着： - 指针 `p` 所指向的内容（即 `*p`）是常量，不能通过 `p` 来修改。 - 但指针 `p` 本身可以改变，即可以重新指向另一个地址。 2. `int* const p` 是常量指针（constant pointer）。这意味着： - 指针 `p` 本身是常量，一旦初始化后就不能再指向其他地址。 - 但可以通过 `p` 修改它所指向的内容（即 `*p` 可以修改）。 我们通过示例和对比表格来详细说明。 示例代码（参考引用[4][5]）： ```cpp #include <iostream> using namespace std; int main() { int a = 10; int b = 20; // 情况1: const int* p (指向常量的指针) const int* p1 = &a; // 指向a // *p1 = 30; // 错误：不能通过p1修改a的值 p1 = &b; // 正确：p1可以指向b // 情况2: int* const p (常量指针) int* const p2 = &a; // p2将始终指向a *p2 = 30; // 正确：通过p2修改a的值 // p2 = &b; // 错误：p2不能指向其他地址 return 0; } ``` 对比表格： | 特性 | `const int* p` (指向常量的指针) | `int* const p` (常量指针) | |----------------------|--------------------------------|---------------------------| | **指针指向的内容** | 不可修改（`*p = ...` 非法） | 可修改（`*p = ...` 合法） | | **指针自身的指向** | 可修改（`p = ...` 合法） | 不可修改（`p = ...` 非法）| | **初始化要求** | 可不初始化（但通常初始化才有意义）| 必须初始化 | | **const关键字位置** | 在`*`左边（或类型前） | 在`*`右边（变量名前） | 另外，引用[2]提到，在引用中，`int& const b`是非法的，因为引用本身是常量（不能改变引用对象），所以不需要显式加const。而`const int&`和`int const&`是等价的，表示对常量的引用。 总结记忆口诀：**左定值，右定向**。 - 当const出现在`*`左边时，限定的是指针指向的内容为常量（定值）。 - 当const出现在`*`右边时，限定的是指针本身为常量（定向）。 注意：`const int* p`和`int const* p`是等价的，因为C++标准规定，const放在类型之前或之后（但必须在`*`之前）是等价的。而`int* const p`则是不同的。 应用场景： - 指向常量的指针：用于函数参数，表示函数不会修改指针指向的数据，增加安全性（如打印函数）[^5]。 - 常量指针：常用于固定指向某个内存地址（如硬件寄存器映射）[^4]。 最后，关于用户之前的问题，我们已经做了对比分析。现在生成相关问题： </think> ### `const int* p` 与 `int* const p` 对比分析 #### 一、核心区别总结 | 特性 | `const int* p` (常量指针) | `int* const p` (指针常量) | |----------------------|-----------------------------------|-----------------------------------| | **本质** | 指向常量的指针 (Pointer to const) | 指针本身是常量 (Const pointer) | | **修改指向的值** | ❌ 禁止 (`*p = val` 非法) | ✅ 允许 (`*p = val` 合法) | | **修改指针指向** | ✅ 允许 (`p = &x` 合法) | ❌ 禁止 (`p = &x` 非法) | | **const关键字位置** | `*` 左侧 (`const int*` 或 `int const*`)| `*` 右侧 (`int* const`) | | **初始化要求** | 可不初始化 | **必须初始化** | | **内存保护重点** | 保护数据内容 | 保护指针地址 | > 💡 **记忆口诀**： > `const` 在 `*` 左 → **定值** (值不可变) > `const` 在 `*` 右 → **定向** (指针不可变) #### 二、代码示例详解 ```cpp #include <iostream> using namespace std; int main() { int a = 10, b = 20; // === 示例1: const int* p (常量指针) === const int* p1 = &a; // ✅ 指向a cout << *p1 << endl; // 输出: 10 // *p1 = 15; // ❌ 编译错误: 不能修改指向的值[^3] p1 = &b; // ✅ 允许改变指向 cout << *p1 << endl; // 输出: 20 // === 示例2: int* const p (指针常量) === int* const p2 = &a; // ✅ 必须初始化 *p2 = 15; // ✅ 允许修改值 (a变为15) cout << a << endl; // 输出: 15 // p2 = &b; // ❌ 编译错误: 不能改变指向 // === 特殊场景 === const int c = 100; const int* p3 = &c; // ✅ 常量指针指向常量 // int* const p4 = &c; // ❌ 错误: 非const指针不能指向常量[^2] } ``` #### 三、底层原理分析 1. **`const int* p` 内存模型** ```mermaid graph LR p[指针变量p] -->|存储| A[地址A] A -->|指向| B[常量数据] ``` - 指针 `p` 存储在栈/堆中（可修改） - 目标数据被标记为只读（不可修改） 2. **`int* const p` 内存模型** ```mermaid graph LR p[常量指针p] -->|固定指向| A[地址A] A -->|指向| B[可变数据] ``` - 指针 `p` 的地址值被锁定（不可修改） - 目标数据可自由修改 #### 四、典型应用场景 1. **`const int* p` 适用场景** - 函数参数保护（防止意外修改）： ```cpp void print(const char* str) { // 保证不修改原始字符串[^5] cout << str; } ``` - 访问只读硬件寄存器 2. **`int* const p` 适用场景** - 固定地址映射（如嵌入式系统）： ```cpp volatile uint32_t* const PORT_A = (uint32_t*)0x4000; *PORT_A = 0xFF; // 向固定地址写入 ``` - 资源句柄的不可变引用 #### 五、特殊注意事项 1. **类型等价性** - `const int*` 与 `int const*` 完全等价[^1][^3] - 但 `const int*` 和 `int* const` **不等价** 2. **常量传播规则** - 常量指针可指向非常量变量（添加保护层）： ```cpp int x = 5; const int* p = &x; // ✅ 合法 ``` - 指针常量**不能**指向常量变量（除非双重const）： ```cpp const int y = 10; // int* const p = &y; // ❌ 非法 const int* const p = &y; // ✅ 合法[^2] ``` > ⚠️ **危险操作**： > 使用 `const_cast` 绕过 `const int*` 限制可能导致未定义行为： > ```cpp > const int val = 100; > const int* p = &val; > int* hack = const_cast<int*>(p); > *hack = 200; // 未定义行为！(可能引发崩溃) > ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值