12x函数高级

函数默认参数

#include<iostream>

// 函数声明，带有默认参数值
voidgreet(conststd::string& name = "World", int times = 1){
for (int i = 0; i < times; ++i) {
std::cout << "Hello, " << name << "!" << std::endl;
    }
}

intmain(){
// 调用函数，不提供参数，使用默认值
    greet();

// 调用函数，提供一个参数，使用另一个参数的默认值
    greet("Alice");

// 调用函数，提供所有参数
    greet("Bob", 3);

return0;
}
---
Hello, World!
Hello, Alice!
Hello, Bob!
Hello, Bob!
Hello, Bob!

函数重载

函数重载（Function Overloading）是C++中的一种特性，允许在同一个作用域中定义多个同名函数，但这些函数的参数列表必须不同。参数列表的不同可以是参数的数量不同，或者参数的类型不同。函数重载使得同一个函数名可以根据不同的参数进行不同的操作，从而提高代码的可读性和灵活性。

用法和好处

• 简化函数调用：函数重载可以简化函数调用，使代码更简洁。
• 提高代码可读性：使用函数重载可以提高代码的可读性，明确函数的不同操作。
• 灵活性：函数重载使得同一个函数名可以根据不同的参数进行不同的操作，从而提高代码的灵活性。

#include<iostream>

// 函数重载示例

// 重载函数，接受一个整数参数
voidprint(int num){
std::cout << "整数: " << num << std::endl;
}

// 重载函数，接受一个双精度浮点数参数
voidprint(double num){
std::cout << "双精度浮点数: " << num << std::endl;
}

// 重载函数，接受一个字符串参数
voidprint(conststd::string& str){
std::cout << "字符串: " << str << std::endl;
}

intmain(){
// 调用重载函数，传递整数参数
    print(10);

// 调用重载函数，传递双精度浮点数参数
    print(3.14);

// 调用重载函数，传递字符串参数
    print("Hello, World!");

return0;
}
---
整数: 10
双精度浮点数: 3.14
字符串: Hello, World!

在C++中，函数重载是通过函数的参数列表来区分不同的函数，而不是通过返回值来区分。因此，不能仅仅通过不同的返回值类型来重载函数。函数重载的注意事项包括：

1. 参数数量不同：函数的参数数量不同可以实现重载。
2. 参数类型不同：函数的参数类型不同可以实现重载。
3. 参数顺序不同：函数的参数顺序不同可以实现重载。

注意事项

• 参数列表必须不同：函数重载的参数列表必须不同，可以是参数数量、参数类型或参数顺序的不同。
• 不能仅通过返回值类型重载：函数重载不能仅通过返回值类型来区分，否则会导致编译错误。

函数重载的两个注意事项

1. 使用引用作为函数重载条件。
2. 展示函数重载碰到默认参数时的两个坑。

#include<iostream>

// 使用引用作为函数重载条件
voidprint(int& num){
std::cout << "左值引用: " << num << std::endl;
}

voidprint(constint& num){
std::cout << "常量左值引用: " << num << std::endl;
}

// 函数重载碰到默认参数的两个坑

// 函数重载，带有默认参数
voiddisplay(int a, int b = 10){
std::cout << "display(int a, int b = 10): " << a << ", " << b << std::endl;
}

// 函数重载，参数数量不同
voiddisplay(int a){
std::cout << "display(int a): " << a << std::endl;
}

intmain(){
// 使用引用作为函数重载条件
int x = 5;
constint y = 10;

    print(x); // 调用 void print(int& num)
    print(y); // 调用 void print(const int& num)

// 函数重载碰到默认参数的两个坑

// 调用 display(int a, int b = 10)
    display(1, 2);

// 调用 display(int a)
// display(1);

// 由于 display(int a) 和 display(int a, int b = 10) 都可以匹配 display(1)，会导致编译错误
// display(1); // 编译错误：调用 display(1) 时，编译器无法确定调用哪个重载函数

return0;
}
---
左值引用: 5
常量左值引用: 10
display(int a, int b = 10): 1, 2

函数占位参数

函数占位参数（placeholder parameter）在C++中是指在函数声明或定义中使用的参数，但在函数体内并不使用这些参数。占位参数通常用于保持函数签名的一致性，或者在重载运算符时使用。用法和好处

• 保持函数签名一致性：占位参数可以用于保持函数签名的一致性，特别是在重载函数时。
• 区分重载运算符：占位参数常用于区分重载运算符，如前置和后置递增运算符。

#include<iostream>

// 函数声明，带有占位参数
voidexampleFunction(int usedParam, int unusedParam){
// (int a, int) 或者(int a, int =10) 带默认参数
// 使用第一个参数
std::cout << "Used parameter: " << usedParam << std::endl;
// 占位参数 unusedParam 未被使用
}

// 重载运算符，带有占位参数
classMyClass {
public:
// 重载前置递增运算符，带有占位参数
    MyClass& operator++() {
// 实现递增逻辑
  ++value; 
return *this; // 返回递增后的对象
/*  是在 C++ 中常见的一种用法，特别是在类的成员函数中。
            它的主要作用是返回当前对象的引用或副本。
            这个用法在实现链式调用（method chaining）时非常有用*/
    }

// 重载后置递增运算符，带有占位参数
    MyClass operator++(int) {
  MyClass temp = *this; // 保存当前对象
        ++value; 
return temp; // 返回递增前的对象
    }

// 获取值
intgetValue()const{
return value;
    }

private:
int value = 0;
};

intmain(){
// 调用带有占位参数的函数
    exampleFunction(10, 20);

// 使用重载运算符的类
    MyClass obj;
std::cout << "Initial value: " << obj.getValue() << std::endl;

// 使用前置递增运算符
    ++obj;
std::cout << "After prefix increment: " << obj.getValue() << std::endl;

// 使用后置递增运算符
    obj++;
std::cout << "After postfix increment: " << obj.getValue() << std::endl;

return0;
}
-- -
Used parameter : 10
Initial value : 0
After prefix increment : 1
After postfix increment : 2