【C++干货基地】C++引用与指针的区别：深入理解两者特性及选择正确应用场景

 🔥 个人专栏: 《C++干货基地》《粉丝福利》 ⛺️生活的理想，就是为了理想的生活!

引入

  哈喽各位铁汁们好啊，我是博主鸽芷咕《C++干货基地》是由我的襄阳家乡零食基地有感而发，不知道各位的城市有没有这种实惠又全面的零食基地呢？C++ 本身作为一门篇底层的一种语言，世面的免费课程大多都没有教明白。所以本篇专栏的内容全是干货让大家从底层了解C++，把更多的知识由抽象到简单通俗易懂。

⛳️ 推荐

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

文章目录

• 引入
• ⛳️ 推荐
• 一、引用的概念
• • 1.1 引用的语法
  • 二、引用的特性
  • • 2.1 引用必须初始化
    • 2.2 引用不能更改指向
    • 2.3 一个变量可以有多个指向
    • 三、常引用
    • • 3.1 权限的放大与缩小
      • 3.2 临时变量具有常性
      • 四、引用的使用场景
      • • • 做参数
          • 做返回值
          • 4.2 传值和传引用的效率对比
          • 五、引用和指针的区别
          • • 5.1 引用与指针的大小
            • 5.2 引用和指针的底层对比
            • 总结
            • 📝文章结语：

              一、引用的概念

              引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空

              间，它和它引用的变量共用同一块内存空间。

              比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。

              

              所以，铁牛 和 黑旋风，都是 李逵

              • 这俩就相当于李逵的别名

                引用的概念其实有点相当于指针的平替，以往我们在使用指针等要 取地址 解引用 太麻烦了，所以C++祖师爷在开发C++的时候就有了引用的概念，下面就来看看引用到底是个什么东西吧！

                1.1 引用的语法

                • 类型& 引用变量名(对象名) = 引用实体；

                  以上就是引用的语法了下面我们就来看一下实际是如何使用的

                  🍸 代码演示：

                  #define _CRT_SECURE_NO_WARNINGS 1
                  #include
                  using namespace std;
                  int main()
                  {
                  	int a = 10;
                  	//给a取别名
                  	int& b = a;
                  	b = 20;
                  	cout 
                  	*x = 20;
                  }
                  void fun1(int& y)
                  {
                  	y = 30;
                  }
                  int main()
                  {
                  	int a = 10;
                  	//使用指针做形参
                  	fun(&a);
                  	cout 
                  	int a = 10;
                  	int& b = a;
                  	int& c;
                  	return 0;
                  }
                  
                  	int a = 10;
                  	int x = 30;
                  	int& b = a;
                  	cout 
                  	int a = 10;
                  	int& b = a;
                  	b = 20;
                  	cout 
                  	x = 30;
                  }
                  int main()
                  {
                  	int a = 10;
                  	fun(a);
                  	return 0;
                  }
                  
                  	int a = 10;
                  	//权限的缩小
                  	const int& b = a;
                  	b = 30;
                  	return 0;
                  }
                  
                  	const int a = 8;
                  	//权限的平移
                  	const int& c = a;
                  	const int& b = 10;
                  	return 0;
                  }
                  
                  	int a = 10;
                  	double b = a;
                  	const int& x = b;
                  	return 0;
                  }      
                  
                  	int a = 97;
                  	char b = 'a';
                  	if (a == b)
                  	{
                  		cout 
                  	int a = 10;
                  	int b = 20;
                  	//权限的放大，a+b的结果是一个临时变量。临时变量具有常性
                  	//int& b = a + b;
                  	const int& b = a + b;
                  	return 0;
                  }      
                  
                  	int tmp = x;
                  	x = y;
                  	y = tmp;
                  }
                  int main()
                  {
                  	int a = 10;
                  	int b = 20;
                  	swap(a, b);
                  	cout 
                  	int a = 10;
                  	return a;
                  }
                  int& fx()
                  {
                  	int b = 20;
                  	return b;
                  }
                  int main()
                  {
                  	int& a = fun();
                  	cout 
                  	int* a;
                  	int size;
                  	int capacity;
                  	//成员函数
                  	void Init(SeqList& sl)
                  	{
                  		int* tmp = (int*)malloc(sizeof(int) * 4);
                  		if (tmp == NULL)
                  		{
                  			perror("malloc file");
                  			exit(-1);
                  		}
                  		sl.a = tmp;
                  		sl.size = 0;
                  		sl.capacity = 4;
                  	}
                  	void PushBack(SeqList& sl,int x)
                  	{
                  		//...
                  		sl.a[size++] = x;
                  	}
                  	int& Get(SeqList& sl, int pos)
                  	{
                  		return sl.a[pos];
                  	}
                  };
                  int main()
                  {
                  	SeqList s;
                  	s.Init(s);
                  	s.PushBack(s, 1);
                  	s.PushBack(s, 2);
                  	s.PushBack(s, 3);
                  	s.PushBack(s, 4);
                  	for (int i = 0; i