C++入门——命名空间与输入输出与缺省参数与重载函数与引用与内联

命名空间——namespace

命名空间的用处

在C++中，命名空间（namespace）的作用与价值主要体现在以下几个方面：

• 避免命名冲突： 命名空间允许开发者将全局作用域划分为更小的区域，不同命名空间中的标识符（如变量、函数、类等）可以同名而不会冲突。这在大型项目中特别重要，可以避免不同部分的代码因命名冲突而产生错误。

• 组织代码结构： 命名空间可以帮助开发者更好地组织代码结构，使代码更具可读性和可维护性。通过合理划分命名空间，可以清晰地表达模块间的关系和依赖。

• 版本管理： 命名空间可以用于版本控制，不同版本的同名函数或类可以放在不同的命名空间中，避免版本升级时的冲突和兼容性问题。

• 库的封装： 在开发库时，命名空间可以用于封装库中的函数和类，避免与用户代码的命名冲突，并提供清晰的接口。

• 提供扩展性和灵活性： 命名空间的引入使得代码具备更强的扩展性和灵活性，可以更容易地向项目中添加新功能或模块而不会破坏现有的代码结构和功能。

命名空间的定义

定义命名空间，需要使⽤到namespace关键字，后⾯跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。

• namespace本质是定义出⼀个域，这个域跟全局域各⾃独⽴，不同的域可以定义同名变量，所以下⾯的rand不在冲突了。

• C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的⽣命周期，命名空间域和类域不影响变量⽣命周期。

• namespace只能定义在全局，当然他还可以嵌套定义。

• 项⽬⼯程中多⽂件中定义的同名namespace会认为是⼀个namespace，不会冲突。

• C++标准库都放在⼀个叫std(standard)的命名空间中。

代码如下：

namespace space
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;
	int Add(int left, int right)
	{
		return left + right;
	} 
	struct Node
	{
		struct Node* next;
		int val;
	};
}

int rand = 1;

命名空间的使用

1，使用命名空间一般情况需要运用作用域解释符 :: 才能识别成功

代码实例：

namespace A
{
	int a = 10;

	struct S
	{
		int x;
	};
}

int a = 100;


int main()
{
	cout << a << endl;
	cout << A::a << endl;

	A::S m;
	m.x = 0;
	return 0;
}

结果如图：

2，每次都要写一个：：比较麻烦，于是在个人写代码可以考虑使用展开命名空间：

using namespace A;

这就相当于把括号去掉了，变成了全局都可以使用的,不过就要注意冲突问题了。

3，也可以单独展开一部分内容，从而使这部分不用使用：：

using A::a;

命名空间的嵌套

命名空间可以嵌套定义，允许在一个命名空间内部定义另一个命名空间。这种嵌套结构有助于更细致地组织和管理代码，特别是对于大型项目而言。

示例：

namespace Outer 
{
    int x;

    namespace Inner 
    {
        int y;
    }
}

在上面的示例中，Outer 是外部命名空间，Inner 是嵌套在 Outer 中的内部命名空间。可以通过限定名访问其中的成员：

Outer::x = 10;
Outer::Inner::y = 20;

命名空间的别名

C++支持使用别名（alias）来简化命名空间的使用，特别是当需要引用一个较长或复杂的命名空间时。

示例：

namespace very::long::namespace::name {
    int some_value;
}

// 别名的使用
cnamespace alias = very::long::namespace::name;

// 使用别名访问命名空间成员
alias::some_value = 42;

上面的示例中，very::long::namespace::name 是一个比较长的命名空间名称，通过别名 alias 可以更方便地访问其成员。

使用命名空间别名的注意事项

局部化别名的影响范围： 命名空间别名只在声明它的作用域内有效，超出该作用域范围后别名不再有效。

namespace a::b::c {
    int value;
}

int main() {
    namespace abc = a::b::c;
    abc::value = 10;  // 合法
    
    // 超出作用域范围，别名不再有效
    abc::value = 20;  // 错误：abc未定义
    return 0;
}

