C++三：引用使用+函数重载

一、引用的注意事项

1. 引用必须初始化。

int & ta ; // 错误的 ，取别名必须要有目标

2. 引用初始化后不能修改。

3. 对常量引用必须添加 const

const int & ca = 100 ;

4. 引用的类型必须匹配

float c = 3.14 ;

int & yc = c ; // 错误的，引用的类型不匹配

二、引用作为参数传递

1、当一个引用作为参数时，设置为常量引用，则可以传递变量也可以传递常量。

2、当一个引用作为参数传递，并设置为常量引用后，该函数不能修改目标的值。（安全）

#include <iostream>

using namespace std;

//传递引用
//形参是形式上存在的，在函数未被调用之前，是不存在的。
int add(const int &a, const int &b) //用户需要传递 变量 和 常量 给该函数，必须要设置为常量引用
{
    return a+b;
}

//修改目标的值
void change(const int &tmp)
{
    //tmp+=100; 错误的，常量引用不能修改目标的值
    cout << tmp << endl;    //只能访问
}

int main()
{
    int a = 100,b = 200;
    add(a,b); //传递变量
    
    add(100,200);    //传递常量

    //了解特殊写法（右值引用）：
    int num = 10;
    //int && a = num;    //右值引用不能初始化为左值
    int &&a = 10;    //作用：引用常量 C++11 以上的编译器才支持

    return 0;
}

三、引用作为返回值

1、当一个引用作为返回值时，必须要确保返回后，数据的空间还是存在的！！

（例如：静态变量，堆，全局变量，传递的参数引用。）

2、传递参数的引用作为返回值

3、当一个引用作为返回值，该函数可以当作左值使用。

#include <iostream>

using namespace std;

//返回参数的引用
int &func(int &date)
{
    return date;
}

int main()
{
    int tmp = 100;
    //把函数当作左值使用
    func(tmp) = 10086;    //等价于 tmp = 10086;
    
    cout << tmp << endl;

    return 0;
}

编译运行：

四、了解引用的实质

#include <iostream>

using namespace std;

struct node
{
    //声明结构体中的数据成员
    int &p; //其实就是一个常量指针
};

int main()
{
    cout << sizeof(struct node) << endl;

    int a=100;
    int b=200;

    //常量指针
    int *const p = &a;
    // p =&b; //因为常量指针所指向的地址不能修改，因为引用其实实质就是一个常量 指针。

    return 0;
}

他的操作方式 C ++ 编译器都进行优化了！

编译运行：

五、C++中的多态

什么是多态？

        多种状态！！多种形式！！一个事物（接口函数）拥有多种状态（功能）。

多态：一个对象作用于不同的事物，所得到的状态不一样。

（一个函数，对象，作用于不同的参数，所实现的功能不一样。）

六、C++的多态类型

静态多态 : 在程序《编译阶段》已经确定好要执行的状态。

（函数重载，运算符重载，模板）

动态多态 : 在程序《运行阶段》 才能确定好要执行的状态。

（虚拟函数覆盖）

七、C++中的静态多态-->函数重载

作用：通过同名的函数，实现不同的功能。（一个函数实现多种功能）

函数重载的条件：

1. 函数名相同

2. 函数的参数列表不同 ( 参数个数不同， 类型不同，或 不同类型位置不同 )

3. 返回值不能作为重载的依据

函数重载实现原理：

 练习：编写一个函数，实现不同数据类型的交换，最少3种以上。

#include <iostream>
#include <string.h>

using namespace std;

void swp(int &a,int &b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

void swp(float &a,float &b)
{
    float tmp = a;
    a = b;
    b = tmp;
}

void swp(char *a,char *b)
{   
    char tmp[100] = {0};

    strcpy(tmp,a);
    strcpy(a,b);
    strcpy(b,tmp);

}

int main()
{
    int a=10,b=20;
    cout << a << ":" << b << endl;
    swp(a,b);
    cout << a << ":" << b << endl;

    float a1=3.14,b1=2.44;
    cout << a1 << ":" << b1 << endl;
    swp(a1,b1);
    cout << a1 << ":" << b1 << endl;

    char a2[100]={"hello"};
    char b2[100]={"nihao"};
    cout << a2 << ":" << b2 << endl;
    swp(a2,b2);
    cout << a2 << ":" << b2 << endl;

    return 0; 
}

编译运行：

八、C++中的默认参数

概念：在定义函数的时候，可以给参数列表赋默认值。

作用：简化函数调用！

语法 :

返回值类型 函数名 ( 参数 1 = 值，参数 2 = 值，参数 3 = 值 )

{ }

// 例子：定义一个函数并赋值默认参数

int func ( int a = 10 , int b = 20 , int c = 30 )

{

        

}

参数的传递顺序：

默认参数的填写顺序：

九、利用默认参数简化函数接口

#include <iostream>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

using namespace std;

//原来的映射接口
//void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);

//简化映射接口
//重新设计一个my_mmap
void *my_mmap(int fd,size_t length=800*480*4,int prot=PROT_READ|PROT_WRITE, int flags=MAP_SHARED,off_t offset=0,void *addr=NULL)
{
    return mmap(addr,length,prot,flags,fd,offset);
}


int main()
{
    int fd=open("/dev/fb0",O_RDWR);

    //调用映射接口 简化调用，丰富调用方式！
    int *p = (int *)my_mmap(fd);
    int *p1 = (int *)my_mmap(fd,600*300*4);
    int *p2 = (int *)my_mmap(fd,600*300*4,PROT_READ);

    return 0;
}

十、练习

1、利用默认参数简化 open 接口,默认以读写的方式打开一个 my.txt 文件。

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

using namespace std;

//简化open接口  
int my_open(const char *pathname="my.txt", int flags=O_RDWR)
{
    return open(pathname,flags);
}


int main()
{

    int fd=my_open();

    int fd1=my_open("new.txt"); 

    int fd2=my_open("new1.txt",O_RDONLY); 

}