C中的const限定符介绍和用法示例 _C语言

限定符const可以应用于任何变量的声明, 以指定其值不会更改(这取决于const变量的存储位置, 我们可以使用指针更改const变量的值)。
【C中的const限定符介绍和用法示例】如果尝试更改const, 则结果是实现定义的。
1)指向变量的指针。

int *ptr;

我们可以更改ptr的值, 也可以更改指向对象ptr的值。指针和指针所指向的值都存储在读写区域中。请参见以下代码片段。

#include < stdio.h> int main( void ) { int i = 10; int j = 20; int *ptr = & i; /* pointer to integer */ printf ( "*ptr: %d\n" , *ptr); /* pointer is pointing to another variable */ ptr = & j; printf ( "*ptr: %d\n" , *ptr); /* we can change value stored by pointer */ *ptr = 100; printf ( "*ptr: %d\n" , *ptr); return 0; }

输出如下：

*ptr: 10*ptr: 20*ptr: 100

2)指向常量的指针。
指向常量的指针可以通过以下两种方式声明。

const int *ptr;

int const *ptr;

我们可以更改指针以指向任何其他整数变量, 但是不能更改使用指针ptr指向的对象(实体)的值。指针存储在读写区域(当前为堆栈)中。指向的对象可能在只读或读写区域中。让我们看下面的例子。

#include < stdio.h> int main( void ) { int i = 10; int j = 20; /* ptr is pointer to constant */ const int *ptr = & i; printf ( "ptr: %d\n" , *ptr); /* error: object pointed cannot be modified using the pointer ptr */ *ptr = 100; ptr = & j; /* valid */ printf ( "ptr: %d\n" , *ptr); return 0; }

输出如下：

error: assignment of read-only location ‘*ptr’

以下是变量i本身为常数的另一个示例。

#include < stdio.h> int main( void ) { /* i is stored in read only area*/ int const i = 10; int j = 20; /* pointer to integer constant. Here i is of type "const int", and & i is of type "const int *".And p is of type "const int", types are matching no issue */ int const *ptr = & i; printf ( "ptr: %d\n" , *ptr); /* error */ *ptr = 100; /* valid. We call it up qualification. In C/C++, the type of "int *" is allowed to up qualify to the type "const int *". The type of & j is "int *" and is implicitly up qualified by the compiler to "const int *" */ ptr = & j; printf ( "ptr: %d\n" , *ptr); return 0; }

输出如下：

error: assignment of read-only location ‘*ptr’

C ++中不允许使用降级资格, 并且可能在C语言中引起警告。以下是降级资格的另一个示例。

#include < stdio.h> int main( void ) { int i = 10; int const j = 20; /* ptr is pointing an integer object */ int *ptr = & i; printf ( "*ptr: %d\n" , *ptr); /* The below assignment is invalid in C++, results in error In C, the compiler *may* throw a warning, but casting is implicitly allowed */ ptr = & j; /* In C++, it is called 'down qualification'. The type of expression & j is "const int *" and the type of ptr is "int *". The assignment "ptr = & j" causes to implicitly remove const-ness from the expression & j. C++ being more type restrictive, will not allow implicit down qualification. However, C++ allows implicit up qualification. The reason being, const qualified identifiers are bound to be placed in read-only memory (but not always). If C++ allows above kind of assignment (ptr = & j), we can use 'ptr' to modify value of j which is in read-only memory. The consequences are implementation dependent, the program may fail at runtime. So strict type checking helps clean code. */printf ( "*ptr: %d\n" , *ptr); return 0; } // Reference: // http://www.dansaks.com/articles/1999-02%20const%20T%20vs%20T%20const.pdf// More interesting stuff on C/C++ @ http://www.dansaks.com/articles.shtml

3)常数变量的指针。

int * const ptr;

上面的声明是一个指向整数变量的常量指针, 这意味着我们可以更改指针所指向的对象的值, 但不能将指针更改为指向另一个变量。

#include < stdio.h> int main( void ) { int i = 10; int j = 20; /* constant pointer to integer */ int * const ptr = & i; printf ( "ptr: %d\n" , *ptr); *ptr = 100; /* valid */ printf ( "ptr: %d\n" , *ptr); ptr = & j; /* error */ return 0; }

输出如下：

error: assignment of read-only variable ‘ptr’

4)常量指向常量

const int * const ptr;

上面的声明是指向常量变量的常量指针, 这意味着我们不能更改指针所指向的值, 也不能将指针指向其他变量。让我们看一个例子。

#include < stdio.h> int main( void ) { int i = 10; int j = 20; /* constant pointer to constant integer */ const int * const ptr = & i; printf ( "ptr: %d\n" , *ptr); ptr = & j; /* error */ *ptr = 100; /* error */return 0; }

输出如下：