【C++】指针、常量、引用、数组、字符串等辨析

目录

1. 什么是变量？
2. 什么是指针？
   指针的指针
3. 什么是引用、数组引用和引用数组？
4. 什么是字符数组与字符串？
5. 什么是数组指针与指针数组？
6. 什么是常量？
7. 什么是常量指针与指针常量？

    int ii=123;					  
    int* intPTR=ⅈ              //a pointer to a interger
    
    int ints[5]={1,2,3,4,5};        //an array of 5 intergers
    int(&intsREF)[5]=ints;          //a refrence to an array of 5 integers,reference must be initialized

    string strs[2]={"hello","world"};
    string(*strsPTR)=strs;          //a pointer to an array of character strings

    int** intPTRPTR=&intPTR;     //a pointer to a pointer of a interger


    const int CONST_INT=666;                        //a constant integer,a const must be initialized
    const int* PTR_TO_CONST_INT = &CONST_INT;       //a pointer to a constant integer
    int* const CONST_PTR_TO_INT = ⅈ              //a constant pointer to an integer

什么是变量？

当我们输入 int ii; 时，我们定义了一个变量ii，它拥有这些属性：

1. 这个变量的名称叫做 ii；
2. 这个变量的类型是 int；
3. 这个变量有一个地址，这个地址处储存了这个变量。地址的分配是自动的，但是你可以使用 &ii 来获取这个地址。地址一般被表示成一串16进制数，例如 ’0x61fe0c‘。另外，如果想cout char类型变量的地址请参考这篇文章。

int ii;
cout << &ii<<endl;

输出地址，为16进制数，例如：
0x61fe0c

当我们输入 ii=123; 时，我们给变量 ii 赋值了 123。也就是 ii 的值为 123。
当我们输入 int ii =123; 时，我们定义并赋值了变量 ii 。

int ii = 123;
cout << "值："<<ii<<endl<<"地址为："<<&ii<<endl;

输出：
值：123
地址为：0x61fe0c

什么是指针（Pointer）？

指针类型 是一种派生类型。例如，int* 类型是由 int 派生出的。
例如：int* intPTR = ⅈ
我们称intPTR是一个指向变量ii的指针。
intPTR 是这个指针的名称；int*是这个指针的类型；变量ii 的地址 是这个指针的值；同样地，系统也会自动地给指针分配一个地址&p。
注意分辨：指针的值p是指针指向的变量的地址，而指针的地址&p是指针本身的地址。

int ii = 123;
int* intPTR = ⅈ //定义一个 int* 的指针变量intPTR，并将 ii 的地址赋值
cout<<"ii的地址："<<&ii<endl;
cout<<"p的值："<<p<endl;
cout<<"p的地址："<<&p<endl;

输出：
ii的地址为：0x61fe1c
intPTR的值：0x61fe1c
intPTR的地址：0x61fe10

指针的指针

int** intPTRPTR=&intPTR; //a pointer to a pointer of a interger

什么是引用与数组引用？

引用（Reference）

引用：指对某个变量起别名；
A reference is an alternative name for an object.
例如：int& rr = ii; 表示声明了一个ii的引用rr；引用在被创建时必须初始化。
什么叫别名啊（战术后仰），就是压根就不存在变量rr，从头到尾只存在一个变量。它又叫ii又叫rr。
那么 &rr 就是 &ii，都是这个变量的地址；
如果有iiPTR和rrPTR，那么它们的值都是这个变量的地址；但是&iiPTR 和&rrPTR不一样，因为这是两个指针变量（尽管它们指向一个变量）。

    int ii =1;
    int& rr=ii;
    int *iiPTR=ⅈ
    int *rrPTR=&rr;
    cout<<"-------初始化时--------"<<endl;
    cout<<"ii的值："<<ii<<"\t\trr的值："<<rr<<endl;
    cout<<"ii的地址："<<&ii<<"\trr的地址："<<&rr<<endl;
    cout<<"iiPTR的值："<<iiPTR<<"\trrPTR的值："<<rrPTR<<endl;
 	cout<<"iiPTR的地址："<<&iiPTR<<"\trrPTR的地址："<<&rrPTR<<endl;
 	
    cout<<"-------ii++后--------"<<endl;
    ii++;
    cout<<"ii的值："<<ii<<"\t\trr的值："<<rr<<endl;
    
    cout<<"-------r++后--------"<<endl;
    rr++;
    cout<<"ii的值："<<ii<<"\t\trr的值："<<rr<<endl;

