const int*,const int*const和int const*之间有什么区别？

Question

我总是搞砸了怎么用const int*,const int * const和int const *正确的.是否有一套规则来定义您能做什么和不能做什么？

我想知道在任务,传递到职能等方面所做的所有事情和所有不应做的事情.

Answer 1

向后读(由顺时针/螺旋规则驱动):

• int* - 指向int的指针
• int const * - 指向const int的指针
• int * const - const指向int的指针
• int const * const - const指向const int的指针

现在第一个const可以在类型的任何一侧,所以:

• const int * == int const *
• const int * const == int const * const

如果你想变得非常疯狂,你可以做这样的事情:

• int ** - 指向int的指针
• int ** const - 指向int的指针的const指针
• int * const * - 指向int的const指针的指针
• int const ** - 指向const int指针的指针
• int * const * const - 指向int的const指针的const指针
• ...

并确保我们清楚const的含义

const int* foo;
int *const bar; //note, you actually need to set the pointer 
                //here because you can't change it later ;)

foo是一个指向常量整数的变量指针.这使您可以更改指向的内容,但不能更改指向的值.大多数情况下会看到C风格的字符串,其中有一个指向a的指针const char.您可以更改指向的字符串,但不能更改这些字符串的内容.当字符串本身位于程序的数据段中且不应更改时,这很重要.

bar是一个指向可以更改的值的常量或固定指针.这就像没有额外语法糖的参考.因为这个事实,通常你会使用一个你将使用T* const指针的引用,除非你需要允许NULL指针.

Answer 2

对于那些不了解顺时针/螺旋规则的人:从变量的名称开始,顺时针移动(在这种情况下,向后移动)到下一个指针或类型.重复直到表达结束.

这是一个演示:

Answer 3

我想这里已经回答了所有问题,但我只想补充一点,你应该小心typedefs!它们不仅仅是文本替换.

例如:

typedef char *ASTRING;
const ASTRING astring;

类型astring是char * const,而不是const char *.这是我总是倾向于放在const类型右侧的一个原因,而不是从一开始.

Answer 4

几乎所有人都指出:

有什么区别const X* p,X* const p和const X* const p？

你必须从右到左阅读指针声明.

• const X* p 表示"p指向一个常数为X的X":不能通过p更改X对象.

• X* const p 表示"p是指向非const的X的const指针":您不能更改指针p本身,但可以通过p更改X对象.

• const X* const p 表示"p是指向X的常量指针":您不能更改指针p本身,也不能通过p更改X对象.

Answer 5

1. 常量参考:

   对变量(此处为int)的引用,它是常量.我们主要将变量作为引用传递,因为引用的大小小于实际值,但是存在副作用,这是因为它就像实际变量的别名.我们可能会通过完全访问别名来意外更改主变量,因此我们将其设置为常量以防止此副作用.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK
   

2. 常量指针

   一旦常量指针指向变量,它就不能指向任何其他变量.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error
   

3. 指向常数的指针

   一个指针,通过它可以不改变它指向的变量的值,这个指针称为指向常量的指针.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error
   

4. 指向常量的常量指针

   指向常量的常量指针是一个指针,既不能改变它指向的地址,也不能改变保存在该地址的值.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error
   

Answer 6

一般规则是const关键字立即适用于它之前的内容.例外,一个起点const适用于以下内容.

• const int*是int const*和"指向常量int"的意思相同.
• const int* const是int const* const和"指向常量int的常量指针"相同.

编辑: 对于Dos和Don'ts,如果这个答案还不够,你能更准确地了解你想要的吗？

Answer 7

这个问题恰恰说明了为什么我喜欢按照我在问题中提到的方式做事,因为类型id可以接受？

简而言之,我发现记住规则的最简单方法是"const" 在它适用的东西之后.所以在你的问题中,"int const*"意味着int是常量,而"int*const"意味着指针是常量.

如果有人决定把它放在最前面(例如:"const int*"),作为一种特殊的例外情况,它适用于它后面的东西.

许多人喜欢使用这个特殊的例外,因为他们认为它看起来更好.我不喜欢它,因为它是一个例外,因此混淆了事情.

Answer 8

简单使用'const'

最简单的用法是声明一个命名常量.为此,我们声明一个常量,好像它是一个变量,但在它之前加上'const'.必须立即在构造函数中初始化它,因为当然,之后无法设置值,因为这会改变它.例如,

const int Constant1=96; 

将创建一个整数常量,无法想象地称为"Constant1",值为96.

这些常量对于程序中使用的参数很有用,但在编译程序后不需要更改.对于程序员而言,它优于C预处理器'#define'命令,因为编译器本身可以理解和使用它,而不是在到达主编译器之前由预处理器替换为程序文本,因此错误消息更有帮助.

