0822|C++day2 引用+函数重载

一、左值引用(reference)

如果想要实现两个数据的交换，值传递不能交换实参，地址传递可以交换实参，会额外开辟空间

【1】概念

• 引用其实就是给变量起了一个别名，孙悟空(齐天大圣)
• C++对C的一个最重要的扩充

【2】定义

数据类型  &引用名=目标名;

引用的注意事项：
1、引用必须初始化
2、引用不能引用空
3、一个目标可以有多个引用用
4、引用还能作为其他引用的目标

&的用法：

1. 取地址
2. 按位与
3. &&逻辑与
4. &前面有数据类型表示定义引用

区分&的含义：

1. 如果&前面有数据类型，说明表示定义引用
2. 如果&前面没有数据类型，且为一个单目运算，就表示取变量的地址

#include 
using namespace std;

int main()
{
    int a = 100;
    int &ra = a;    //定义了变量a的引用ra
    cout << &a << endl;
    cout << "&ra=" << &ra << endl;
    int &rb = a;
    int &rra = ra;
    cout <<  &rra << endl;
    cout <<  &rb << endl;
    return 0;
}

思考：引用可不可以更改目标？不能更改目标

【3】引用基本使用

1. 引用必须有目标
2. 引用的目标一旦指定，不能更改
3. 修改引用的值，实际上就是在修改目标的值
4. 一个目标可以有多个引用

【4】引用作为函数的形参

       由于引用和目标占用同一块空间，在作为参数传递时，不会开辟新的空间，并且传引用实际上就是传变量的空间，所以也没有值传递和地址传递的区别。

#include 
using namespace std;

void swap(int &n1,int &n2)
//引用作为函数的形参，传递实参本身到函数中
{
    int temp;
    temp = n1;
    n1 = n2;
    n2 = temp;
}
int main()
{
    int a=90,b=80;
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
//    int &p = a;
//    int &q = b;
    swap(a,b);  //调用结束后，实参会发生交换
    cout << "调用后" << endl;
    cout << "a=" << a << endl;
    cout << "b=" << b << endl;
    return 0;
}

练习：尝试实现，冒泡排序，要求：引用作为函数的形参。

#include 

using namespace std;
void fun(int (&s)[5])
{
    int i=1,j=0,temp;
    for(i=1;i<5;i++)
    {
        for (j=0;j<5-i;j++)
        {
            if(s[j]>s[j+1])
            {
                temp = s[j];
                s[j] = s[j+1];
                s[j+1] = temp;
            }
        }
    }
}
int main()
{
    int arr[5]={2,9,7,1,6};
    int a;
    int &ra = a;
    int (&pa)[5] = arr;
    cout << sizeof(arr) << endl;
    cout << sizeof(pa) << endl;
    return 0;
}

【5】引用作为函数的返回值

① 引用作为函数的返回值，结果是一个左值，所以引用作为函数的返回值可以被赋值。

② 引用作为函数的返回值，可以返回的内容：

1. 全局变量的引用
2. 静态局部变量的引用
3. 堆区申请的空间
4. 实参传递过来的引用

③ 其实就是返回，生命周期长的变量的引用。

#include 
using namespace std;

//函数的返回值和形参皆为引用
int &fun(int &a,int &b)
{
    a = a+b;
    return a;
}
int fun1(int a,int b)
{
    a = a+b;
    return a;
}
int main()
{
    int nu1 = 100,nu2=7;
    fun(nu1,nu2)=90;   //<===>nu1=90
    cout << "nu1=" << nu1 << endl;
    cout << "nu2=" << nu2 << endl;
    //cout << ret << endl;
    return 0;
}

5.1 左值是什么？

=：赋值运算符

左值 = 右值；

左值：既可以作为左值也可以作为右值

右值：只能作为右值

• int a = 8;
• 8 = 9; ----->错误的，
• int b = a; ----->左值可以作为右值
• b = 5+4; //5+4的结果是一个临时值

常见的右值：const修饰的，常量，临时值(计算的结果、函数的基本数据类型的返回)

常见的左值：变量，可以取地址，

【6】常引用(const)

常引用就是为了保护目标，不能通过引用被修改

