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/freeC中的库函数

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

0822|C++day2 引用+函数重载_第1张图片

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

 

你可能感兴趣的:(嵌入式学习,C++,#,c++作业,c++,算法,开发语言)