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

换行与缓冲区：endl 的应用

初学者常误以为 endl 仅是换行符。实际上，它执行两个动作：插入换行符 \n 并强制刷新输出缓冲区。这与直接使用 \n 有显著区别：

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

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

C++ IO 的核心优势

1. 自动识别类型：无需像 C 语言那样手动指定 %d、%s 等格式符，IO 流通过重载自动适配变量类型，避免未定义行为。
2. 自定义类型支持：通过重载 << 和 >> 运算符，可以让自定义类/结构体直接参与 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;
}

提高输入输出效率

默认情况下，C++ IO 流为了兼容 C 语言的 IO 功能，会与 C 标准 IO 同步。若追求极致性能，可关闭同步：

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

C++ 的缺省参数

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

#include<iostream>
void Func(int a = 10) {
    std::cout << a;
}

int main() {
    Func(); // 输出 10
    return 0;
}

全缺省与半缺省规则

全缺省指所有参数都有默认值，调用时可传任意数量参数（从左到右）。

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

int main() {
    Func(a);   // 传第一个
    Func(a, b); // 传前两个
    Func();     // 都不传
    return 0;
}

半缺省指部分参数有默认值。规定必须从右向左依次缺省，不能间隔跳跃。

// 错误示例：中间参数缺省，右侧未缺省
// void Func(int a = 10, int b, int c = 20);

// 正确示例：从右向左缺省
void Func(int a, int b = 20, int c = 10) {
    std::cout << a << " " << b << " " << c << std::endl;
}

int main() {
    Func(1); // 只传第一个，b 和 c 使用默认值
    return 0;
}

注意：函数声明和定义分离时，缺省参数只能在声明中指定，不能在两者同时出现，否则会导致重复定义错误。

C++ 的函数重载

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 main() {
    int a = 10, b = 20;
    double a2 = 1.2, b2 = 2.2;
    add(a, b);      // 调用 int 版本
    add(a2, b2);    // 调用 double 版本
    return 0;
}

常见陷阱

1. 返回值不同不构成重载：

int fxx() { return 0; }
void fxx() { }
// 编译错误：fxx 被重新定义为不同的函数

2. 缺省参数引发的歧义：

void fxx(int a){ }
void fxx(){ }
// 如果 fxx() 是 fxx(int a=0) 的简写，可能导致调用歧义

掌握这些基础特性，能帮助你编写更健壮、易维护的 C++ 代码。