命名空间的层次和别名： 可以在需要的层次上使用别名，以提高代码的可读性和简洁性。但要注意，过度使用别名可能导致代码可读性下降，因此应谨慎选择使用别名的位置和方式。

输入与输出

原理概述

C++ 中的输入输出（IO）机制涉及到 iostream 标准库的使用，主要由 std::cout 和 std::cin 这两个对象负责处理输出和输入操作。这些对象的背后涉及到一些基本的工作原理：

输出流 (std::cout)
std::cout 对象：

std::cout 是 ostream 类的一个实例，定义在 头文件中。
它是标准输出流，用于将数据发送到控制台或其他标准输出设备。
插入操作符 (<<)：

输出流使用 << 操作符（插入操作符）来将数据插入到输出流中。
std::cout << “Hello, World!” 将字符串 “Hello, World!” 插入到输出流中。

刷新输出缓冲区：

输出流通常使用缓冲区来提高效率。为了确保输出及时显示，可以使用 std::endl 操作符来插入换行符并刷新缓冲区。

输入流 (std::cin)
std::cin 对象：

std::cin 是 istream 类的一个实例，也定义在 头文件中。
它是标准输入流，用于从键盘或其他标准输入设备获取用户输入的数据。
提取操作符 (>>)：

输入流使用 >> 操作符（提取操作符）来从输入流中提取数据并存储到相应的变量中。
std::cin >> num 将用户输入的数据转换成整数并存储到 num 变量中。

工作原理概述
输入输出流的工作：

在程序中，输出通过 std::cout 发送到输出设备，例如显示器。
输入通过 std::cin 从输入设备（通常是键盘）读取用户输入。
流缓冲：

输出流和输入流通常都具有缓冲机制，这意味着数据首先被存储在缓冲区中，然后才被实际写入或读取。
缓冲区的使用可以提高IO性能，减少频繁的系统调用。

错误处理：

输入操作可能导致的错误（如输入不匹配的数据类型）可以通过检查流状态来处理，例如 std::cin.fail() 来检测输入是否有效。
流操作符的链式调用：

流操作符 << 和 >> 可以链式调用，使得多个输出或输入操作可以连续进行，例如 std::cout << “Hello” << " " << “World!”。

输入输出的使用

输出（Output）

在C++中，输出通常使用 std::cout 对象，该对象位于 iostream 头文件中。它使用 << 操作符来将数据发送到标准输出流（通常是控制台）。

示例：

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

在这个例子中：

std::cout 是标准输出流对象。
<< 操作符用于将字符串和其他数据插入到输出流中。
std::endl 是用于输出换行并刷新缓冲区的操作符。

输入（Input）
输入使用 std::cin 对象，也位于 iostream 头文件中。它使用 >> 操作符来从标准输入流（通常是键盘）中读取数据。

示例：

#include <iostream>

int main() {
    int num;
    std::cout << "Enter a number: ";
    std::cin >> num;
    std::cout << "You entered: " << num << std::endl;
    return 0;
}

在这个例子中：

std::cin 是标准输入流对象。
>> 操作符用于从输入流中提取数据，并存储到变量 num 中。
输入输出流的操作

在C++中，除了基本的输入和输出操作外，还可以使用流操作符 << 和 >> 进行更复杂的输入输出。这些操作符可以被重载以支持不同类型的数据，包括基本类型（整数、浮点数）、字符串、自定义类型等。

示例：

#include <iostream>
#include <string>

int main() {
    std::string name;
    int age;
    
    std::cout << "Enter your name: ";
    std::cin >> name;
    
    std::cout << "Enter your age: ";
    std::cin >> age;
    
    std::cout << "Hello, " << name << "! You are " << age << " years old." << std::endl;
    
    return 0;
}

控制输入输出格式

在C++中，可以使用一些控制符号来控制输出的格式，例如：

• std::setw(int width): 设置字段宽度。
• std::setprecision(int n): 设置浮点数的精度。
• std::fixed 和 std::scientific: 控制浮点数的输出格式。
  示例：

