C到C++过度（下）

一.缺省函数

1.什么是缺省函数

缺省函数，也称为默认函数，是指在定义函数时为函数的某些参数指定了默认值。

当调用这个函数时，如果没有为具有默认值的参数传递具体的值，那么函数就会使用事先定义好的默认值来进行运算。

例如，有一个函数 func(int num = 5) ，这里的 num = 5 就是给参数 num 设定的缺省值。

如果调用 func() ，此时函数内部的 num 就会使用默认值 5 进行相关操作。

再比如，一个计算矩形面积的函数 calculate_area(int length = 10, int width = 5) ，如果调用 calculate_area() ，则会按照默认的长为 10，宽为 5 来计算面积。

缺省函数能够增加函数的灵活性和易用性，减少函数调用时的参数传递数量，提高代码的简洁性和可读性。

2.全缺省

全缺省即全部形参变量都给一个默认值

如：func(int num = 5，int n=6);

{}

int main()

{

        //此时会输出num==1，n==2

        func(1,2);

       //此时会输出num==5，n==6

        func（）；

} 

3.半缺省

注意：半缺省必须从右往左缺省（缺省：有默认值为缺省）

如：func(int num ，int n=6);

{}

int main()

{

        //此时会输出num==1，n==2

        func(1,2);

       //此时会输出num==1，n==6

        func（1）；

      //此时会运行错误！！

        func（ ，2）；

} 

二.函数重载

1.什么是函数重载

函数重载：同一空间（或同一作用域）内两个同名的两个函数

当这两个函数仅满足①参数个数不同②类型不同③类型顺序不同三者其一时他们就互为重载函数可以同时存在于一个空间中。函数重载与返回值无关，返回值不是重载的条件（知识点：一个作用域中两个函数可以但要满足同载）

如：第①，void func（int ，int）

{}

void func（int，int，int）

{}

构成函数重载

第② void func（int，int）

{}

int func（char，char）

{}

构成函数重载

第③ int func（int，char）

{}

void func（char，int）

{} 

函数重载

！！注意：c语言不支持重载，c++支持重载

为什么c语言不支持重载，c++支持重载？

原因总结：在声明和定义分离时，c语言直接用函数名去查找，而c++用修饰后的函数名去查找

如：对f（int，char）

{}

f（char，int）

{}

int main（）

{

        f（1，‘a'）；

        f（’a‘，1）；

        return 0；

}

中，c语言会在系统中传回f（）因此不知道该调用谁会产生调用歧义

c++会传回类似于f（1，’a‘）传回 ？f@@YAXDH@z ，而f（’a‘，1）传回 ？f@@YAXHD@z 因此可以区分出他们之间的区别，不会产生调用歧义

这就是为什么c语言不支持重载，c++支持重载

三,引用

1.什么是引用

引用就是取别名

int a=0;

//b是a的别名

int&b=a;
 //c是a的别名
  int& c = a; 

 //d是a的别名
    int& d = b ;

//改变d，全部都会跟着改变
    d++;

2.引用的价值（引用与指针类似）

如：

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

int main()
{
    int x = 0,  y = 1;
    Swap(x, y);
    cout << x <<":"<< y << endl；

    int* p1 = &x;
    //指针变量取别名
    int*& pr = p1;
    pr = NULL;

3.引用的特性

①引用在定义时必须初始化

②一个变量可以有多个引用

③引用一旦引用一个实体，再不能引用其它实体

4.引用的放大和缩小

如：

int main()
{
    //权限的平移
    int x = 0;
    int& y = x;

    //权限的缩小，可以
    const int& z = x;
    y++;//可以影响z
        //运行不了：权限的放大,不可以
        //m只读
        //n变成我的别名，n的权限是可读可写
        const int m = 0;
    //int& n = m;
    const int& n = m;
    //可以，不是权限的放大
    //m拷贝给p，p的修改不影响m
    int p = m;

    //权限的放大
    //p1可以修改，*p1不可以，const修饰的是*p1
    const int* p1 = &m;
    //++p1；可以

    //int*p2=p1；不可以
    const int* p2 = p1;

    //权限的缩小
    int* p3 = &x;
    const int* p4 = p3;
    return 0;
}

总结：

引用和指针都有放大和缩小的概念

赋值没有

引用和指针可以缩小，不可以放大