C++ Day2

目录

一、左值引用(reference)

【1】概念

【2】定义

思考: 

 【3】引用基本使用

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

练习:

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

 【6】常引用(const)

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

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

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

【1】new

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

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

【2】delete

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

 三、C++中的函数

【1】函数重载(overload)

i)概念

ii)函数重载的要求

iii)函数重载的代码

2】函数参数的默认值

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

【4】哑元

【5】内联函数(inline)

四、C++中的结构体

【1】定义和C中的区别

 练习:

【2】结构体的大小

 作业:


一、左值引用(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;
}

思考: 

1、引用可不可以更改目标?不能更改目标

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

练习:

1、尝试实现,冒泡排序,要求:引用作为函数的形参。

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

=:赋值运算符

左值 = 右值;

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

右值:只能作为右值

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是库函数

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

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.如果函数的某一个形参有默认值,说明该参数右侧的所有参数都是有默认值的

使用的注意事项:

  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】哑元

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

哑元的使用场景:

使用场景一:如果在大型的工程中,对某些功能的代码进行更新,为了保证对前面版本的兼容,设置某些参数为哑元,目的能够让前面的代码继续正常使用。

使用场合二:自增自减运算符的重载(后面讲)

#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】结构体的大小

结构体对齐的原则:

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

自身偏移量=自身的大小

 作业:

#include 

using namespace std;

struct students{
    int age;
    string sex;
    void set_stu(string name1, float score2);
private:
    string name;
    float score;


};
void students::set_stu(string name1, float score2)
{
    students :: name = name1;
    students :: score = score2;
    cout << name << endl;
    cout << score << endl;
}
int main()
{

    struct students a;
    a.age = 15;
    a.sex = "男";
    a.set_stu("zhangsan",98.5);
    cout << a.age << endl;
    cout << a.sex << endl;
    return 0;
}

你可能感兴趣的:(转世重生,c++,算法,开发语言)