(创建于2017/12/21)

1.引用是变量的别名

#include "iostream"  //包含c++的头文件
using namespace std;
int main() {
    int a = 10;
    int &b = a;
    b = 20;  //b是a的别名，修改b的值就等于修改了a
    cout << "a="<<a<< endl;
    cout << "b=" << b<< endl;
    system("pause");
    return 0;
}

打印
a=20
b=20
请按任意键继续. . .

2.指针和引用的比较

#include "iostream"  //包含c++的头文件
using namespace std;

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}
int main() {
    int a = 10;
    int b = 20;

    //通过指针交换两个变量的值
    swap(&a, &b);
    cout << "a="<<a<< endl;
    cout << "b=" << b<< endl;

    //通过引用交换两个变量的值
    swap(a, b);
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    system("pause");
    return 0;
}

3.复杂数据类型的引用

#include "iostream"  //包含c++的头文件
using namespace std;
struct Boss {
    int age;
};
void print1(Boss *b1) {
    b1->age = 10;
}
void print2(Boss &b2) {
    b2.age = 20;
}

void print3(Boss b3) {
    b3.age = 30;
}
int main() {
    Boss boss;
    boss.age = 100;
    //通过指针修改变量的值
    print1(&boss); //b1是指向boss的指针
    cout << "boss.age="<< boss.age<< endl;

    //通过引用修改变量的值
    print2(boss); //b2是boss的别名
    cout << "boss.age=" << boss.age << endl;

    //这种方式无法修改变量的值
    print3(boss); //b3是形参，将boss拷贝一份给了b3，但是修改b3跟boss没有关系
    cout << "boss.age=" << boss.age << endl;
    system("pause");
    return 0;
}

4.引用的本质

1.引用在c++内部的实现是一个常指针
Type& name <<-->> Type *const name
2.c++编译器在编译过程中使用常指针作为引用的内部实现，所以引用所占内存空间于
指针相同
3.从使用角度，引用会让人误以为其只是一个别名，没有自己的存储空间，这时c++为了实用性而做的细节隐藏。也就是说底层实现和指针是相同的，只不过这一步由编译器替我们做了

5.引用做函数返回值

#include "iostream"  //包含c++的头文件
using namespace std;

int& getA() {
    int a;
    a = 30;
    return a;
}
int main() {
    int a;
    
    //使用一个int变量接收一个int型的引用，得到的是这个引用的值
    a = getA();

    //使用int型引用接收int型引用，得到的是这个引用的地址
    int &b= getA();
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    system("pause");
    return 0;
}

6.返回函数本身

#include "iostream"  //包含c++的头文件
using namespace std;

int& getA() {
    int a;
    a = 30;
    return a;
}

int getB() {
    int a;
    a = 20;
    return a;
}
int main() {
    //返回的是一个数字 20， 20 = 200是编译不过的
    //getB() = 200;
    //返回的是引用，也就是a本身，相当于给a重新赋值
    getA() = 100;
    cout << "a=" << getA << endl;
    system("pause");
    return 0;
}

注意这些代码无法直接运行，需要调试

#include <stdlib.h>
#include<iostream>

//引用就是某一变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。其格式为：类型 &引用变量名 = 已定义过的变量名

//注意这里define后边不加分号，否则使用PI的那行代码（return PI  * r * r;）会提示 --*的操作必须是指针--
//#define PRICE 30;的意思是把你下面代码中的PRICE全部替换成30;
//你错误我估计有两原因 第一你的分号是中文分号第二你下面的代码类似于
//I = PRICE * 5; 之类的 应为这样宏替换之后就成了 I = 30; *5; 
#define PI 3.14

using namespace std;

//类
class MyCircle {
    //属性（共用权限访问修饰符）
private:
    double r;
    double s;
public:
    void setR(double r) {
        this->r = r;
    }
    //获取面积
    double getS() {
        return PI * r * r;
    }
};

//结构体
struct MyTeacher{
    public:
    char name[20];
    int age;
    public:
    void say(){
        cout << this->age << "岁" << endl;
    }
};
void main(){
MyTeacher t1;
t1.age = 10;
t1.say();
system("pause");
}
//指针值交换
void swap_1(int *a, int *b) {
    int c = 0;
    c = *a;
    *a = *b;
    *b = c;
}

//引用值交换
//为在程序中调用该函数，则相应的主调函数的调用点处，直接以变量作为实参进行调用即可，而不需要实参变量有任何的特殊要求
void swap_2(int &a, int &b) {
    int c = 0;
    c = a;
    a = b;
    b = c;
}


