一、输入【cin】、输出【cout】

【代码示例】

#include <iostream>
int main()
{
	int x;
	double y;
	std::cin >> x >> y;
	std::cout << "x = " << x << std::endl;
	std::cout << "y = " << y << std::endl;
	return 0;
}

【知识要点】

1. <iostream>是Input Output Stream 的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
2. <<是流插⼊运算符，>>是流提取运算符。
3. cin/cout/endl等都属于C++标准库，C++标准库都放在一个叫std (standard)的命名空间中，所以要通过命名空间的使用方式来用。

---

二、命名空间

【命名空间的概念】

为避免变量、函数和类的名称都存在于全局作用域中而导致命名冲突，故C++引入namespace关键字。

【使用方法】

这里创建了名为wyx的命名空间，并在之中创建了一个名为wyx2的命名空间。

namespace wyx // 外层命名空间
{
	namespace wyx2 // 嵌套命名空间
	{
		double x = 3.14;
	}
	int x = 5; // 变量
	struct Node // 结构体
	{
		int a;
		double b;
	};
	void Func() // 函数
	{
		std::cout << "hello,world!" << std::endl;
	}
}

学过C语言的都知道，当调用变量时，会优先调用局部变量，若局部变量不存在，再调用全局变量。
同理，当编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间⾥⾯去查找。
所以我们要使⽤命名空间中定义的变量/函数，有三种⽅式：

一、指定命名空间访问
示例：

1. 如需调用外层命名空间wyx中的Func函数：
2. 输出嵌套命名空间wyx2中的x：

#include <iostream>
namespace wyx // 外层命名空间
{
	namespace wyx2 // 嵌套命名空间
	{
		double x = 3.14;
	}
	int x = 5; // 变量
	struct Node // 结构体
	{
		int a;
		double b;
	};
	void Func() // 函数
	{
		std::cout << "hello,world!" << std::endl;
	}
}
int main()
{
	wyx::Func(); // 1
	std::cout << wyx::wyx2::x << std::endl; // 2
	return 0;
}

运行结果：

二、使用using将命名空间中某个成员展开，项⽬中经常访问的不存在冲突的成员推荐这种⽅式。
示例：

1. 将外层命名空间wyx中的Func函数展开
2. 将嵌套命名空间wyx2中的x展开

#include <iostream>
namespace wyx // 外层命名空间
{
	namespace wyx2 // 嵌套命名空间
	{
		double x = 3.14;
	}
	
	int x = 5; // 变量
	struct Node // 结构体
	{
		int a;
		double b;
	};
	void Func() // 函数
	{
		std::cout << "hello,world!" << std::endl;
	}
}
using wyx::Func; // 1
using wyx::wyx2::x; // 2
int main()
{
	Func(); // 1
	std::cout << x << std::endl; // 2
	return 0;
}

运行结果：

三、展开命名空间中全部成员，项⽬不推荐，冲突⻛险很⼤，⽇常⼩练习程序为了⽅便推荐使⽤。
示例：

1. 将C++标准库std (standard)展开
2. 将外层命名空间wyx展开

#include <iostream>
namespace wyx // 外层命名空间
{
	namespace wyx2 // 嵌套命名空间
	{
		double x = 3.14;
	}
	int x = 5;
	struct Node
	{
		int a;
		double b;
	};
	void Func()
	{
		std::cout << "hello,world!" << std::endl;
	}
}
using namespace std; // 1
using namespace wyx; // 2
int main()
{
	Func();
	cout << x << endl;
	return 0;
}

运行结果：

---

三、缺省参数

【缺省参数的概念】

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

【使用方法】

#include <iostream>
using namespace std;
void Func1(int a = -5, int b = 5, int c = 100, int d = 2000)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	cout << d << endl << endl;
}
void Func2(int a, int b, int c = 100, int d = 2000)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	cout << d << endl << endl;
}
int main()
{
	Func1();
	Func1(1);
	Func1(1, 2);
	Func1(1, 2, 3);
	Func1(1, 2, 3, 4);
	cout << "------------------" << endl << endl;
	Func2(1, 2);
	Func2(1, 2, 3);
	Func2(1, 2, 3, 4);
	return 0;
}

运行结果：

在使用缺省参数时需注意以下三点：

一、带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参。
错误示例：

二、C++规定半缺省参数必须从右往左依次连续缺省，不能间隔跳跃给缺省值。
错误示例：

三、函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须在函数声明中给缺省值。
正确示例：

运行结果：

---

四、函数重载

【函数重载的概念】

C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同、类型不同、顺序不同。
这样C++函数调⽤就表现出了多态⾏为，使⽤更灵活。

【使用方法（四点）】

一、可参数个数不同

二、可参数类型不同

三、可参数类型的顺序不同

四、不可仅返回值不同

