cpp自学 day12 （默认参数-占位参数-重载）

函数的默认参数

CPP中函数的形参是可以有默认值的

语法：返回值类型 函数名 (参数 = 默认值) { }

​​​​int func(int a, int b = 20, int c = 30)
{
    return a + b + c;
}

int main() {
    cout << func(10, 30) << endl;
    system("pause");
    return 0;
}

如上图，如果bc都有默认值，给函数传一个值它也认，若传递的值与默认值不同，则传递的值覆盖默认值，默认值最低优先级

注意事项

1、如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值

默认实参不在形参列表的结尾  // 有默认值的参数右边必须都有默认值

int func(int a, int b = 10, int c, int d)
{
    return a+b+c; //报错，默认实参不在形参列表的结尾
}

2、函数声明有默认参数，函数实现就不能有默认参数，声明有默认参数，实现就不能有

     声明和实现只能有一个有默认参数

函数占位参数

语法：返回值类型 函数名 (数据类型){ }    //只填一个数据类型就代表占位参数了 

//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
    cout << "this is func" << endl;
}

int main() {
    func(10,10); //占位参数必须填补
    system("pause");
}

函数重载

作用：函数名可以相同，提高复用性

函数重载满足条件：

• 同一个作用域下

• 函数名称相同

• 函数参数类型不同或者个数不同或者顺序不同

                         疑问：那么我怎么知道我调用函数的时候调用的哪一个函数呢？

                            答：根据传入参数的不同，函数会根据参数类型，进行匹配

函数的返回值不可以作为函数重载的条件 

在C++中，函数重载允许我们在同一个作用域内定义多个同名函数，只要它们的参数列表（参数的类型、数量或顺序）不同。然而，函数的返回值类型不能作为区分重载函数的依据。这意味着即使两个函数的返回值类型不同，但如果它们的参数列表相同，它们也不能被视为重载函数。

例如：

#include <iostream>
using namespace std;

// 以下两个函数的参数列表相同，不能通过返回值类型来区分
int func() {
    cout << "int func() 调用" << endl;
    return 0;
}

double func() { // 错误：与上面的函数参数列表相同，不能重载
    cout << "double func() 调用" << endl;
    return 0.0;
}

int main() {
    func(); // 编译器无法区分调用哪个函数，导致编译错误
    return 0;
}

注意事项

函数的返回值不可以作为函数重载的条件

• 引用作为重载条件

• 函数重载碰到函数默认参数

引用作为重载条件

//函数重载注意事项
//1、引用作为重载条件

void func(int &a)
{
    cout << "func (int &a) 调用 " << endl;
}

void func(const int &a)
{
    cout << "func (const int &a) 调用 " << endl;
}


int main() {
    int a = 10;
    func(a); //调用无const
    func(10);//调用有const
}

关键点：引用必须要有“原名”，不能直接引用常量

函数重载碰到函数默认参数

//函数重载注意事项
//2、重载碰到函数默认参数

void func2(int a, int b = 10)
{
    cout << "func2(int a, int b = 10) 调用" << endl;
}

void func2(int a)
{
    cout << "func2(int a) 调用" << endl;
}

int main() {


    func2(10); //碰到默认参数产生歧义，需要避免，存在二义性

    system("pause");

    return 0;
}

上面的代码会报错，func2函数重载没问题，但此时我传入10这个这个常量，上下两个函数都能传进去，导致编译器不知道调哪个。

C++ 函数特性详解：默认参数、占位参数与函数重载

一、默认参数 (Default Arguments)

1. 基本语法

返回类型 函数名(参数类型 参数名 = 默认值);

示例：

int sum(int a, int b = 5, int c = 10) {
    return a + b + c;
}

int main() {
    cout << sum(1);     // 1 + 5 + 10 = 16
    cout << sum(1, 2);  // 1 + 2 + 10 = 13
}

2. 核心规则

• 右向连续原则：一旦某个参数被赋予默认值，其右侧所有参数必须都有默认值

• 声明唯一性：函数声明与定义中默认参数只能出现一次（推荐在声明中指定）

错误示例：

int func(int a, int b = 10, int c);  // ❌ c没有默认值
int func(int x = 5);                // 声明
int func(int x = 5) { ... }         // ❌ 重复指定默认参数

二、占位参数 (Placeholder Parameters)

1. 基本语法

返回类型 函数名(数据类型);

示例：

void print(int a, int) {  // 第二个参数为占位符
    cout << "Value: " << a << endl;
}

int main() {
    print(10, 0);  // 必须传入占位参数
}

2. 高级用法

• 带默认值的占位参数：

  void log(string msg, int = 0) {
      cout << "[LOG] " << msg << endl;
  }
  
  int main() {
      log("System started");  // 合法调用
  }

• 应用场景：

  • 保持接口兼容性

  • 预留功能扩展

  • 满足特定回调函数签名要求

三、函数重载 (Function Overloading)

1. 基本规则

合法重载条件（满足其一即可）：

1. 参数类型不同：void func(int) vs void func(double)

2. 参数数量不同：void func() vs void func(int)

3. 参数顺序不同：void func(int, double) vs void func(double, int)

非法重载：

int func();         // ❌ 仅返回值不同
double func();      // 无法构成重载

2. 引用类型重载

// 处理可修改左值
void process(int &val) {
    val *= 2;
}

// 处理常量/右值
void process(const int &val) {
    cout << "Value: " << val << endl;
}

int main() {
    int a = 5;
    process(a);   // 调用非const版本
    process(10);  // 调用const版本
}

3. 匹配优先级（从高到低）

1. 精确类型匹配

2. 类型提升匹配（如 char → int）

3. 标准转换匹配（如 int → double）

4. 用户定义转换匹配

四、关键注意事项

1. 默认参数陷阱

void draw(int w, int h = 50);  // 声明
void draw(int size);           // 重载函数

draw(30);  // ❌ 二义性：既可匹配draw(30,50)也可匹配draw(30)

2. const 修饰符的特殊性

• 按值传递：

  void test(int);          // ❌ 重复定义
  void test(const int);    // 顶层const不构成重载

• 指针/引用传递：

  void parse(char*);       // 处理非常量指针
  void parse(const char*); // 处理常量指针 ✅ 合法重载

3. 类型转换歧义

void calc(float);
void calc(double);

calc(10);  // ❌ 歧义：float(10)与double(10)优先级相同

五、综合示例分析

1. 合法重载案例

// 参数类型不同
void display(int num) { /*...*/ }
void display(string str) { /*...*/ }

// 参数数量不同
void connect() { /* 默认连接 */ }
void connect(string ip) { /* 指定IP */ }

// 引用类型不同
void modify(int& x) { x++; }
void modify(const int& x) { cout << x; }

2. 错误用法集合

// 默认参数顺序错误
void setup(int a = 5, int b);  // ❌

// 二义性调用
void render(int duration);
void render(int duration, int fps = 60);
render(100);  // ❌ 可能匹配两个版本

// 无效重载
double getArea(double r);
int getArea(double r);  // ❌ 仅返回值不同