输出：
-------初始化时--------
ii的值：1               rr的值：1
ii的地址：0x61fe04      rr的地址：0x61fe04
iiPTR的值：0x61fe04     rrPTR的值：0x61fe04
iiPTR的地址：0x61fe08   rrPTR的地址：0x61fe00
-------ii++后--------
ii的值：2               rr的值：2
-------r++后--------
ii的值：3               rr的值：3

数组引用和引用数组

参考这篇文章

int &array[5] //an array of 5 references
引用数组；引用的数组；元素都是引用的一个数组
array 首先向右结合，相当于 (int&)array[]；
array是个数组，其中的元素是引用。
注意！这种写法是非法的！具体请参考上述文章。

int ints[5]={1,2,3,4,5}; //an array of 5 intergers
int(&intsREF)[5]=ints; //a reference of an array
数组引用；数组的引用；一个数组的引用
intsREF首先和&结合，所以intsREF是引用，引用的对象是数组

字符数组与字符串

char ch[3] = {'a','b','c'}是一个大小为3的字符数组；
字符串的本质就是字符数组。
但是，C语言规定，字符串必须以\0结尾（作为字符串的结束符号），所以字符串变量的元素个数比字符数组的元素多一个\0。
string str = "abc" 实际上str是：{'a','b','c',\0}。

数组指针与指针数组

指针数组

int *ptrArray[5]; //an array of 5 pointers
指针的数组；元素都为指针的一个数组；
ptrArray 首先向右结合，相当于 (int*)ptrArray[5]
ptrArray 是个数组，这个数组的元素都是指针。

数组指针

string strs[2]={"hello","world"}; //an array of 2 strings
string(*strsPTR)=strs; //a pointer of an array
数组的指针；一个指向数组的指针；
strPTR和*结合，表明类型是string * ，然后指向str数组的地址。
具体请参考这篇文章

什么是常量（Const）？

const 关键词能够自定义某一常量。它的值将不可改变。

const int c=1				c is a const
const int v[]={1,2,3,4}		v[4] is a const
const int x					error! 常量在定义时必须初始化
f(){
	c = 2;			错误！c是常量，不可被改变！
}

f(){
	int val=1;
	val=2;		val可被改变
	g(&val);
}
g(const int* p){
	*p=3;		错误！不能被改变！
}

常量指针与指向常量

当我们谈论一个指针的时候，我们讨论了两个 objects ，分别是指针本身，和指针所指向的量；
那么就会有这些情况：

指针常量（指向常量）

const int* ii//pointer to a const int
int const *ii //pointer to a const int
一个指针，它指向一个常量：
也就是说，C是一个常量，它的值不可改变；存在一个指针P，它指向C。
那么，*P(也就是C)是无法被修改的。*P=D在试图将D的值赋给C，是不可行的；
但是指针P本身的值，即所指向的量的地址，是可以被改变的。例如P=&D，指针P现在指向了D。

常量指针（常指针）

int *const ii//a const pointer to a int
一个常量，是个指针，它指向一个普普通通的int变量：
也就是说，对于同样的例子。*P(也就是C)是可以被修改的。*P=D是可行的；
但是指针P本身的值，即所指向的量的地址，是不可以被改变的。例如P=&D在试图使P指向D，是不可行的。

指向常量的常指针

const int* const p;

如何区分和记忆呢？

法1：
首先，*是只能存在类型之后的，表示这一类型的派生类型，所以只有：

1. int * const
2. int const *
3. const int *

其次。只有*const表示声明常量指针，const *不能用于声明常量指针。
于是，常指针的声明是 int *const。
指针常量（指向常量）的声明是 const int*和int const*

法2：
从右至左读：

int *const ip;		ip是 常量指针 指向 int	--> ip 是 指向int 的常量指针
int const* pi1;		pi1是 指针 指向 常量int
const int* pi2;		pi2是 指针 指向 int常量