它也适用于指针但是必须要小心'const'来确定指针或它指向的是否是常量或两者.例如,

const int * Constant2 

声明Constant2是指向常量整数的变量指针

int const * Constant2

是一种替代语法,它做同样的事情,而

int * const Constant3

声明Constant3是一个指向变量integer的常量指针

int const * const Constant4

声明Constant4是指向常量整数的常量指针.基本上'const'适用于其左边的任何东西(除非没有任何东西,在这种情况下它适用于它的直接权利).

参考:http://duramecho.com/ComputerInformation/WhyHowCppConst.html

Answer 9

在我遇到C++大师Scott Meyers的这本书之前,我有同样的疑问.请参阅本书中的第三个项目,其中详细介绍了如何使用const.

请遵循这个建议

1. 如果这个词const出现在星号的左边,那么指向的是不变的
2. 如果单词const出现在星号的右侧,则指针本身是常量
3. 如果const双方都出现,两者都是不变的

Answer 10

这很简单但很棘手.请注意,我们可以交换const与任何数据类型(预选赛int,char,float,等).

我们来看下面的例子.

const int *p==> *p是只读的[ p是指向常量整数的指针]

int const *p==> *p是只读的[ p是指向常量整数的指针]

int *p const==> 错误的陈述.编译器抛出语法错误.

int *const p==> p是只读的[ p是指向整数的常量指针].由于p这里的指针是只读的,因此声明和定义应该在同一个地方.

const int *p const ==> 错误的陈述.编译器抛出语法错误.

const int const *p ==> *p是只读的

const int *const p1 ==> *p并且p是只读的[ p是指向常量整数的常量指针].由于p这里的指针是只读的,因此声明和定义应该在同一个地方.

int const *p const ==> 错误的陈述.编译器抛出语法错误.

int const int *p ==> 错误的陈述.编译器抛出语法错误.

int const const *p ==> *p是只读的,相当于int const *p

int const *const p ==> *p并且p是只读的[ p是指向常量整数的常量指针].由于p这里的指针是只读的,因此声明和定义应该在同一个地方.

Answer 11

以简单的方式记住：

如果 const 在 * 之前，则值是常量。

如果 const 在 * 之后，则地址是常量。

如果 const 在 * 之前和之后都可用，则值和地址都是常量。

例如

1. int * 常量变量；//这里地址是常量。

2. int const * var；//这里的值是常量。

3. int const * const var；// 值和地址都是常量。

Answer 12

在C++中还有很多其他关于const正确性的细微之处.我想这里的问题只是关于C,但我会给出一些相关的例子,因为标签是C++:

• 您经常传递像字符串TYPE const &这样的大型参数,以防止对象被修改或复制.示例:

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  但是TYPE & const没有意义,因为引用总是const.

• 您应该始终标记不修改类的类方法const,否则您无法从TYPE const &引用中调用该方法.示例:

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• 常见的情况是返回值和方法都应该是const.示例:

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  实际上,const方法不能将内部类数据作为引用返回非const.

• 因此,必须经常使用const重载创建const和非const方法.例如,如果你定义T const& operator[] (unsigned i) const;,那么你可能也想要由下式给出的非const版本:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Afaik,C中没有const函数,非成员函数本身不能在C++中使用const,const方法可能有副作用,而编译器不能使用const函数来避免重复函数调用.事实上,即使是简单的int const &参考也可能见证它在其他地方被改变的价值.

Answer 13

原始设计者反复将C和C++声明语法描述为失败的实验.

相反,让我们将类型命名为"指向Type"; 我会称之为Ptr_:

template< class Type >
using Ptr_ = Type*;

现在Ptr_<char>是一个指针char.

Ptr_<const char>是一个指针const char.

并且const Ptr_<const char>是一个const指针const char.

那里.

Answer 14

两侧带有 int 的 const 将指向常量 int：

const int *ptr=&i;

或者：

int const *ptr=&i;

constafter*将使常量指针指向 int：

int *const ptr=&i;

在这种情况下，所有这些都是指向常量 integer 的指针，但这些都不是常量指针：

 const int *ptr1=&i, *ptr2=&j;

在这种情况下，所有都是指向常量 integer 的指针，ptr2 是指向常量 integer 的常量指针。但 ptr1 不是常量指针：

int const *ptr1=&i, *const ptr2=&j;

Answer 15

对我而言，const即相对于左侧或右侧出现还是相对于左侧和右侧出现的位置*有助于我弄清实际含义。

1. constLEFT的A *表示指针所指向的const对象是对象。

2. constRIGHT的A *表示指针是const指针。

下表摘自Stanford CS106L标准C ++编程实验室课程阅读器。