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

• << : 流插入运算符，用于向输出流写入数据
• >> : 流提取运算符，用于从输入流提取数据

这种设计让 IO 操作更符合直觉。同时，运算符返回值是流对象本身，支持链式调用：

std::cout << "姓名：" << "张三" << "，年龄：" << 25 << std::endl;

链式调用的底层原理是：每次 << 操作返回 ostream&，使得后续操作可以直接作用于同一个流对象。

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

初学者常误以为 endl 只是换行符，其实它的深层功能是强制刷新输出缓冲区，将缓冲区数据立即写入输出设备。这与直接使用 \n 有显著区别：

// 仅换行，不刷新缓冲区，性能更优
std::cout << "Hello\n";

// 换行 + 刷新缓冲区，适用于需要立即输出的场景（如调试日志）
std::cout << "Hello" << std::endl;

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

1.5 C++ IO 的核心优势：从手动格式到自动适配

1.5.1 自动识别类型

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++

这不仅简化了代码，还从根本上避免了格式不匹配的问题。

1.5.2 自定义类型支持

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;
    // 输出：点的坐标：(10, 20)
    return 0;
}

这种可扩展性让 C++ IO 流成为面向对象编程的理想选择。

1.6 面向对象的底层支撑：IO 流的设计思想

C++ IO 流的设计深度融合了面向对象的核心思想：

• 继承体系：istream 和 ostream 作为基类，派生出文件流 (fstream)、字符串流 (sstream) 等子类，实现了 IO 操作的统一接口。
• 多态与重载：通过运算符重载和虚函数，实现了不同类型数据的 IO 适配。
• 封装性：底层缓冲区管理、设备交互等细节被封装在流内部，开发者只需关注高层接口。

这些设计使得 IO 流库既灵活又易于拓展，但也意味着需要掌握更多面向对象知识才能深入理解其底层应用原理。

1.7 提高输入输出效率

在需要极致 IO 性能的地方，C++ 默认配置可能不如 C 语言高效。若希望提升速度，可在代码开头加入以下设置：

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 全缺省与半缺省

2.2.1 全缺省

全缺省指函数中全部参数都有缺省值。此时可以完全不传参，也可以只传部分参数。

#include <iostream>
void Func(int a = 10, int b = 20, int c = 30) {
    std::cout << a << " " << b << " " << c << std::endl;
}
int main() {
    Func();      // 输出 10 20 30
    Func(1);     // 输出 1 20 30
    Func(1, 2);  // 输出 1 2 30
    return 0;
}

注意：只能从左向右依次传值，不能跨越地、间隔跳跃地传值。例如 Func(a, , c) 是不允许的。如果确实想跳过中间参数，可以通过调整参数顺序来实现。

2.2.2 半缺省

半缺省指对函数中部分变量进行初始化。规定只能从右往左依次缺省，不能间隔跳跃缺省。

#include <iostream>
// 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); // 输出 1 20 10
    return 0;
}

小贴士：

1. 带缺省参数的函数调用，必须从左到右依次给实参，不能跳跃。
2. 函数声明和定义分离时，缺省参数不能在两者中同时出现，通常规定必须在函数声明时给出缺省值。

三、C++的函数重载

在 C 语言中，功能相同的函数必须命名不同，这降低了开发效率。C++ 的函数重载允许在同一作用域中出现同名函数，只要它们的形参不同即可。

3.1 函数重载的定义

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 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;
}

重要提示：返回值的不同不能作为重载条件。因为如果是同名函数，编译器无法区分调用哪个版本：

#include <iostream>
int fxx() {
    std::cout << "int fxx()" << std::endl;
}
void fxx() {
    std::cout << "void fxx()" << std::endl;
}
int main(){
    fxx(); // 编译错误：调用歧义
    return 0;
}

此外，也要小心缺省参数带来的类似返回值不同的效果，可能导致调用歧义。