1. 常引用可以引用常变量，也可以引用非常变量
2. 不能通过引用去修改目标的值，仍然可以通过目标本身修改
3. 常用于函数传参，如果形参是一个常引用，在函数内部不能通过常引用修改原来的目标

#include 
using namespace std;

int main()
{
    int num1 = 90;
    const int &ra = num1;  //定义了一个常引用ra，目标是非常变量num1
    num1 = 8;
    //ra = 70;
    const int num2 = 0;
    const int &rb = num2;  //定义了一个常引用rb，目标是常变量num2
    //既不能通过引用修改num2，也不能通过目标num2修改自身的值    
    return 0;
}

【7】结构体中的引用成员

由于引用必须初始化，所以结构体中如果有引用成员，需要先初始化。

#include 
using namespace std;

struct Stu
{
    string name;
    int &age;
};

int main()
{
    int x = 18;

    //定义一个结构体变量s1，由于Stu中有引用成员，所以结构体变量必须初始化
    struct Stu s1={"zhangsan",x};

    cout << s1.name << endl;
    cout << s1.age << endl;
    return 0;
}

【8】引用和指针的区别(笔试题)

1. 引用必须初始化，指针可以不初始化(野指针)，指针可以指向NULL，引用不能为空，引用一定有明确的目标
2. 指针可以修改指向，引用一旦指定目标，不能再修改
3. 指针在使用前，需要做合理性检查，但是引用不需要
4. 指针会另外开辟空间，但是引用不开辟空间，和目标使用同一片空间
5. 指针的大小是8byte/4Byte，引用的大小和目标的大小一致
6. 有多级指针，没有多级引用
7. 有指针数组，但是没有引用数组

二、C++中的动态内存分配

• new/delete属于C++中的关键字
• malloc/free是C中的库函数

【1】new

i）使用new申请单个内存空间

数据类型 *指针名 =  new  数据类型;
new的结果，就是一个对应数据类型的指针，不需要强转

#include 
#include 
using namespace std;

int main()
{
    int a = 100;
    int *p = (int *)malloc(sizeof(int));   //使用malloc申请了堆区的4Byte的空间
    cout << *p << endl;   //随机值


//------------------使用new申请空间-----------------
    int *p1 = new int;    //使用new申请了堆区的一个int大小的空间
    cout << p1 << endl;
    *p1 = 90;
    cout << *p1 << endl;


    int *p2 = new int(45);  //使用new在堆区申请了一个int类型的控制，并赋初始值为45
    cout << *p2 << endl;
    return 0;
}

ii）使用new申请连续的内存空间

1、只申请空间，不进行初始化操作
数据类型 *指针名 = new 数据类型[个数]
2、申请空间，并初始化
数据类型 *指针名 = new 数据类型[个数]{初始值}


#include 
using namespace std;

int main()
{
    //使用new申请连续的空间
    int *p = new int[5];      //在堆区申请了5个int的空间

    cout << p << endl;
    cout << p+1 << endl;
    cout << p+2 << endl;
    cout << p+3 << endl;
    cout << p+4 << endl;
    for (int i=0;i<5;i++)
    {
        cout << p[i] << endl;    //随机值
    }

    //申请连续的空间并初始化
    int *p2 = new int[5]{1,2,3,4,5};
    for (int i=0;i<5;i++)
    {
        cout << p2[i] << endl;   //1,2,3,4,5
    }
    return 0;
}

【2】delete

1、delete释放单个空间
delete 指针名;    ---->delete p
2、delete释放连续空间
delete []指针名;    ---->delete []p
[]内不能写任何内容，只做引导delete释放多个空间使用

#include 
#include 
using namespace std;

int main()
{
//------------------使用new申请空间-----------------
    int *p1 = new int;    //使用new申请了堆区的一个int大小的空间
    cout << p1 << endl;
    *p1 = 90;
    cout << *p1 << endl;
    delete p1;
    p1 = nullptr;  //和NULL是一样的效果

    int *p2 = new int(45);  //使用new在堆区申请了一个int类型的控制，并赋初始值为45
    cout << *p2 << endl;
    int *p3 = new int[5]{1,2,3,4,5};
    delete []p3;    //释放连续空间时，需要加[]
    p3 = nullptr;
    return 0;
}

