C++编程：引用、指针、内存管理和函数特性-优快云博客

本文链接：https://blog.youkuaiyun.com/Hacker_ccc/article/details/124537214

引用

类型名 & 引用名 = 某变量名

int n=4;
int &r=n;
//r引用了n，r的类型是 int &

引用效果：等效于引用变量名的别名，它们是一回事

修改等都是同步的

注意：

定义引用时，一定要将其初始化成引用某个变量
初始化后，不能再引用别的变量，只能一直引用初始化变量
引用只能引用变量，不能引用常量和表达式

引用作为函数的返回值

int n=4;
int & SetValue(){ return n;}
//返回类型是 int & ，然后变量是n
int main()
{
    SetValue()=40;
    //=> int &n=40;
    cout<<n;//=> 40
    return 0;
}

常引用

前面加const关键字，即为“常引用”

int n;
const int &r=n;
r的类型是const int & r;

特点
不能通过常引用去修改其引用的内容
int n=100;
const int & r=n;
r=200;//编译出错
n=300;//No probelm

常引用和非常引用的转换

const T &和T &是不同的类型！！！
T & 类型的引用或T类型的变量可以用来初始化const T & 类型的引用
const T 类型的引用和const T & 类型的引用则不能用来初始化T &类型的引用

const关键字的用法

定义常量

const int MAX_VAL=23;

定义常量指针

特点：不可通过常量指针修改其指向的内容

const int *p

形式: const T *

不能把常量指针赋值给非常量指针，反过来可以
const int *p1;int *p2;
p1=p2;//ok
p2=p1;//error
p2=(int *)p1;//强制类型转换

作用：

函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方的内容

定义常引用

定义指针常量

特点：

指针常量一旦指向某个变量，就不能指向其他变量
int* const p

动态内存分配

new运算符实现动态内存分配

第一种用法：

形式：P = new T；
T是任意类型名，p是类型为T *的指针
动态分配出一片大小为sizeof(T)字节的内存空间，并且将该内存空间的起始地址赋值给P
int *pn;
pn=new int;
*pn=5;
第二种用法：分配一个数组

形式：P = new T[N]
T：任意类型名
P：类型为T * 的指针
N：要分配的数组元素的个数，可以是整型表达式
int *pn;
int i=5;
pn=new int[i*20];(5*100)的int空间

用delete运算符释放动态分配的内存

int *p=new int;
*p=5;
delete p;
delete p;
//异常，一片空间不能被delete多次

int *p=new int[20];
p[0]=1;
delete []p;

内联函数

函数调用有时间开销

为了减少函数调用的开销，引入内联函数的机制。编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用语句处，而不会产生调用函数的语句。
形式：在函数定义前面加inline关键字
inline int Max(int a,int b)
{
    if(a>b) return a;
    return b;
}
坏处：是可执行文件体积变大

函数重载

一个或多个函数，名字相同，然而参数个数或参数类型不相同，这就叫做函数的重载。
一下三个函数是重载关系：
int Max(double f1,double f2){ }
int Max(int n1,int n2){ }
int Max(int n1,int n2,int n3){ }
作用：

函数重载使得函数命名变得简单
编译器根据调用语句中的实参的个数和类型判断应该调用哪个重载版本
重载函数一定是参数表不一样的

函数的缺省参数

定义函数的时候可以让最右边的连续若干个参数有缺省值；那么调用函数的时候，若相应位置不写参数，参数就是缺省值。
void func(int x1,int x2=2,int x3=3) { }
  
func(10);//等效于func(10,2,3)
func(10,8);//等效于func(10,8,3)
func(10,,8);//不行，只能最右边的连续若干个参数缺省