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

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

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

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

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

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

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

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

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

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

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

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

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

1.5.1、自动识别类型

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

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

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 语言高效。想要让 C++ 的输入和输出达到类似 C 语言的极致速度，可以在代码开头加入以下设置：

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

这段代码禁用了 C++ 流与 C 标准 IO 的同步，并解除了 cin 与 cout 的绑定关系，能显著提升大数据量读写时的性能。

二、C++的缺省参数

2.1、缺省参数的定义及其基本用法

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

#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(); // 未传参，使用缺省值 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, 2, 3); // 输出：1 2 3
    return 0;
}

既然是全缺省，那是不是可以所有参数都不传进去？确实可以。也可以只传部分参数的值进去，比如 Func(a) 或 Func(a, b)。

但如果想只传第一个和第三个参数的值呢？写成 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=1, c=3, b 取缺省值 20
    return 0;
}

小贴士：在传入值的时候，只能从左向右依次传值，不能跨越地、间隔跳跃地传值。

2.2.2、半缺省

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

#include<iostream>
void Func(int a, int b, int c = 10) {
    std::cout << a << " " << b << " " << c << std::endl;
}
int main() {
    Func(1, 2); // 正确，c 取缺省值
    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); // 正确，b 和 c 取缺省值
    return 0;
}

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

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

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

#include<iostream>
void fxx(int a){
    std::cout << "fxx(int a)" << std::endl;
}
void fxx(){
    std::cout << "fxx()" << std::endl;
}
int main(){
    fxx(); // 此时会产生歧义，因为 fxx() 可以匹配 fxx(int a=?) 如果存在默认值的话
    return 0;
}

掌握上述特性，能帮助你在编写 C++ 代码时更加得心应手，构建出既简洁又健壮的逻辑结构。