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

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

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

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

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

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

在我们刚刚开始学习 C++ 语言的时候，老师经常会告诉我们，这个是换行符，其实不然，它的作用远不止于此:

表面功能: 相当于插入换行符 \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++ 针对 C 语言做的优化之一。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、提高输入输出效率

在需要输入输出性能的地方，C++ 在这方面是比不过 C 语言的，想要让 C++ 的输入和输出像 C 语言一样，那就要在代码前面加上这段代码:

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

总之: C++ IO 流不仅是输入输出的工具，更是面向对象设计思想的典型实践。掌握其核心原理与最佳实践，将为你构建更健壮、可扩展的 C++ 应用打下坚实基础。

二、C++的缺省参数

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

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

#include<iostream>
//这里定义一个函数
void Func(int a = 10) {
    std::cout << a;
}
int main() {
    int a = 20;
    //这里将参数 a 传入函数中
    Func(a);
    return 0;
}

运行结果为：20。

但是这时候我们不将 a 的值传进去，我们看看结果是什么:

#include<iostream>
//这里定义一个函数
void Func(int a = 10) {
    std::cout << a;
}
int main() {
    int a = 20;
    //这里不传 a 的值进去
    Func();
    return 0;
}

运行结果为：10。

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

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() {
    int a = 1, b = 2, c = 3;
    Func(a, b, c);
    return 0;
}

运行结果为：1 2 3。

既然是全缺省，那是不是可以所有参数都不传进去？确实可以，想下面这样:

//这里为了方便，只展示主函数，其余的与上面的代码保持相同
int main() {
    int a = 1, b = 2, c = 3;
    Func();
    return 0;
}

运行结果为：10 20 30。

这时候又有读者要问了，能不能只传部分参数的值进去？我不想传完，行不行？答案是可以的，像这样:

int main() {
    int a = 1, b = 2, c = 3;
    Func(a); Func(a, b);
    return 0;
}

我们可以传只传第一个参数的值进去，也可以只传前两个参数进去，但是如果我们想只传第一个和第三个的参数进去呢？写成这样可以吗?

Func(a, ,c);

很显然是不行的，为什么？因为在制定语法的时候这是不被允许的，但是我们如果真的只想传第一个和第三个的值呢？我们可以怎么做？简单，只用调换一下位置就行了:

#include<iostream>
//像这样子调换一下 b 和 c 的位置即可
void Func(int a = 10, int c = 30, int b = 20) {
    std::cout << a << " " << b << " " << c << std::endl;
}
int main() {
    int a = 1, b = 2, c = 3;
    //只传入 a 和 c 的值
    Func(a, c);
    return 0;
}

运行结果为：1 3 20。

这样一来，只有 a 和 c 的值被修改了。

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

2.2.2、半缺省

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

#include<iostream>
//只缺省最后一个参数
void Func(int a, int b, int c=10) {
    std::cout << a << " " << b << " " << c << std::endl;
}
int main() {
    int a = 1, b = 2, c = 50;
    //这时候就要将前两个参数全部传进去
    Func(a, b);
    return 0;
}

运行结果为：1 2 10。

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

#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() {
    int a = 1, b = 2, c = 50;
    Func(a);
    return 0;
}

运行结果为：1 20 10。

小贴士: 带缺省参数的函数调用，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,int b" << std::endl;
}
void add3(double b, int a) {
    std::cout << "int 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;
}