C/C++ - Auto & Reference

目录

auto

Reference

---

auto

• 当使用auto​​关键字声明变量时，C++编译器会根据变量的初始化表达式推断出变量的类型。

  1. 自动类型推断：auto​​关键字用于自动推断变量的类型，使得变量的类型可以根据初始化表达式进行推导。

  2. 初始化表达式：在使用auto​​声明变量时，必须提供初始化表达式，以便编译器能够推断变量的类型。

  3. 推断规则：编译器根据初始化表达式的类型来推断变量的类型。推断的结果可以是基本类型、自定义类型、指针类型等。

  4. 类型一致性：编译器会确保自动推断的类型与初始化表达式的类型一致，以保证类型安全。

  5. 引用类型推断：当使用auto​​声明引用变量时，编译器会推断出引用的类型，并创建对应的引用。

     #include 
     
     int main()
     {
     	//类型推断
     	auto a = 1;					//int
     	auto b = 'A';				//char
     	auto c = 3.14f;				//float
     	auto d = "Hello World";		//const char*
     	auto e = &a;                //int*
     
     	//编译正确
     	int f = 3.14;
     
     	//编译错误
     	//int g{3.14};
     
     	//类型回溯
     	const std::type_info& TypeName = typeid(e);
     	std::cout << TypeName.name() << std::endl;
     
     
     	return 0;
     }
     

Reference

• 引用的基本概念

  • 引用是一个已存在变量的别名，通过使用 &​​​ 符号进行声明。

  • 引用语法格式 -> 类型 & 引用变量名 ( 对象名 ) = 引用实体；​​

    int& ref = a;
    

  • 引用在定义时必须初始化

    int a = 0;
    //数据类型& 变量名 = 初始值;
    //引用必须赋值
    int& ref = a;
    

  • 引用必须在声明时进行初始化，并且一旦初始化后，它将一直引用相同的对象。

    #include 
    
    int main()
    {
    	//局部变量
    	int a = 2;
    	int b = 5;
    
    	//引用变量ref1指向变量a
    	int& ref1 = a;
    
    	//success -> 修改ref1[a] = b
    	//failed  -> 修改int& ref1 = b;
    	//引用一旦赋值无法重新引用其他变量
    	ref1 = b;
    
    	return 0;
    }
    

  • 一个变量可以有多个引用

    int a = 0;
    //一个变量可以有多个引用
    int& ref1 = a;
    int& ref2 = a;
    

  • 引用权限(权限只能变小不能扩大)

• 引用作为函数参数

  • 引用参数使用 & 符号进行声明，表示该参数是一个引用。

    void Fun(int& ref/*引用参数*/)
    {
    
    	return;
    }
    

  • 引用参数在函数内部直接操作原始变量，而不会创建副本。

    #include 
    
    //创建副本 -> 将参数的值PUSH进STACK
    void Fun2(int a)
    {
    
    }
    
    //地址传递 -> 指针
    void Fun3(int* p)
    {
    
    }
    
    //地址传递 -> 引用
    void Fun4(int& ref)
    {
    
    }
    
    int main()
    {
    	int Num = 0;
    	Fun2(Num);	//int a = Num;
    	Fun3(&Num);	//int* p = &Num;
    	Fun4(Num);  //int& ref = Num;
    
    	return 0;
    }
    
    //Fun2
    mov         eax,dword ptr [Num] 
    push        eax							//创建副本                 
    call        Fun2 (04113B1h)  
    add         esp,4  
    
    //Fun3
    lea         eax,[Num]  
    push        eax  						//地址传递
    call        Fun3 (04113A7h)  
    add         esp,4  
    
    //Fun4
    lea         eax,[Num]  
    push        eax 						//地址传递 
    call        Fun4 (04113B6h)  
    add         esp,4  
    
    
    
    

  • 

  • 引用参数可以在函数内部修改原始变量的值。

    #include 
    
    //地址传递 -> 引用
    void Fun4(int& ref)
    {
    	//[ref] -> main->Num.Addr
    	ref = 2;
    }
    
    int main()
    {
    	int Num = 0;
    	Fun4(Num);  //int& ref = Num;
    
    	return 0;
    }
    

  • 通过引用传递参数可以实现函数的返回多个值的效果。

    #include 
    
    bool cc_OpenFile(const char* szFileName, int& nFileSize)
    {
    	//TODO
    	bool bret = true;
    	if (bret)
    	{
    		nFileSize = 123;
    	}
    
    	return bret;
    }
    
    int main()
    {
    	int FileSize = 0;
    	bool bret = cc_OpenFile("D:\\1.txt", FileSize);
    
    	return 0;
    }
    