void main() {

    //-------------类（可以继承）---------------
    MyCircle c1;
    c1.setR(4);
    cout << "圆的面积：" << c1.getS() << endl;

    //-------------结构体（不可以继承）---------------
    MyTeacher t1;
    t1.age = 10;
    t1.say();

    //-------------Boolean类型---------------
    //bool isSingle = true;
    //大于0的数都代表正确
    bool isSingle = 17;
    //false -17
    
    if (isSingle) {
        cout << "单身" << endl;
        cout << sizeof(bool) << endl;//1个字节
    }
    else {
        cout << "有对象" << endl;
    }

    int a = 10, b = 20;
    ((a > b) ? a : b) = 30;
    cout << b << endl;

    //-------------引用类型---------------
    //变量名-门牌号(内存空间0x00001的别名，可不可以有多个名字？)
    int a = 10;
    //b就这个内存空间另外一个别名\
    //& C++中的引用
    int &b = a;
    cout << b << endl;


    //-------------指针和引用实现值的交换---------------
    int x = 10;
    int y = 20;

    printf("%d,%d\n", x, y);
    //指针交换
    //swap_1(&x, &y);

    //a成了x的别名
    //引用交换
    swap_2(x, y);
    printf("%d,%d\n", x, y);

    system("pause");
}

1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给 形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效 率和所占空间都好。

3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用"*指针变量名"的 形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。

7.常引用的初始化

#include "iostream"  //包含c++的头文件
using namespace std;

int main() {
    int a = 10;
    const int &b = a;
    //常引用 让变量b拥有只读属性，不能通过b去修改a
    //b = 39;

    //常引用两种初始化方式
    {
        int a1 = 30;
        //用a1变量去初始化常引用
        const int a2 = a1;
    }

    {
        const int a = 40;

        //普通引用无法直接通过字面量初始化，
        //引用是内存空间的别名，一个数字是没有内存空间的
        //int &m = 32; 

        //常引用可以直接赋值，c++编译器会给32分配空间，然后
        //创建一个m指针指向这个空间
        const int &m = 32;
    }
    system("pause");
    return 0;
}

8.内联函数和宏

1.c++编译器可以将一个函数进行内联编译，这个函数叫内联函数，内联函数在最终生成的代码中是没有定义的，c++编译器直接将内联函数插入到函数调用的地方，内联函数没有普通函数调用时的额外开销（压栈 跳转 返回）
2.c++编译器不一定准许函数的内联请求。内联函数是对编译器的一种请求，因此编译器可能拒绝，内联函数由编译器处理，直接将编译后的函数插入到掉用的地方，宏代码片段由由预处理器处理，进行简单的文本替换，没有任何编译的过程
3.现代c++编译器可以进行编译优化，因此一些函数即使没有inline声明，也可能被编译器进行内联编译

内联编译的限制：
不能存在任何形式的循环语句
不能存在过多的判断语句
函数体不能过于庞大
不能对函数进行取址操作
内联函数声明必须在调用之前

#include "iostream"  //包含c++的头文件
using namespace std;

#define FUN(a,b) ((a<b?a:b))

inline int myFun(int a, int b) {
    return a < b ? a : b;
}
int main() {
    int a = 1;
    int b = 3;
    //int c = FUN(a, b);
    int c = myFun(a, b);
    printf("c =%d",c);
    system("pause");
    return 0;
}

9.默认参数

c++在函数声明时可以为参数提供一个默认值，默认值在函数调用时可指定可不指定，如果不指定，编译器会自动使用默认值替代。默认参数必须在形参列表的末尾定义，否则无法编译通过，见注释掉的fun3

#include "iostream"  //包含c++的头文件
using namespace std;

void fun1(int a = 2) {
    cout << "a="<<a<< endl;
}

void fun2(int a = 2, int b = 3) {
    cout << "a=" << a <<" b="<<b<< endl;
}

//void fun3(int a = 2, int b = 3,int c) {
//  cout << "a=" << a << " b=" << b << endl;
//}

void fun3(int a, int b = 2, int c = 3) {
    cout << "a=" << a << " b=" << b <<" c"<<c<< endl;
}
int main() {
    
    fun1();
    fun2();
    fun3(12);
    system("pause");
    return 0;
}

10，占位参数

占位参数只有参数类型声明，没有参数名声明，一般情况下，在函数体内部无法使用占位参数，那么要它有何用？注意，虽然如此，调用时也必须指定实参，否则无法编译通过。占位参数不像默认参数，在形参列表中，在前在后定义都可以

#include "iostream"  //包含c++的头文件
using namespace std;

void fun1(int a,int) {
    cout << "a="<<a<< endl;
}
void fun2(int, int,int a) {
    cout << "a=" << a << endl;
}
int main() {
    
    fun2(1,2,3);
    fun1(1, 2);
    system("pause");
    return 0;
}

11.默认参数和占位参数结合

将二者结合起来使用，用于后期程序的扩展和对c代码的兼容，你会发现下边的两种调用方式都可以通过了

#include "iostream"  //包含c++的头文件
using namespace std;

//第三个参数，默认参数和占位参数结合
void fun1(int a, int b, int = 3) {
    cout << "a="<<a<< endl;
}

int main() {
    fun1(1, 2, 3);
    fun1(1, 2);
    system("pause");
    return 0;
}