#include <iostream>
#include <iomanip>

int main() {
    double pi = 3.141592653589793;
    
    std::cout << "Pi: " << std::setprecision(5) << pi << std::endl;
    std::cout << "Pi (fixed): " << std::fixed << pi << std::endl;
    std::cout << "Pi (scientific): " << std::scientific << pi << std::endl;
    
    return 0;
}

错误处理

在实际应用中，需要考虑用户的输入可能导致的错误，如非法输入（例如输入不匹配的数据类型）。可以使用流状态和函数来检测和处理这些错误，例如：

#include <iostream>

int main() {
    int num;
    
    std::cout << "Enter an integer: ";
    if (!(std::cin >> num)) {
        std::cerr << "Invalid input!" << std::endl;
        return 1;
    }
    
    std::cout << "You entered: " << num << std::endl;
    
    return 0;
}

在这个示例中，通过 std::cin >> num 的返回值来检查输入的有效性，如果输入不是一个整数，则输出错误信息。

缺省参数

缺省参数（Default arguments）是指在函数声明中为某些参数提供默认值，使得在调用函数时可以省略这些参数的赋值操作。这种特性在许多编程语言中都有支持，包括C++。

定义缺省参数的方式

在 C++ 中，可以在函数声明或定义中为参数提供默认值。例如：

void func(int a, int b = 10, int c = 20) {
    // 函数体
}

在上面的例子中，b 和 c 是带有默认值的参数。调用 func 函数时，可以这样使用：

func(5);     // a = 5, b = 10 (默认值), c = 20 (默认值)
func(5, 15); // a = 5, b = 15, c = 20 (默认值)
func(5, 15, 25); // a = 5, b = 15, c = 25

使用缺省参数的价值和优势

• 简化函数调用：

缺省参数允许函数的调用者仅提供必需的参数，而无需在每次调用时都指定所有参数。这样可以减少重复性代码，提高代码的可读性和简洁性。

• 向后兼容性：

在不破坏现有调用的情况下，可以向函数中添加新的参数并为其提供默认值。这样可以在扩展函数功能时保持向后兼容性，不需要修改现有代码。

• 灵活性：

默认参数可以根据函数的使用场景而设定，使得函数在不同的调用情境下表现出不同的行为，从而增加了函数的灵活性。
降低错误的风险：

减少了因遗漏某些参数导致的错误，特别是在函数有多个参数时，使用默认参数可以减少出错的可能性。

• 清晰的代码结构：

当函数有多个参数时，使用默认参数可以使函数声明更加简洁和清晰，避免过多的重复信息。
使用缺省参数的注意事项
默认参数的位置：

默认参数必须从右向左连续出现，即不允许非默认参数之后再有默认参数。

• 声明和定义的一致性：

如果在函数声明时指定了默认参数，那么在函数定义时也必须提供默认参数的值，否则会导致编译错误。
可读性考量：

虽然可以提高代码的简洁性，但过多或不当使用默认参数可能会降低代码的可读性和维护性。因此，应合理使用，确保代码的清晰和易理解性。

函数重载

函数重载（Function overloading）是指在同一个作用域内，可以定义多个同名函数，但它们的参数列表（包括参数类型和个数）必须不同。函数重载允许使用相同的函数名来定义多个功能类似但参数类型或个数不同的函数，从而增强了函数的灵活性和可复用性。

定义与使用

在 C++ 中，函数重载通过函数名相同但参数列表不同来实现。例如：

// 重载函数示例
void print(int a) {
    cout << "Integer: " << a << endl;
}

void print(double b) {
    cout << "Double: " << b << endl;
}

void print(string s) {
    cout << "String: " << s << endl;
}

上述例子中，print 函数被重载了三次，分别接受整数、双精度浮点数和字符串作为参数。调用时根据参数类型的不同，编译器会选择匹配的重载函数进行调用。

价值与优势

• 增加灵活性：

函数重载允许使用相同的函数名来处理不同类型的参数，从而提高了函数的灵活性和通用性。