1）C++提供new/delete为什么不适用malloc/free

new和delete在申请和释放类对象空间是，new会自动调用构造函数，delete会自动调用析构函数，但是malloc/free不会。

【3】new/delete和malloc/free的区别(笔试题)

1. new/delete是C++中的关键字，malloc和free是C中的库函数；
2. new/delete会自动调用构造和析构函数；
3. new申请空间时以数据类型为单位，malloc以字节大小为单位；
4. new在申请空间的同时可以初始化，malloc不行；
5. free在释放空间时，不需要考虑连续空间的问题，但是delete在释放连续空间时，需要手动加 [ ]，delete [ ] 指针名。

三、C++中的函数

【1】函数重载(overload)

i）概念

• 函数重载，是实现静态多态的一种方式，能够实现“一名多用”
• 解决了，针对同一功能的函数，由于参数的不同，需要定义为不同名字的函数。

ii）函数重载的要求

1. 函数名相同
2. 形参不同(个数不同、类型不同)
3. 在同一作用域下

iii）函数重载的代码

函数重载后，文件中会存在多个同名不同参的函数，编译器会根据调用时的实参去匹配参数类型，再来决定调用哪一个函数。

g++ -S test.cpp -o test.s ----->可以通过查看汇编文件看到现象

#include 
using namespace std;
//实现函数重载

//整型变量的加法函数
int add(int num1,int num2)   //addii
{
    return num1+num2;
}

//字符型变量的加法函数
char add(char num1,char num2)   //addcc
{
    return num1+num2;
}

//浮点型变量的加法函数
float add(float num1,float num2)   //addff
{
    return num1+num2;
}
int main()
{
    int a=55,b=9;
    char num1 = 90,num2 = 7;
    float n1 = 9.0,n2 = 3.14;

    cout << add(a,b) << endl;
    cout << add(n1,n2) << endl;
    cout << add(num1,num2) << endl;
    return 0;
}

【2】函数参数的默认值

• C语言中，函数形参的值只能通过实参传递过去，
• C++中，函数的形式参数，支持默认值，如果实参传值就使用实参的值，如果实参没有传值，就使用默认值

函数传参时，参数初始化的顺序是靠左原则，所以默认参数的设置是靠右原则
如果函数的某一个形参有默认值，说明该参数右侧的所有参数都是有默认值的

使用的注意事项：

1. 默认参数需要遵循靠右原则；
2. 在没有实参传值过来时，才使用默认参数；
3. 如果函数有默认参数，默认参数只能在函数声明中出现。

#include 
using namespace std;

int add(int num1,int num2,int num3=9);
int main()
{
    int ret = add(3,5);
    cout << ret << endl;
    return 0;
}

int add(int num1,int num2,int num3)
{
    return num1+num2+num3;
}

【3】当函数重载和默认参数同时出现

如果重载的函数，和省略了默认参数后的函数的参数个数一致，

调用时会造成混乱

尽量避免，函数重载和函数的默认参数同时出现

#include 

using namespace std;
int add(int num1,int num2,int num3=9);
//int add(int num1,int num2)
//{
//    return num1+num2;
//}
int main()
{
    int ret = add(3,5);
    cout << ret << endl;
    return 0;
}

int add(int num1,int num2,int num3)
{
    return num1+num2+num3;
}

【4】哑元

       哑元指的是，在形参列表中，只有参数类型，没有实际意义的参数，调用时也需要传参数，但是函数不能获取到该参数。

哑元的使用场景：

1. 使用场景一：如果在大型的工程中，对某些功能的代码进行更新，为了保证对前面版本的兼容，设置某些参数为哑元，目的能够让前面的代码继续正常使用。
2. 使用场合二：自增自减运算符的重载(后面讲)

#include 
using namespace std;

int add(int num1,int num2,int);
int main()
{
    int ret = add(3,5,1);
    add(1,2,3);
    add(4,5,6);
    add(4,5,6);
    add(4,5,6);
    add(4,5,6);
    cout << ret << endl;
    return 0;
}

//add函数的，第三个参数是一个哑元
int add(int num1,int num2,int)
{
    return num1+num2;
}

【5】内联函数(inline)

