目录
复合类型
复合类型（compound type）是指基于其他类型定义的类型。C++语言有几种复合类型，常见的复合类型包括数组、指针、引用、结构体、联合体、类、枚举、函数指针和模板等，本文将介绍其中的两种：引用和指针。
一、引用【引用即别名】
在 C++ 中，引用是一个别名，允许我们为一个已经存在的对象创建一个新的名字。通过引用，我们可以直接操作原始对象，而不是操作该对象的副本。
语法示例：
int a=10;
int &r1=a; // 定义一个名为r1的引用，r1绑定到a对象上1. 在 C++ 中，引用本身不占用内存，它只是一个对象的别名，引用和被引用的对象共享同一块内存，如下所示：
#include<iostream>
int main(){
int a=10; // 声明并初始化变量a
int &refa=a; // 定义一个名为refa的引用，refa指向a（是a的另一个名字）
std::cout<<"refa的地址为:"<<&(refa)<<std::endl;
std::cout<<"a的地址为:"<<&(a)<<std::endl;
return 0;
}
// 程序输出：
// refa的地址为:0x61fe44
// a的地址为:0x61fe442.引用必须被初始化，且不能初始化为null或nullptr。
int &refval2; // 报错，引用必须被初始化
int &ref = nullptr; // 错误：引用不能被初始化成nullptr3. 定义一个引用，对其进行的所有操作都是在与之绑定的对象上进行的：
一般在初始化变量时，初始值会被拷贝到新建的对象中。然而定义引用时，程序把引用和它的初始值绑定（bind）在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和他的初始值对象一直绑定在一起。因为无法令引用重新绑定到另外一个对象，因此引用必须初始化。
// 基本类型的初始化
// 对于基本类型（如 int、float 等），通常会发生值拷贝。例如：
int a = 10;
int b = a; // a 的值会被拷贝到 b 中
定义一个引用，对其进行的所有操作都是在与之绑定的对象上进行的：
#include<iostream>
int main(){
int a=10; // 声明并初始化变量a
int &refa=a; // 定义一个名为refa的引用，refa指向a（是a的另一个名字）
refa=5; // 修改引用，即修改对象a
std::cout<<a; // 输出：5
return 0;
}为引用赋值，实际上是把值赋给了与引用绑定的对象。 获取引用的值，实际上是获取了与引用绑定的对象的值。同理，以引用作为初始值，实际上是以与引用绑定的对象作为初始值：
#include<iostream>
int main(){
int a=10; // 声明并初始化变量a
int &refa=a; // 定义一个名为refa的引用，refa指向a（是a的另一个名字）
refa = 5; // 为引用refa赋值，实际上是把值赋给了与引用绑定的对象a。这条语句的执行，a会变成5
std::cout<<refa; // 获取引用的值，实际上是获取了与引用绑定的对象的值。输出：5
// 利用与refa绑定的对象的值初始化变量b
int b=refa; // 正确，b被初始化为a的值，b被初始化为5
return 0;
}4. 由于引用本身不是一个对象，所以不能定义引用的引用。
int a = 10;
int &refa = a;
// int & &refb = refa; // ❌ 编译错误，不能定义引用的引用
这种写法是非法的，因为 refa 只是 a 的别名，不是一个独立的变量，C++ 不允许对其再取引用。
5. 引用只能绑定在对象上，而不能与字面值或某个表达式的计算结果绑定在一起。
#include<iostream>
int main(){
int &refval = 10; // 错误：引用类型的初始值必须是一个对象，引用不能与字面值绑定在一起
int val = 10;
int &refval = val; // 正确：引用类型的初始值必须是一个对象
int &refval2 = val+1; // 错误：引用不能与表达式的计算结果绑定在一起
const int &ref = 2; // 正确：常量引用
return 0;
}6. 引用的类型必须要和与之绑定的对象的类型严格匹配。
#include<iostream>
int main(){
double i=10.2;
int &ref = i; // 错误：此处引用类型的初始值必须是int型对象
return 0;
}7.允许在一条语句中定义多个引用，其中每个引用标识符都必须以符号&开头。
#include<iostream>
int main(){
int i=1024,i2=2048; // i和i2都是int
int &r=i,r2=i2; // r是一个引用，与i绑定在一起，r2是int
int i3=1024,&ri=i3; // i3是int，ri是一个引用，与i3绑定在一起
int &r3=i3,&r4=i2; // r3和r4都是引用
return 0;
}8.引用是不能进行解引用操作的
#include<iostream>
int main(){
int i=42;
int &refi = i;
std::cout<<"*refi 的值为:"<<*refi<<std::endl; // 错误：
return 0;
}分析：
refi是i的 引用 (int &refi = i;)，它并不是指针，因此不能使用*refi进行解引用。*只能用于 指针，但refi只是i的别名，本质上仍然是int类型，而不是int*。std::cout << *refi;试图对int进行指针解引用操作，编译器报错：operand of '*' must be a pointer but has type "int" 意思是 * 操作符的操作数必须是指针，但 refi 只是 int 类型的引用，不能用 * 进行解引用。
总结
引用是对象的别名： 引用并不占用额外的内存，它只是已有变量的别名，所有操作都会作用到原始变量上。
引用必须初始化： 引用在声明时必须绑定到一个合法的对象，不能不初始化。C++ 不允许声明没有初始化的引用。
引用不能更改绑定对象： 一旦引用绑定到某个对象，它就不能再绑定到其他对象。也就是说，引用是不可重新绑定的。
引用不占用内存： 引用本身不会占用新的内存空间。它只是一个简单的别名，直接指向原对象的内存位置。
引用不能为 NULL 或 nullptr： 引用必须引用有效的对象，不能指向 NULL 或 nullptr。
二、指针
指针：指针是一个变量，它存储对象的内存地址，指针本身是一个独立的变量，占用内存。
指针（pointer）是“指向（point to）”另外一种类型的复合类型。与引用类似，指针也实现了对其他对象的间接访问。然而指针与引用相比又有很多不同点。其一，指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以先后指向几个不同的对象。其二，指针无须在定义时赋初值。和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值。
2.1 语法
// 基本数据类型 *变量名; 未初始化的指针
// 基本数据类型 *变量名=nullptr; 初始化为nullptr的指针
int *p1; // 定义一个整型指针变量p1如果在一条语句中定义了几个指针变量，每个变量前面都必须要有符号*：
int *p1,*p2; // p1和p2都是指向int型对象的指针
double dp,*dp2; // dp是double型对象，dp2是指向double型对象的指针2.2 获取对象的地址
指针存放某个对象的地址，要想获取该地址，需要使用取地址符（操作符&）：
int val=10;
int *p1=&val; // p1存放变量val的地址，或者说p1是指向变量val的指针第二条语句把p1定义为一个指向int的指针，随后初始化p1令其指向名为val的int对象。因为引用不是对象，没有实际地址，所以不能定义指向引用的指针（int &* ,这是非法的）。
#include<iostream>
int main(){
int val=10;
int &*refval=val; // 报错：不能定义指向引用的指针
return 0;
}为什么不能有指向引用的指针？
- 引用 (
&) 只是变量的别名，它本质上不是一个独立的对象，没有自己的地址，因此不能有指向引用的指针。 int &refval = val;refval只是val的别名，实际上refval和val共享同一块内存，没有单独的存储单元。- 指针存储的是地址，但引用没有独立的地址，所以不能用指针指向引用。
不能用引用初始化指针。
#include<iostream>
int main(){
int val=10;
int &refval=val;
int *p1=refval; // 错误：类型不匹配，不能用引用初始化指针，引用refval是int类型，而p1是int*类型
return 0;
}指针的类型要和它所指向的对象严格匹配：
#include<iostream>
int main(){
double dval;
double *pd = &dval; // 正确：初始值是double型对象的地址
double *pd2 = pd; // 正确：初始值是指向double对象的指针
int *pi = pd; // 错误：指针pi的类型和pd的类型不匹配
pi = &dval; // 错误：试图把double型对象的地址赋给int型指针
return 0;
}2.3 利用指针访问对象、修改对象
如果指针指向了一个对象，则允许使用解引用符（操作符*）来访问该对象：
#include<iostream>
int main(){
int val=42;
int *p=&val; // p存放着变量val的地址，或者说p是指向变量val的指针
std::cout<<*p; // 由符号*得到指针p所指的对象，输出42
*p=3; // 为*p赋值实际上是为p所指的对象赋值
std::cout<<val; // 借助指针直接修改指向的对象的值，输出3
}
2.4 void*指针【通用指针】
2.5 指向指针的指针
指针是内存中的对象，像其他对象一样也有自己的地址，因此允许把指针的地址再存放到另一个指针当中。
通过*的个数可以区分指针的级别。**表示指向指针的指针，***表示指向指针的指针的指针，以此类推：
解引用int型指针会得到一个int型的数，同样，解引用指向指针的指针会得到一个指针。此时为了访问最原始的那个对象，需要对指针的指针做两次解引用：
2.6 指向指针的引用
引用本身不是对象，因此不能定义指向引用的指针。但指针是对象，所以存在对指针的引用：
代码分析与验证：
#include<iostream>
int main(){
int i=42;
int *p; // 定义一个整型指针
int *&r=p; // r 是一个对指针 p 的引用，也就是说，r与指针p共享一块儿内存，r与p的地址一致
r = &i; // r引用了一个指针，因此给r赋值&i就是令p指向i【修改引用的值其实本质上在修改引用的对象的值，r引用的对象是指针p，指针p初始化没有赋值，在此时通过修改指针p的引用从而为指针p赋值】
std::cout<<"i 的地址为:"<<&(i)<<std::endl;// i 的地址为:0x61fe44
std::cout<<"p 的值为:"<<p<<std::endl; // p 的值为:0x61fe44
std::cout<<"r 的值为:"<<r<<std::endl; // r 的值为:0x61fe44
std::cout<<"(*r) 的值为:"<<*r<<std::endl; //(*r) 的值为:42
std::cout<<"i 的值为:"<<i<<std::endl; //i 的值为:42
*r=0; // 解引用r得到i，也就是p指向的对象，将i 的值改为0
std::cout<<"i 的值为:"<<i<<std::endl; //i 的值为:0
return 0;
}问题：上述代码中，*r=0；可以执行，大家可能会有疑惑，r是一个对指针p的引用，那么本质上还是一个引用，那为什么还能解引用？ 我们都知道，引用本身并不支持解引用操作，那这里为什么可以呢？
指向指针的引用（Pointer Reference，
int *&）本质上仍然是一个引用，而不是指针，但它是指针的别名，可以通过它来间接操作指针指向的地址。int *&ptrRef = ptr;
ptrRef是 指针的引用（Pointer Reference），本质上是ptr这个指针的别名。ptrRef仍然是一个引用，而不是新的指针。- 但是
ptrRef引用的是指针，所以可以通过ptrRef来修改ptr的值（即指向的地址）。常见误解
概念 是否是指针 本质 int *ptr✅ 是指针 存储地址，可以指向 int变量int &ref❌ 不是指针 只是 int变量的别名，没有独立地址int *&ptrRef❌ 不是指针 是指针 ptr的别名，它是引用
int *&r=p; 表示r是一个对指针p的引用，如下所示：
#include<iostream>
int main(){
int i=42;
int *p = &i; // p是一个int型指针，指向i对象
int *&r=p; // r 是一个对指针 p 的引用，也就是说，r与指针p共享一块儿内存，r与p的地址一致
std::cout<<"p 的值为:"<<p<<std::endl; // p 的值为:0x61fe44
std::cout<<"r 的值为:"<<r<<std::endl; // r 的值为:0x61fe44
}不能定义指向引用的指针，如下所示：
int &*r=p; // 报错：r是一个指向引用的指针，因此错误三、总结
指针（Pointer） 和 引用（Reference） 都是在 C++ 中用于操作变量的地址或者间接访问对象的工具。它们的共同点和区别如下：
共同点
间接访问：
- 都可以间接地访问和修改原始变量的值。通过指针或引用操作，可以访问和修改它们所指向的对象。
访问同一内存：
- 无论是通过指针还是引用，它们都指向一个内存位置，操作时会影响这个内存位置的数据，因此间接修改原对象。
用于提高效率：
- 对于较大对象（如大数组、对象等），通过引用或指针传递参数可以避免拷贝操作，从而提高程序效率。
区别
1. 语法
指针：指针是一个变量，它保存的是另一个变量/对象的地址。声明指针时需要使用
*来指明它是指向某种类型的指针。int a = 10; int *ptr = &a; // ptr 是一个指向 int 类型的指针，保存了 a 的地址引用：引用是一个变量的别名，它直接引用某个已有的对象。引用的本质是变量的别名。
int a = 10; int &ref = a; // ref 是 a 的引用，直接引用 a2. 初始化
指针：指针可以在声明时不初始化，后续可以指向不同的对象或
nullptr。int *ptr = nullptr; // 指针可以初始化为 nullptr ptr = &a; // 之后可以指向其他变量引用：引用必须在声明时初始化，并且一旦引用某个对象后，无法再改变引用的对象。
int a = 10; int &ref = a; // 必须在声明时初始化，ref 永远引用 a3. 是否可以重新绑定
指针：指针可以重新绑定到不同的地址。指针可以指向不同的对象。
int a = 10, b = 20; int *ptr = &a; ptr = &b; // ptr 可以重新指向 b引用：引用一旦初始化绑定到某个变量后，就不能再绑定到其他对象。
int a = 10, b = 20; int &ref = a; ref = b; // 这是修改 a 的值为 b 的值，而不是将 ref 重新绑定到 b4. 内存占用
- 指针：指针本身占用内存（通常为 4 或 8 字节，取决于系统架构），因为它需要存储地址。
- 引用：引用本身不占用额外内存，它只是对象的别名。
5. 指向空值
指针：指针可以为空，可以指向
nullptr或不指向任何有效的对象。int *ptr = nullptr; // 空指针，指向无效地址引用：引用不能为空，必须引用有效的对象。引用在创建时必须绑定到一个实际的对象。
6. 解引用
指针：指针需要通过解引用（
*）操作符来访问或修改其指向的对象。int a = 10; int *ptr = &a; *ptr = 20; // 解引用 ptr 修改 a 的值引用：引用不需要解引用，可以像使用普通变量一样直接使用。
int a = 10; int &ref = a; ref = 20; // 直接修改 a 的值7. 指针与引用在函数中的应用
- 指针：指针可以通过传递地址来修改原始对象。
void modify(int *ptr) { *ptr = 30; // 修改指针指向的值 }- 引用：引用可以通过传递引用来修改原始对象，而不需要解引用。
void modify(int &ref) { ref = 30; // 修改引用绑定的值 }8. 指针与引用的使用场景
- 指针：通常用于动态内存管理、数组处理、指向不同对象的需求等。指针更适合于处理复杂的数据结构和内存管理。
- 引用：通常用于需要传递对象的别名而不改变对象的语义（如在函数中传递参数时避免拷贝）。引用更简洁且易于理解。
总结
特点 指针（Pointer） 引用（Reference） 初始化 可以为空，后续可以重新指向其他对象 必须在声明时初始化，不能改变绑定的对象 语法 使用 *来声明指针使用 &来声明引用是否为空 可以为 nullptr或空指针不能为空，必须引用有效对象 是否可以重新绑定 可以指向不同对象 不能重新绑定到其他对象 内存占用 占用内存（通常为 4 或 8 字节） 不占用额外内存 解引用 需要使用 *来解引用直接使用，像普通变量一样操作 指针和引用各有优势，选择使用它们时应根据具体需求决定。指针适用于需要动态内存管理或处理多个对象的场景，而引用适用于简化代码和提高效率。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