• 简化接口：

可以使用同一个函数名来实现多种功能，而无需为每种类型编写单独的函数，从而简化了接口和代码维护。

• 提高可读性：

函数重载使得代码更易读，因为相似功能的函数可以用相同的名字表示，不需要为每种功能选择不同的函数名。

• 代码复用：

可以通过重载减少重复的代码量，特别是在需要处理相似类型的数据时，可以重用相同的核心逻辑。
注意事项

• 参数列表必须不同：

函数重载依赖于参数列表的差异来区分不同的函数。如果两个函数只有返回类型不同而参数列表相同，这在 C++ 中是不合法的。
函数重载和默认参数的区别：

函数重载和默认参数是不同的概念。函数重载是通过不同的参数列表来区分同名函数，而默认参数是为函数的部分参数提供默认值，从而在调用函数时可以省略这些参数的赋值。

• 避免混淆：

当函数重载过多或者参数类型相差不大时，容易造成调用时的歧义和混淆，因此应根据需要和可读性适度使用。

• 可维护性：

过度使用函数重载可能会增加代码复杂性和维护成本，因此应在代码结构清晰和易于理解的前提下使用。

引用

在编程中，“引用”（Reference）是一个允许我们使用已存在变量的别名的机制。引用可以看作是变量的另一个名字，通过引用可以直接访问和操作原始变量的值。在 C++ 中引用有其独特的定义、使用方式以及价值与注意事项。

定义与使用

在 C++ 中，引用使用 & 符号来声明。例如：

int x = 10;
int &y = x;  // y 是 x 的引用

y = 20;  // 相当于修改了 x 的值为 20

cout << x << endl;  // 输出为 20

上述代码中，y 是 x 的引用，因此对 y 的修改实际上修改了 x 的值。引用在声明时必须初始化，并且一旦初始化后，就不能再改变指向的变量。

价值与优势

• 避免拷贝开销：

引用可以避免传递大对象时的拷贝开销，通过传递引用而非对象本身来提高效率。

• 函数返回值：

函数可以返回引用，允许返回函数内部创建的局部变量的引用，避免了对象的复制。

• 修改参数：

通过引用传递参数，可以在函数内部修改实参的值，从而实现函数对调用者的影响。

• 简化代码：

在某些情况下，使用引用可以简化代码结构，使代码更加清晰和易于理解。

注意事项

• 避免悬空引用：

引用必须始终指向有效的对象。如果引用指向一个已销毁的对象，会导致未定义的行为（悬空引用）。
初始化：

引用在声明时必须初始化，且不能改变引用的绑定（即不能指向其他对象）。

• 生命周期：

引用的生命周期必须小于或等于其所引用对象的生命周期，否则会出现悬空引用或者访问无效内存的问题。

• 传递对象：

传递对象时，如果不需要修改对象本身，可以使用常量引用 const 来避免意外修改。

常量引用

在 C++ 中，常量引用（const reference）是一种常见的用法，它允许我们在函数参数传递和对象声明中使用引用，同时确保被引用的对象不会被修改。常量引用通常用于以下几个方面：

定义
常量引用通过在引用声明时加上 const 关键字来定义，例如：

const int& ref = x;

这里 ref 是对 x 的常量引用，意味着不能通过 ref 修改 x 的值，但可以通过 ref 访问 x 的值。

示例
函数参数中使用常量引用

void printNumber(const int& num) {
    cout << "Number: " << num << endl;
}

int main() {
    int x = 10;
    printNumber(x);  // 通过常量引用传递参数 x
    return 0;
}

在上面的例子中，printNumber 函数接受一个 const int& 类型的参数 num，这意味着函数内部不能修改 x 的值，但可以安全地访问 x 的内容。

避免不必要的复制

void processVector(const vector<int>& vec) {
    // 对 vec 进行处理，但不修改其中的元素
}

int main() {
    vector<int> numbers = {1, 2, 3, 4, 5};
    processVector(numbers);  // 传递 vector 的常量引用
    return 0;
}