• 引用作为函数返回值

  • 函数的返回类型可以是引用类型，使用 & 符号进行声明。

    //返回值类型为引用
    int& Fun()
    {
    
    }
    

  • 不应该返回指向局部变量的引用，因为在函数执行完毕后，局部变量会被销毁，引用将变得无效。

    #include 
    
    //返回值类型为引用
    int& Fun()
    {
    	//Fun -> STACK -> [EBP - 8]
    	int a = 1;
    
    	//不要返回局部变量的指针 & 引用
    	//lea         eax,[a]
    	return a;
    }
    
    int main()
    {
    	int& ref = Fun();
    	printf("%d \r\n", ref);
    	printf("%d \r\n", ref);
    	printf("%d \r\n", ref);
    
    	return 0;
    }
    

  • 返回指向静态变量或全局变量的引用也是不推荐的，因为这样做可能导致函数不可重入和线程安全性问题。

    //创建线程
    CreateThread;
    
    //多线程执行下函数时,可能
    void Fun(lpvoid lp)
    {
    	g_Num++;
    }
    

  • 返回引用可以避免对象的拷贝，提高效率，并允许对返回值进行修改。

• 常量引用

  • 常量引用声明与初始化

    • 常量引用使用 const​​​ 关键字进行声明。

    • 常量引用必须在声明时被初始化，并且一旦初始化后，就不能再引用其他对象。

    • 常量引用可以绑定到常量、非常量和临时对象。

    • 常量引用提供了一种只读访问对象的方式，不能通过常量引用修改所引用的对象。

      #include 
      
      int main()
      {
      	int a;
      	const int b = 1;
      
      	const int& ref1 = a;	//绑定非常量
      	const int& ref2 = b;	//绑定常量
      	const int& ref3 = 10;	//临时对象
      
      	//引用对象之后无法修改其指向对象
      	//常量引用无法修改其指向对象的值
      	std::cout << ref2 << std::endl;
      
      	return 0;
      }
      

  • 常量引用与非常量引用的区别

    • 常量引用只能用于读取对象的值，而非常量引用可以用于修改对象的值。

    • 常量引用可以绑定到常量对象，而非常量引用不能绑定到常量对象。

    • 常量引用可以接受临时对象作为参数，而非常量引用不能直接接受临时对象作为参数。

      #include 
      
      int main()
      {
      	int a = 0;
      	const int b = 0;
      
      	//引用与常量引用一旦绑定对象后均无法修改其指向
      	int& ref1 = a;
      	const int& ref2 = b;
      
      	//普通引用可以修改其指向对象的值
      	//int* const p = &a; 
      	ref1 = 2; //a = 2;
      
      	//常量引用不可修改其指向对象的值
      	//const int* const p = &a;
      	//b = 2;
      
      	return 0;
      }
      

  • 常量引用与函数参数

    • 将函数参数声明为常量引用可以防止在函数内部意外修改参数的值。

    • 如果函数不需要修改参数的值，将其声明为常量引用可以提高代码的清晰度和可读性，并帮助避免潜在的错误。

      #include 
      
      void Fun(const int& ref)
      {
      	std::cout << ref << std::endl;
      }
      
      
      int main()
      {
      	int nVer = 2;
      	Fun(nVer);
      
      	return 0;
      }
      

• 数组引用

  #include 
  
  int main()
  {
  	int Arr[5] = { 0 };
  
  	//数组引用
  	int (&ref1)[5] = Arr;
  
  	//定义类型
  	typedef int(ARR_TYPE)[5];
  	ARR_TYPE& ref2 = Arr;
  
  	//定义类型
  	typedef int(&ARR_REF)[5];
  	ARR_REF ref3 = Arr;
  
  	return 0;
  }
  

  • 在C++中，可以通过引用来操作数组，这样可以方便地传递和修改数组，而无需进行数组的复制。数组引用在函数参数传递和函数返回值等场景中非常有用。
  • 数组引用是对数组的别名，使用引用可以直接操作数组元素。
  • 语法：类型 (&引用名)[数组大小] = 数组;​​