C++的引用和函数重载

最新推荐文章于 2024-11-09 20:38:27 发布

奕书想睡觉了。

最新推荐文章于 2024-11-09 20:38:27 发布

阅读量186

点赞数

文章标签： c++ java jvm

本文链接：https://blog.csdn.net/weixin_62318298/article/details/132439540

版权

左值的引用(reference)

如果想要实现两个数据的交换，进行值传递时，不能交换实参，使用地址传递会交换实参(额外开辟空间)

概念

引用其实就是给变量起了一个别名
C++是对C的一个重要的扩充

定义

数据类型 &引用名 = 目标名
引用的注意事项

引用必须初始化
引用不能为空
一个目标可以有多个引用
引用还能作为其他引用的目标

&的用法

取地址
按位与
&&逻辑与
&前面有数据类型表示定义引用
如果前面有数据类型，说明表示定义引用
如果&前面没有数据类型，且为单目运算，表示取变量的地址

引用基本使用

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

引用作为函数的形参

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

引用作为函数的返回值

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

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

常引用(const)

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

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

结构体中的引用成员

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

引用和指针的区别

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

C++中的动态内存分配

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

new

使用new申请单个空间

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

	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;

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

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


    //使用new申请连续的空间
    int *p = new int[5];      //在堆区申请了5个int的空间
    
    //申请连续的空间并初始化
    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
    }

delete

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




//------------------使用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;

C++提供new / delete，为什么不适用malloc / free？

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

new / delete和malloc / free的区别

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

C++中的函数

函数重载

概念

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

要求

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

实例：

#include <iostream>
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;
}

函数参数的默认值

C语言中，函数形参的值只能通过实参传递
C++中，函数的形式参数同时还支持默认值，如果实参传递，则使用实参，如果实参未传递，则使用默认值

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

使用的注意事项

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

函数重载和默认参数同时出现

如果重载的函数，和省略了默认参数后的函数参数个数一致，调用时会造成混乱；因此，尽量避免函数重载和函数的默认参数同时出现

哑元

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

哑元的使用场景

如果在大型的工程中，对某些功能的代码进行更新，为了保证对前面版本的兼容，设置某些参数为哑元，目的是为了能够让前面的代码继续正常使用
自增自减运算符的重载

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;
}

内联函数

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

内联函数的要求

在函数多次调用时，建议定义为内联函数
函数体比较小

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

C++中的机构体

定义和C中的区别

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

结构体的大小

结构体对齐原则
第一个元素，直接存，从第二个元素起，每一个元素都要在其本身偏移量的整数倍上，结构体的大小，是结构中最大对齐量的整数倍
自身偏移量=自身的大小<操作系统对齐数?自身的大小:操作系统的对齐数

练习

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

#include <iostream>

using namespace std;
struct Stu{
    int age;
    char sex;
    void o_fun();
    void fun(string name,int score);
private:
    string name = "wangwu";
    int score = 90;
};
void Stu::fun(string str,int num)
{
    name = str;
    score = num;
}
void Stu::o_fun()
{
    cout << name << endl;
    cout << age << endl;
    cout << sex << endl;
    cout << score << endl;
}
int main()
{
    Stu student;
    string name = "zhangsan";
    int num = 99;
    student.age = 21;
    student.sex = 'N';
    student.fun(name,num);
    student.o_fun();
    return 0;
}