C++ 入门进阶：输入输出流、缺省参数与函数重载

1.4 换行与缓冲区：endl 的应用

初学者常误以为 endl 只是换行符。实际上，它除了插入换行符 \n 外，还会强制刷新输出缓冲区，将数据立即写入设备。这与直接使用 \n 有显著区别：

// 仅换行，不刷新缓冲区，性能更优
std::cout << "Hello\n";
// 换行 + 刷新缓冲区，适用于调试或需要立即输出的场景
std::cout << "Hello" << std::endl;

频繁使用 endl 会导致缓冲区频繁刷新，降低 IO 性能。在高敏感场景中，优先使用 \n，仅在需要立即输出时使用 endl。

1.5 C++ IO 的核心优势

自动识别类型

C 语言的 printf() 需手动指定格式符（如 %d, %s），一旦类型不匹配即产生未定义行为。C++ IO 流通过重载实现了自动类型识别：

int num = 42;
double pi = 3.14;
std::string name = "C++";
std::cout << num << " " << pi << " " << name << std::endl;
// 输出：42 3.14 C++

这不仅简化了代码，还从根本上避免了格式错误。

自定义类型支持

C++ IO 流支持通过重载 << 和 >> 运算符，让自定义类像内置类型一样参与 IO 操作：

#include <iostream>
struct Point { int x, y; };

// 重载<<运算符，实现 Point 类型的输出
std::ostream& operator<<(std::ostream& os, const Point& p) {
    return os << "(" << p.x << ", " << p.y << ")";
}

int main() {
    Point p{10, 20};
    std::cout << "点的坐标：" << p << std::endl;
    return 0;
}

1.6 提高输入输出效率

若需追求极致 IO 性能，可关闭 C++ 流与 C 标准流的同步，并解绑 cin 与 cout：

ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);

二、C++ 的缺省参数

2.1 定义与基本用法

缺省参数是在声明或定义函数时为参数指定默认值。调用时若未传实参则使用默认值，否则使用传入值：

#include<iostream>
void Func(int a = 10) {
    std::cout << a;
}
int main() {
    Func(); // 输出 10
    return 0;
}

2.2 全缺省与半缺省

全缺省

所有参数均设置默认值。调用时可传全部、部分或不传参数：

void Func(int a = 10, int b = 20, int c = 30) {
    std::cout << a << " " << b << " " << c << std::endl;
}

注意：只能从左向右依次传值，不能跳跃。例如想只传第一个和第三个参数，需调整参数顺序：

void Func(int a = 10, int c = 30, int b = 20) {
    std::cout << a << " " << b << " " << c << std::endl;
}
// 调用 Func(1, 3); 即可跳过中间参数

半缺省

部分参数设置默认值，规定必须从右向左依次缺省，不能间隔跳跃：

// 正确：从右向左缺省
void Func(int a, int b = 20, int c = 10);

// 错误：中间参数缺省，左侧未缺省
void Func(int a, int b = 20, int c); // 编译错误

此外，当函数声明和定义分离时，缺省参数只能在声明处指定，不能在定义处重复指定。

三、C++ 的函数重载

3.1 函数重载的定义

C++ 支持在同一作用域中出现同名函数，但要求形参不同（个数、类型或顺序）。这解决了 C 语言中功能相同却需命名不同导致的效率问题。

#include<iostream>

// 参数类型不同
int add(int a, int b) {
    std::cout << "int (a+b) " << a + b << std::endl;
    return a + b;
}

double add(double a, double b) {
    std::cout << "double (a + b) " << a + b << std::endl;
    return a + b;
}

// 参数个数不同
int add2(int a, int b, int c) {
    std::cout << "int (a + b + c) " << a + b + c << std::endl;
    return a + b + c;
}

int add2(int a, int b, int c, int d) {
    std::cout << "int (a + b + c + d) " << a + b + c + d << std::endl;
    return a + b + c + d;
}

// 参数类型顺序不同
void add3(int a, double b) {
    std::cout << "int a, double b" << std::endl;
}

void add3(double b, int a) {
    std::cout << "double b, int a" << std::endl;
}

int main() {
    int a = 10, b = 20, c = 30, d = 40;
    double a2 = 1.2, b2 = 2.2;
    add(a, b);
    add(a2, b2);
    add2(a, b, c);
    add2(a, b, c, d);
    return 0;
}

3.2 注意事项

1. 返回值不能作为重载条件：编译器无法仅凭返回值区分同名函数。

   int fxx() { return 0; }
   void fxx() {} // 错误：重定义
   

2. 缺省参数的歧义：缺省参数可能导致类似返回值的冲突，需谨慎处理。

   void fxx(int a){}
   void fxx(){fxx(0);} // 推荐显式传递参数而非依赖隐式转换
   

掌握这些机制，能让代码更加简洁且易于维护。