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

这种重载实现了'语法糖'效果，让 IO 操作更符合直觉。同时，运算符的返回值是流对象本身，支持链式调用：

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

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

换行与缓冲区：endl 的应用

初学者常误以为 endl 只是换行符，其实不然，其作用远不止于此：

• 表面功能：相当于插入换行符 \n，实现文本换行
• 深层功能：强制刷新输出缓冲区，将缓冲区的数据立即写入输出设备

这与直接使用 \n 有着显著的区别：

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

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

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

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

自动识别类型

在 C 语言中，使用 printf() 需要手动指定格式符，如 %s %d %f 等，一旦格式符与变量类型不相同，就会导致未定义行为。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;
    // 输出：点的坐标：(10, 20)
    return 0;
}

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

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

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

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

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

提高输入输出效率

在需要输入输出性能的地方，C++ 默认配置下可能不如 C 语言高效。想要让 C++ 的输入和输出像 C 语言一样快，可以在代码开头加上这段优化代码：

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() {
    int a = 20;
    Func(a); // 传入参数，使用传进来的值
    return 0;
}

如果不将 a 的值传进去，结果会怎样？

#include <iostream>

void Func(int a = 10) {
    std::cout << a;
}

int main() {
    Func(); // 不传参数，使用缺省值
    return 0;
}

总结来说，我们在定义一个函数时，如果给里面的参数进行了初始化，那么在主函数调用时，如果给函数传进了参数，那就使用传进来的参数；如果没有传参数，那就使用在函数定义时所设定的初始值。

全缺省与半缺省

全缺省

全缺省顾名思义就是函数中全部参数都给了缺省值。

#include <iostream>

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

int main() {
    Func(); // 所有参数都不传，使用缺省值
    Func(1); // 只传第一个
    Func(1, 2); // 只传前两个
    return 0;
}

既然是全缺省，那是不是可以所有参数都不传进去？确实可以。这时候又有读者可能会问，能不能只传部分参数的值进去？比如只传第一个和第三个？写成 Func(a, , c) 显然是不行的，因为在制定语法的时候这是不被允许的。如果我们真的只想传第一个和第三个的值，可以调换一下位置：

#include <iostream>

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

int main() {
    Func(1, 3); // 只传入 a 和 c 的值
    return 0;
}

这样一来，只有 a 和 c 的值被修改了。需要注意的是，在传入值的时候，只能从左向右依次传值，不能跨越地、间隔跳跃地传值。

半缺省

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

#include <iostream>

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

int main() {
    Func(1, 2); // 必须传入前两个参数
    return 0;
}

如果想要让两个参数缺省，那就这样子写：

#include <iostream>

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

int main() {
    Func(1); // 只传入 a
    return 0;
}

注意：带缺省参数的函数调用，C++ 规定必须是从左到右依次给实参，不能跳跃给实参。函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，这时候规定必须是函数声明时给缺省值。

C++ 的函数重载

在 C 语言中，我们经常碰到这样的问题：写很多个功能相同的函数但是命名却不能相同，这样就导致了程序员在编写代码时的效率大幅度降低。而 C++ 的函数重载就是为了解决这个问题。

函数重载的定义

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

但是也要小心缺省函数带来的类似返回值不同的效果：

#include <iostream>

void fxx(int a) {
    std::cout << "fxx(int a)" << std::endl;
}

void fxx() {
    std::cout << "fxx()" << std::endl;
}

int main() {
    fxx(); // 这就是缺省参数带来的类似返回值不同的效果
    return 0;
}

掌握这些基础特性，能让你的 C++ 代码更加简洁、健壮且易于维护。