C++中const指针用法汇总

这里以int类型为例，进行说明，在C++中const是类型修饰符：

int a; 定义一个普通的int类型变量a，可对此变量的值进行修改。

const int a = 3;与 int const a = 3; 这两条语句都是有效的code，并且是等价的，说明a是一个常量，不能对此常量的值进行修改。

const int* p =&a; 与 int const* p = &a; 这两条语句都是有效的code，但是它们不是等价的。其中const int* p = &a; 是平时经常使用的格式，声明一个指针，此指针指向的数据不能通过此指针被改变；int* const p = ∫ 声明一个指针，此指针不能被改变以指向别的东西。

const int *a; 这里const修饰的是int，而int定义的是一个整值,因此*a所指向的对象值不能通过*a来修改，但是可以重新给a来赋值，使其指向不同的对象；

int *const a; 这里const修饰的是a，a代表的是一个指针地址,因此不能赋给a其他的地址值，但可以修改a指向的值；

int const *a;和const int *a;的意义是相同的,它们两个的作用等价；

rules:

(1). A non-const pointer can be redirected to point to other addresses.

(2). A const pointer always points to the same address, and this address can not be changed.

(3). A pointer to a non-const value can change the value it is pointing to. These can not point to a const value.

(4). A pointer to a const value treats the value as const (even if it is not), and thus can not change the value it is pointing to.

以下是一些test code，详细信息可见相关的reference:

#include <iostream>
#include "const_pointer.hpp"

int test_const_pointer_1()
{
{ // reference: https://stackoverflow.com/questions/3247285/const-int-int-const
	int a			= 5;
	int *p1			= &a; //non-const pointer, non-const data
	const int *p2		= &a; //non-const pointer, const data, value pointed to by p2 can’t change
	int * const p3		= &a; //const pointer, non-const data, p3 cannot point to a different location
	const int * const p4	= &a; //const pointer, const data, both the pointer and the value pointed to cannot change
	int const * const p5 = &a; // 与 const int * const p5等价
}

{ // reference: https://stackoverflow.com/questions/162480/const-int-vs-int-const-as-function-parameter-in-c-and-c
	// read the declaration backwards (right-to-left):
	const int a1 = 1; // read as "a1 is an integer which is constant"
	int const a2 = 1; // read as "a2 is a constant integer"
	// a1 = 2; // Can't do because a1 is constant
	// a2 = 2; // Can't do because a2 is constant

	char a = 'a';
	const char *s = &a; // read as "s is a pointer to a char that is constant"
	char const *y = &a; // 与 const char *y 等价
	char c;
	char *const t = &c; // read as "t is a constant pointer to a char"

	// *s = 'A'; // Can't do because the char is constant
	s++;         // Can do because the pointer isn't constant
	*t = 'A';    // Can do because the char isn't constant
	// t++;      // Can't do because the pointer is constant
	// *y = 'A';
	y++;
}

{ // reference: http://www.geeksforgeeks.org/const-qualifier-in-c/
	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);
}

{ // const int *ptr <==> int const *ptr
	int i = 10;
	int j = 20;
	const int *ptr = &i;    /* ptr is pointer to constant */

	printf("ptr: %d\n", *ptr);
	// *ptr = 100;        /* error: object pointed cannot be modified using the pointer ptr */

	ptr = &j;          /* valid */
	printf("ptr: %d\n", *ptr);
}

{ // int * const ptr
	int i = 10;
	int j = 20;
	int *const ptr = &i;    /* constant pointer to integer */

	printf("ptr: %d\n", *ptr);

	*ptr = 100;    /* valid */
	printf("ptr: %d\n", *ptr);

	// ptr = &j;        /* error */
}

{ // const int *const ptr;
	int i = 10;
	int j = 20;
	const int *const ptr = &i;        /* constant pointer to constant integer */

	printf("ptr: %d\n", *ptr);

	// ptr = &j;            /* error */
	// *ptr = 100;        /* error */
}

{ // reference: http://www.learncpp.com/cpp-tutorial/610-pointers-and-const/
	int value = 5;
	int *ptr = &value;
	*ptr = 6; // change value to 6

	const int value2 = 5; // value is const
	// int *ptr2 = &value2; // compile error: cannot convert const int* to int*

	const int *ptr3 = &value2; // this is okay, ptr3 is pointing to a "const int"
	// *ptr3 = 6; // not allowed, we can't change a const value

	const int *ptr4 = &value; // ptr4 points to a "const int"
	fprintf(stderr, "*ptr4: %d\n", *ptr4);
	value = 7; // the value is non-const when accessed through a non-const identifier
	fprintf(stderr, "*ptr4: %d\n", *ptr4);
}

	return 0;
}

//
// reference: https://en.wikipedia.org/wiki/Const_(computer_programming)
class C {
	int i;
public:
	int Get() const { // Note the "const" tag
		return i;
	}
	void Set(int j) { // Note the lack of "const"
		i = j;
	}
};

static void Foo_1(C& nonConstC, const C& constC)
{
	int y = nonConstC.Get(); // Ok
	int x = constC.Get();    // Ok: Get() is const

	nonConstC.Set(10); // Ok: nonConstC is modifiable
	// constC.Set(10);    // Error! Set() is a non-const method and constC is a const-qualified object
}

class MyArray {
	int data[100];
public:
	int &       Get(int i)       { return data[i]; }
	int const & Get(int i) const { return data[i]; }
};

static void Foo_2(MyArray & array, MyArray const & constArray) {
	// Get a reference to an array element
	// and modify its referenced value.

	array.Get(5) = 42; // OK! (Calls: int & MyArray::Get(int))
	// constArray.Get(5) = 42; // Error! (Calls: int const & MyArray::Get(int) const)
}

typedef struct S_ {
	int val;
	int *ptr;
} S;

void Foo_3(const S & s)
{
	int i = 42;
	// s.val = i;   // Error: s is const, so val is a const int
	// s.ptr = &i;  // Error: s is const, so ptr is a const pointer to int
	// *s.ptr = i;  // OK: the data pointed to by ptr is always mutable,
		     // even though this is sometimes not desirable
}

int test_const_pointer_2()
{
	C a, b;
	Foo_1(a, b);

	MyArray x, y;
	Foo_2(x, y);

	S s;
	Foo_3(s);

	return 0;
}

GitHub： https://github.com/fengbingchun/Messy_Test