【可能遇到的问题【缺省参数&函数重载】“对重载函数的调用不明确”】

#include <iostream>
using namespace std;
void Func() // Func_A
{
	cout << "Func_A";
}
void Func(int b = 888) // Func_B
{
	cout << "Func_B";
}
int main()
{
	Func();
	return 0;
}

当运行以上代码时，会出现“对重载函数的调用不明确”的报错。

结论： 当调用Func()发现有多个可行的重载函数，编译器必然报错。这种设计确保了代码的明确性，避免运行时的不确定性。

---

五、引用

【引用的概念】

引用是给已存在变量取的别名，编译器不会为引用变量开辟内存空间，它和引用的变量共用同一块内存空间。

#include <iostream>
int main()
{
    int a = 10;
    int& b = a;  // b是a的别名
    b = 20;      // 修改b即修改a
    std::cout << "a = " << a << std::endl;  // 输出: a = 20
    return 0;
}

【引用的底层实现】

引用在底层是通过指针常量实现的：

1. 编译器将引用变量处理为int* const ptr（指向不可变的指针）
2. 引用操作被转换为指针解引用操作
3. 引用不占用额外内存（与指针不同）

示例分析：

int a = 10;
int& b = a;   // 底层等效于：int* const b = &a;
b = 20;       // 底层等效于：*b = 20;

关键点：

• 引用必须初始化的特性由指针常量的特性保证
• 引用不可改变指向的特性由const修饰符保证
• 引用操作被编译器自动转换为指针操作

【引用的特性】

1. 定义时必须初始化：引用必须在声明时绑定到一个实体。
2. 一个变量可有多个引用：多个别名可指向同一实体。
3. 引用不可改变指向：一旦绑定实体，不能再引用其他对象。

	int x = 5;
	int& r1 = x;  // ✅ 正确
	int& r2 = x;  // ✅ 正确: 多个别名可指向同一实体
	// int& r3;   // ❌ 错误：未初始化
	int y = 10;
	r1 = y;       // 赋值操作，非改变引用指向（x的值变为10）

【引用的使用场景】

1. 引用传参：避免拷贝，直接操作原对象（替代指针传参）。
2. 引用返回值：返回别名可修改原对象（需注意生命周期）。

// 引用传参：交换两个数
void Swap(int& a, int& b)
{
   int tmp = a;
   a = b;
   b = tmp;
}

// 引用返回：修改栈顶元素
int& Top(std::stack<int>& st)
{
   return st.top();  // 返回引用可修改栈顶
}

【const引用】

1. 权限缩小：const引用可绑定普通变量（只读访问）。
2. 临时对象：表达式结果或类型转换的中间值具有常性，需用const引用。

const int c = 100;
const int& rc = c;  // ✅ 正确

double d = 3.14;
const int& rd = d;  // ✅ 正确：绑定临时int对象
// int& r = d;      // ❌ 错误：权限放大

【指针与引用的区别】

特性	指针	引用
初始化	可不初始化（危险）	必须初始化
指向可变性	可改变指向	不可改变指向
内存占用	占用独立内存（4/8字节）	无独立内存（共用原变量空间）
访问方式	需解引用（*ptr）	直接访问（别名）
安全性	可能空指针/野指针	更安全（无空引用）

---

六、内联函数

【内联函数的概念】

用 inline 修饰的函数称为内联函数。编译时，编译器尝试在调用处直接展开函数体，避免函数调用开销（无栈帧创建）。
注意：inline 仅是建议，编译器会根据函数复杂度决定是否展开（递归/长函数可能被忽略）。

【使用方法】

inline int Add(int x, int y) {
   return x + y;
}
int main() {
   int ret = Add(1, 2);  // 可能被展开为：int ret = 1 + 2;
   return 0;
}

【注意事项】

1. 替代宏函数：解决宏的调试困难与类型安全问题。
2. 禁止分离声明与定义：内联函数需在头文件中定义，否则链接错误（展开后无函数地址）。
3. 适用场景：短小且频繁调用的函数（如简单getter/setter）。

---

七、nullptr

【nullptr的概念】

C++11引入的关键字，专用于表示空指针。解决 NULL 在C++中被定义为 0 导致的重载歧义问题。

【使用方法】

void Func(int x) { std::cout << "int\n"; }
void Func(int* ptr) { std::cout << "pointer\n"; }

int main() {
   Func(0);          // 调用 int 版本
   Func(NULL);       // 可能调用 int 版本（NULL=0）
   Func(nullptr);    // 明确调用 pointer 版本
   return 0;
}

【与NULL的对比】

特性	NULL	nullptr
类型	整型（通常为0）	指针类型（std::nullptr_t）
重载匹配	可能误匹配整型重载	精确匹配指针重载
安全性	隐式类型转换风险	类型安全

关键点：始终使用 nullptr 表示空指针，避免历史遗留问题。

---