• 内联函数指的是，在函数调用前的位置，将该函数展开
• 内联函数的优点：简化调用的过程，提高运行的效率
• 内联函数的缺点：造成主调函数内的代码膨胀(代码量过大)

内联函数的要求：

1. 在函数多次调用的时候，建议定义为内联函数
2. 函数体比较小(函数体在5行以内)

inline的作用：

• inline修饰函数，表示建议编译器，把该函数在调用前展开；
• 是否被定义为内联函数，是由编译器决定的，如果编译器认为某些函数，需要定义为内联函数，即使函数没有使用inline修饰，也会在调用前展开。

格式：
inline 函数头; 

#include 

using namespace std;
int add(int num1,int num2,int);
int main()
{
    int ret = add(3,5,1);
    add(1,2,3);
    add(4,5,6);
    add(4,5,6);
    add(4,5,6);
    add(4,5,6);
    cout << ret << endl;
    return 0;
}

//add函数的，第三个参数是一个哑元
inline int add(int num1,int num2,int)
{
    cout << num1 << endl;
    cout << num1 << endl;
    cout << num1 << endl;
    cout << num1 << endl;
    cout << num1 << endl;
    cout << num1 << endl;
    return num1+num2;
}

四、C++中的结构体

【1】定义和C中的区别

1. C++中的结构体，可以定义函数；
2. C++中的结构体，可以给结构体成员初始化；
3. C++中的结构体，在定义结构体变量时，可以加struct也可以不加struct；
4. C++中的结构体，有访问权限；
5. C++中的结构体，允许被继承；
6. C++中的结构体，允许在结构体内嵌套另一个结构体定义的，C语言中，结构体内，只允许嵌套另一个结构体变量。

#include 

using namespace std;

struct Stu
{
    //public
    //private
   string name;

   void fun();     //在结构体内声明函数
   void set_age(int a)   //给结构体中的私有成员赋值,私有成员可以通过结构体内的公有函数访问
   {
       age = a;
   }
private:
   int age=18;
};

//结构体外定义函数
void Stu::fun()
{
    cout << name << endl;
    cout << age << endl;
}
int main()
{
    Stu s1;
    s1.name = "zhangsan";
    s1.set_age(1000);
    s1.fun();
    return 0;
}

练习：

1、定义一个学生的结构体，包含学生的姓名，年龄，成绩，性别，学生的成绩，姓名，定义为私有权限；定义一个学生类型的结构体变量，设置公有函数用于给学生的成绩和名字进行赋值，(结构体中的函数：结构体中声明，结构体外定义)

【2】结构体的大小

结构体对齐的原则：

1. 第一个元素，直接存；
2. 从第二个元素起，每一个元素都要在其本身偏移量的整数倍上，结构体的大小，是结构中最大对齐量的整数倍。

自身偏移量=自身的大小

五、作业：

5.1 整理思维导图

5.2 定义一个学生的结构体

定义一个学生的结构体，包含学生的姓名，年龄，成绩，性别，学生的成绩，姓名，定义为私有权限；定义一个学生类型的结构体变量，设置公有函数用于给学生的成绩和名字进行赋值，(结构体中的函数：结构体中声明，结构体外定义)

#include 

using namespace std;
struct Stu
{
    int age=18;
    char sex;
    void func();  //函数在结构体内声明
    void Msg(string &s,float &sco)  //设置共有函数，用于给学生的成绩和姓名进行赋值
    {
        name = s;
        score = sco;
    }
private: //设置私有权限
    string name;
    float score;
};

void Stu::func()  //函数在结构体外定义,用于输出值
{
    cout << "name =" << name << endl;
    cout << "age = " << age << endl;
    cout << "sex = " << sex << endl;
    cout << "score = " << score << endl;
}

int main()
{
    Stu stu;          //定义Stu类型的stu结构体
    string s = "xyt"; //姓名
    stu.age = 18;     //年龄
    stu.sex='W';      //性别
    float sco = 99;   //成绩
    stu.Msg(s,sco);   //将姓名和成绩的值传递给函数
    stu.func();

    return 0;
}

5.3 整理课上结构体的代码，重点理解，函数的结构体内声明，结构体外定义，以及对于私有的age，给age提供了一个公有的函数设置age的值