在这个例子中，processVector 函数接受一个 const vector& 类型的常量引用，这样可以避免将整个 vector 复制到函数内部，提高了效率和性能。

函数引用

在 C++ 中，函数引用通常指的是将函数作为参数的引用。函数引用作为参数传递给函数，可以允许函数直接修改调用者提供的变量，而不是对变量进行复制。这种技术在需要传递大对象或者需要修改参数值的情况下特别有用。

定义与声明
函数引用作为参数声明时，需要使用 & 符号来表示引用。例如：

void swap(int &a, int &b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;
    swap(x, y);
    cout << "x: " << x << ", y: " << y << endl;  // 输出为 "x: 10, y: 5"
    return 0;
}

在上面的例子中，swap 函数接受两个整数的引用作为参数，并交换它们的值。因为函数参数是引用，所以对 a 和 b 的修改会直接影响到 x 和 y 的值。

使用价值与优势

• 避免复制开销：

将对象通过引用传递给函数，避免了对对象进行复制，尤其在对象较大时能够提高效率。

• 直接修改参数：

函数可以通过引用直接修改调用者提供的参数，而不需要返回值或者通过指针间接修改。

• 传递对象：

对象通过引用传递给函数，函数可以修改对象的状态，这在需要修改对象状态时非常方便。

• 可读性与简洁性：

使用函数引用能够使函数调用更加直观和简洁，减少了对临时变量的需求，同时提高了代码的可读性

注意事项

• 生命周期管理：

引用作为参数传递时，需要确保引用的对象在函数调用期间是有效的，避免出现悬空引用问题。

• 引用和常量引用：

如果函数不需要修改参数值，可以使用常量引用 const 来避免意外的修改，同时加强函数的安全性和可维护性。

• 避免混淆：

在函数声明和定义时，正确地使用引用符号 & 是保证函数行为正确的关键。

内联

在 C++ 中，内联函数是一种特殊的函数形式，它的定义和使用可以有效提高程序的执行效率。下面详细解释内联函数的用法和定义。

内联函数的定义

内联函数是通过 inline 关键字定义的。在函数声明或定义前加上 inline，告诉编译器在每个调用点展开函数的代码，而不是像普通函数那样进行函数调用和返回操作。这种展开可以减少函数调用的开销，特别是对于一些简单的函数。

inline int add(int a, int b) {
    return a + b;
}

内联函数的使用场景和优势

• 减少函数调用开销：

内联函数可以避免函数调用时压栈、跳转和弹栈的开销，适用于简单的函数体或频繁调用的函数。
增加执行速度：

内联函数展开后直接嵌入到调用位置，可以减少执行时间，特别是在循环内部或对性能要求较高的代码中。

• 避免函数调用带来的额外开销：

对于短小的函数，内联可以减少因函数调用而引入的额外指令和内存访问。

• 提高代码的可读性和维护性：

内联函数通常定义在头文件中，这样可以使函数定义和声明更加紧凑和易于理解，方便代码的维护和修改。

注意事项

• 过度使用：

内联函数过于频繁使用可能会增加代码体积，影响缓存性能，应谨慎选择需要内联的函数。

• 函数体复杂度：

函数体过于复杂时，编译器可能不会选择将其内联，而是作为普通函数处理。

• 多文件编译：

如果内联函数定义在多个编译单元中，并且没有合适的优化设置，可能会导致链接器错误或多次定义错误。

示例

#include <iostream>

// 内联函数的定义
inline int square(int x) {
    return x * x;
}

int main() {
    int num = 5;
    std::cout << "Square of " << num << " is: " << square(num) << std::endl;
    return 0;
}

在这个示例中，square 函数被声明为内联函数，因为它只是简单地计算一个数的平方。在 main 函数中，调用 square(num) 时，编译器会尝试将 square 函数的代码直接插入到调用位置，而不是生成普通的函数调用。

总结来说，内联函数是一种通过减少函数调用开销来优化程序执行速度的方式，适合于简单的、频繁调用的函数。