函数返回类型和形参

函数返回类型

1、int *add—–return &c;
2、int add——return c;
3、局部变量不允许以引用（或者指针）形式返回，函数结束，局部变量生存期就到了

int &add(int a,int b)
{
    int c=a+b; 
    return c;//=>return &c
}
void main()
{
    int x=10,y=20;
    int z=add(x,y);//z以值的形式接收数据，对地址不感兴趣，add返回c的值
    int *p=&add(x,y);//&返回c的地址，把c的地址给p
    int &a=add(x,y);//  以引用返回，以引用接收
    printf("%d %d %d\n",z,*p,a);
}

什么情况下可以以引用返回？

1、返回值定义在全局

int c=0;

int & add(int a,int b)
{
    c=a+b;
    return c;
}
void main()
{
}

2,静态量

int c=0;

int & add(int a,int b)
{
    static int x;
    x=a+b;
    return x;
}
void main()
{
}

静态数据成员只初始化一次，以后不会在调用，可见性在函数内，生存期在全局

void fun (int x)
{
    static int a=10;//常量初始化
    static int b=x;//变量初始化
    printf("%d \n",b);
}

void mian ()
{

    int num=100;
    fun(num);     //==>100
    fun(num+100); //==>100
}

3.以引用接收，以引用返回

int & fun （int &a）
{
    a=100;
    return a;//a的生存期不受函数影响，a是x的别名，函数结束时x依旧存在，所以也可以返回&a
}
void main()
{
    int x=0;
    fun(x);
    printf("%d\n",x);//==>100
}

函数形参

void fun1(int a);//传值
{}
void fun2(int &a);//引用=>fun2(int * const a)
{}
void main()
{
    int x=10;
    fun1(x);//x传值给a，a的改变不会影响x
    fun2(x); //a的改变会影响x
}

==>
fun1(10);//编译通过
fun2(10); //编译不通过,不能把字面常量给指针，要给地址

字面常量
1. int a=10;整型字面常量
char x=’a’;整型字面常量
2. a=010;八进制字面常量
3. a=0x10;十六进制字面常量
4.float ft=12.33f;单精度浮点型字面常量
=12.23 双精度。。。
5.char *p=”qweq”字符串字面常量

char ch[]={“qwe”};//数组，非字面常量
char ch2[]=”qwe”;//数组，非字面常量

引用

1、常变量能力扩大—不行

void main ()
{
    const int a=10;//常变量
    int b=a;//编译通过
    int &c=a;//编译不通过，若编译通过，则通过c可以改变a的值，但const int a为常变量值不可改变
    const int &c=a;//通过             
}

2、变量能力缩小—可以

void main()
{
    int a=10;
    int &b=a;//编译通过
    const int &c=a;//常引用不能改变a,a的能力缩小，可以编译通过
}

3、
编译器不同，结果不同

void main ()
{
    const int a=10;//常变量，a只能读值，不能写
    const int &b=10;//在逻辑上，编译器可以通过编译，b为常引用，不会改变10
//编译器工作：定义一个临时变量tmp，把字面常量给临时量（把10给tmp）,const int &b=tmp;(引用临时量)
    const int &c=a;
//引用字面常量：在a为字面常量的前提下，编译器进行int tmp =a;const int &b=tmp(引用临时量)
    const int &x=c;
}

why要用临时量作为过渡？
由于c++极其不安全（指针本身不安全），若把b的常性去掉，没有中间临时变量tmp，那b就可以直接改变a,而产生临时变量，即使改变b的常性，也不会对直接a造成影响

void fun3(int *a);//指针
区别于
viod fun2(int *const a)
void fun2(int &a)引用
传指针，自身可以改变，指向也可以改变
传引用，自身不能改变，指向不能改变

void fun4(int ar[]);//数组做形参，退化为指针
{
if(ar==NULL)return ;
}

int add(int a,int b)
{
    int c=a+b;
    return c;  //mov eax,dword ptr[c]
}

void main()
{
    int x=10,y=20;
    int z=0;
    z=add(x.y);//mov dword ptr[z],eax
    printf("%d\n",z);
}

函数调用时，局部变量产生，当函数结束时局部变量销毁

把c给z，要建立临时变量（eax），不可存到内存中(若存到内存中，则需要内存地址，要找到存放的地址，则需要找到地址存放的地址，无穷无尽根本找不完)

int * add(int a,int b)
{
    int c=a+b;
    return &c;  //编译通过
}
void main()
{
    int x=10,y=20;
    int z=0;
    z=*add(x.y);//*和函数返回值结合
//(理论上：函数名和括号结合，调动函数，返回c的地址，在临时空间里放c的地址，*
//和&c结合=>*&c=z，但是c的生存期在局部，函数调动结束时释放c,则c的地址查找不到
//所以输出随机值。
    printf("%d\n",z);
}
//==>输出随机值

void fun5(int (&br)[10]);//引用数组，对br不改变

//void fun1(int br[])
void fun1(int *s);
void fun2(int (*p)[10]);
void main()
{
    int ar[]={12,23,34,45,56,67,78,89,90,100};
    const int n=sizeof(ar)/sizeof(ar[10]);
    fun1(ar);
    fun2(&ar);
}