C++指针常量和常量指针（int *const p和const int *p）/引用和指针/函数传参

目录

指针常量和常量指针

1、指针常量——指针类型的常量（int *const p）

2、常量指针——指向“常量”的指针（const int *p， int const *p）

引用与指针

在c++中关于* 和&在结构体定义使用的的区别

解决问题

---

指针常量和常量指针

记忆方法：

const=常量，*=指针

1. 按先后顺序写出对应的名字

const在*前是常量指针，指向可以改变，但是指向的内容不能改变。
*在const前是指针常量，指向不能改变，所以一定要赋初值

2. 前者值不可更改。

指针常量：指针在前，则指针指向不可更改，"常量"值可变。

1、指针常量——指针类型的常量（int *const p）

本质是一个常量（广义概念：‘不变化的量’）。类似整型常量是指一个整型的常量，指针常量是一个指针类型的常量。在定义的同时必须初始化。

指针的值是一个常量，即指向不可改变，但指向的内容可以改变。

int main() {
    int m = 10;
    const int n = 20; // 必须在定义的同时初始化
 
    int * const ptr2 = &m; // ptr2：指针常量
 
    ptr2 = &n; // 错误，ptr2不能指向其他地方
 	*ptr2 = 4; // 正确，ptr2指向的内容可以改变
 
    int * const ptr5; // 错误，指针常量定义时必须初始化
    ptr5 = &m; // 错误，指针常量不能在定义后赋值
 
    int * const ptr8 = &n;//错误，"const int*”类型的值不能用于初始化“int *const”类型的实体
    
    const int * const ptr6 = &m; // 指向“常量”的指针常量，具有常量指针和指针常量的特点，指针内容不能改变，也不能指向其他地方，定义同时要进行初始化
    return 0;
}

2、常量指针——指向“常量”的指针（const int *p， int const *p）

本质是一个指针，该指针指向一个“常量”。

指向可以改变，指向的内容不能改变。

int main() {
    int m = 10;
    const int n = 20; //常量必须在定义的同时初始化
 
    const int *ptr1 = &m; // ptr1：常量指针
	ptr1 = &n; // 正确，指针指向可改变，指针可以指向其他地址
    *ptr1 = 3; // 错误，ptr1不能改变指针内容不可变
 
    int *ptr3 = &n; // 错误，常量的地址不能初始化普通指针（"const int*”类型的值不能用于初始化"int*”类型的实体），常量地址只能赋值给常量指针
    const int * ptr4 = &n; // 正确，常量地址初始化常量指针
	
	const int * ptr7; // 正确
    ptr7 = &m; // 正确
   
    return 0;
}

---

引用与指针

int main() {
	int a = 10;
	int *p1 = &a;
	int& p2 = a;
	return 0;
}

p1是指针，p2是引用

指针：指针就是内存地址

引用：引用不是新定义一个变量,而是相当于给已存在变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。引用在定义时必须初始化。

类型& 引用变量名= 引用实体; 

在C++语言中,函数的参数和返回值的传递方式有三种:值传递,指针传递和引用传递.引用具有指针的效率,又具有变量使用的方便性和直观性.

---

在c++中关于* 和&在结构体定义使用的的区别

// An highlighted block
typedef struct queue {
	item_t data[MAXSIZE];
	int front, rear;
	//当前队列的元素数量
	int size;
}Sequeue,*queue_t;

//第一种
void InitQueue(Sequeue & q)
{
	q.front = q.rear = 0;
	q.size = 0;
}

//第二种
void InitQueue(queue_t q)
{

	q->front = q->rear = 0;
	q->size = 0;
}

---

解决问题

写这篇博客主要是记录下自己的困惑，前面的内容都是前置知识(部分b兄的补充，感恩！)。

b兄（大佬）的代码片段如下：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
// 定义状态向量类 
class status{
public:
	int person,cat,chicken,rice;
	status(){
	}
	status(int a1,int a2,int a3,int a4){
		person=a1;
		cat=a2;
		chicken=a3;
		rice=a4;
	}

//	重载异或运算符 
	status operator^(const status& p){
		status t;
		t.person=this->person^p.person;
		t.cat=this->cat^p.cat;
		t.chicken=this->chicken^p.chicken;
		t.rice=this->rice^p.rice;
		return t;
	}
};

疑问一：为什么p和t访问成员变量时都使用‘.’操作符？（这个问题是我傻了）

解答：类对象和类对象的引用访问成员变量时都使用‘.’操作符（想想JAVA！）

疑问二：函数传参时为什么要用引用传递？

第一.类一般比较大，加取地址符是引用（也就是指针），传指针比传值复制快
第二.用了引用之后，访问成员变量用‘.’(e.g. t.person)比'->'好写一点c语言里面的好用（懒癌福音）

疑问三：函数传参时为什么要加const？

加const就是为了安全，防止不小心改变原本的对象

（比如说x是一个status对象，那status& t = x;相当于status * const t = &x;编译器会自动帮你转换；然后const status& p相当于const status * const p指向和指向的内容都不能改变）

---

参考文章：

1.(285条消息) 指针常量和常量指针_qq_36132127的博客-CSDN博客

2.(284条消息) 引用与指针的区别_引用和指针的区别_嫌疑人X的替身的博客-CSDN博客

3.(284条消息) 在c++中关于* 和&在结构体定义使用的的区别_*&rear_Michael·Young的博客-CSDN博客