C++语法基础(一）

第一个C++程序

1. `<iostream>`（C++）

<iostream> 是 C++ 标准库中的头文件，用于处理输入输出操作。它提供了基于流（stream）的输入输出机制。

特点：

面向对象：C++ 中的输入输出操作是基于流的，这种机制是面向对象的。流可以看作是字节序列的抽象，输入流从数据源（如键盘或文件）读取数据，输出流将数据写入目标（如屏幕或文件）。
常用的流对象：
- std::cin：标准输入流，通常与键盘关联，用于从用户输入读取数据。
- std::cout：标准输出流，通常与显示器关联，用于输出数据到屏幕。
- std::cerr：标准错误流，通常与显示器关联，用于输出错误信息。
- std::clog：标准日志流，用于输出日志信息。

2. `<stdio.h>`（C）

<stdio.h> 是 C 标准库中的头文件，用于处理输入输出操作。它提供了一些用于文件操作和标准输入输出的函数。

特点：

基于函数的输入输出：C 语言中的输入输出操作是基于函数的。常见的输入输出函数包括 printf、scanf、fprintf、fscanf、fgets、fputs 等。
低级别：与 C++ 的面向对象的流相比，C 的输入输出更为低级，操作更加直接。

//#include<stdio.h>
#include<iostream>int main(){// printf("hello world\n");std::cout << "hello world" << std::endl;return 0;
}

我们可以先暂时理解为endl 和 \n 一样，功能就是输出时换行，它们有一些重要的区别，endl 是 C++ 标准库中的一个操控符（manipulator），它不仅用于在输出流中插入一个换行符，还会刷新输出缓冲区（flush the output buffer）。这意味着，endl 会强制将缓冲区中的内容立即输出到目标设备（如屏幕），而不仅仅是插入一个换行符。对于作用限定符：：我们可以先简单地理解为什么中的什么。

命名空间

命名空间（namespace） 是 C++ 中用于组织代码的一种机制，它允许将代码分组到不同的命名空间中，以避免名称冲突，特别是在大型项目或使用多个库时。命名空间为变量、函数、类等标识符提供了一个作用域，可以防止不同命名空间中的标识符相互干扰。

代码演示

#include<iostream>
namespace ICBC{int g_money = 0;void pay(int money){g_money -= money;}void save(int money){g_money += money;}
}
namespace CCB{int g_money = 0;void pay(int money){g_money -= money;}void save(int money){g_money += money;}
}int main(){ICBC::pay(1000);ICBC::save(3000);CCB::save(10000);CCB::pay(2000);std::cout << "工行卡的余额:" << ICBC::g_money << std::endl;std::cout << "建行卡的余额:" << CCB::g_money << std::endl;
}

在使用命名空间后，相同名字的变量和函数并没有发生冲突

名字空间声明

代码演示

//名字空间声明
#include<iostream>
using namespace std;
namespace ns{int v_tomato = 10;
}
int main(){int v_tomato = 30;using ns::v_tomato; //从这行代码开始,ns中的内容引入当前作用域(相当于定义)//上面的定义会造成重定义报错v_tomato = 20;  cout << "ns::v_tomato = " << ns::v_tomato << endl;return 0;
}

因为所有标准库提供的类型、对象和函数都位于std名字空间中，所以我们在使用using namespace std;后，就可以对输出代码的写法进行简化,省略std::

代码分析

编译器在编译每一个函数时都会构造两张表，在编译这个函数（main函数）结束后销毁。在函数体内定义的变量会放进定义表，对于函数体外定义的对本函数可见的变量会放进可见表。对于本例，使用名字空间声明也相当于在这个函数体内定义了这个变量，又因为函数体内先前已经定义了这个变量（int v_tomato=30），此时的名字空间声明会造成重定义，这是编译器绝对不允许的，因此会报错。当在函数内使用某个标识符时，如果存在同名，编译器需要确定你使用的是哪一个标识符，因此他会拿着这个名字先在定义表中查看，如果定义表中找不到，才会到可见表中找。

名字空间指令（using namespace [...]）

名字空间指令是指使用 using namespace 语句将整个命名空间引入当前作用域。这意味着命名空间中的所有标识符都可以直接使用，而不必再通过命名空间限定符来引用。这种方式在简化代码的同时也可能带来名称冲突的风险，尤其是在大型项目中。

代码演示

//名字空间指令
#include<iostream>
using namespace std;
namespace ns{int v_tomato = 10;
}
int main(){using namespace ns; //从这行代码开始,ns中的内容在当前作用域中可见//ns::v_tomato = 20;v_tomato = 20;//std::cout << ns::v_tomato << std::endl;cout << "ns::v_tomato = " << ns::v_tomato << endl;return 0;
}

在上面的代码中，using namespace ns; 是一个名字空间指令，它将 ns1命名空间中的所有标识符引入到 main 函数的作用域中，因此你可以直接使用 v_tomato 而不需要在前面加上 ns::。

代码分析（不同于上个代码）

对于本例，代码的输出结果依然是10，我们来分析一下。main函数内的int v_tomato = 10，这是一个放在定义表的局部变量，而对于ns命名空间的int v_tomato = 10是放在可见表中的。当出现v_tomato = 20这个变量，编译器需要确定究竟是这两个同名变量中的哪一个，编译器会先在定义表中寻找，此时他找到了就不会查看可见表，因此v_tomato = 20修改的是main函数内定义的局部变量而不是ns命名空间的同名变量。这也就是最后我们的输出结果依然是v_tomato = 10的原因，因为它实际上并没有修改我们ns命名空间中的这个变量。

名字空间指令和名字空间声明的差别

使用名字空间指令会让所指定命名空间的内容在当前作用域中可见，其中定义的变量会被放入可见表中，而使用名字空间声明会让所指定命名空间中的内容引入当前作用域(相当于定义)，其中定义的变量放入定义表中

代码演示

//名字空间指令 和 名字空间声明 的差别
#include<iostream>
using namespace std;
namespace ns1{int g_money = 10;int g_other = 10;
}
namespace ns2{int g_money = 10;int g_other = 10;
}
int main(){using namespace ns1;//ns1中的所有内容都出现在可见表中using ns2::g_other;//只有ns2::g_other出现在定义表中g_money = 100;//修改的是ns1中的g_moneycout << "ns1::g_money = " <<ns1::g_money <<", ns2::g_money =" << ns2::g_money <<endl;g_other = 100;//修改的是ns2中的g_othercout << "ns1::g_other =" << ns1::g_other <<", ns2::g_other =" << ns2::g_other <<endl;return 0;
}

命名空间的嵌套

在C++中，嵌套命名空间的同名变量不冲突，因为每个变量在其所属的命名空间中都有唯一的作用域。变量的名称相同，但由于它们位于不同的命名空间中，编译器可以通过命名空间限定符（如ns1::ns2::g_money）来区分它们。因此，它们不会冲突。

//命名空间的嵌套
#include<iostream>
using namespace std;namespace ns1{int g_money = 10;namespace ns2{int g_money = 20;namespace ns3{int g_money = 30;namespace ns4{int g_money = 40;}}}
}int main(){//名字空间别名可以简化书写namespace ns_forth = ns1::ns2::ns3::ns4;//cout << ns1::ns2::ns3::ns4::g_money << endl;cout << ns_forth::g_money << endl;
}

扩展

我们说使用名字空间声明引入的变量相当于定义在main函数中的变量，那他们有什么区别？

在C++中，namespace中的变量（如ns::v_tomato）通常具有进程级生命周期

1. 进程级生命周期的定义

进程级生命周期的变量从程序开始执行（通常是在程序的初始化阶段）到程序结束时一直存在。
这些变量通常分配在全局/静态数据区中，生命周期贯穿整个程序的运行过程。

2. `namespace`中的变量的生命周期

namespace ns { int v_tomato = 10; }：
- 这里的v_tomato是在命名空间ns中定义的全局变量。
- 虽然它被封装在namespace中，但它的本质仍是一个全局变量。

特点：

存储位置：v_tomato会存储在全局/静态数据区中，而不是栈或堆中。这意味着它在程序的整个生命周期内都存在。
生命周期：从程序启动时开始（即在main()函数执行之前），直到程序终止时结束。因此，它具有进程级的生命周期。
作用范围：虽然v_tomato的作用范围被限制在命名空间ns中，但它仍然是一个全局变量。这意味着在程序的任何地方，只要通过ns::v_tomato访问，它都可以被引用和修改。

3.示例分析

#include <iostream>namespace ns {int v_tomato = 10; // 进程级生命周期的变量
}int main() {std::cout << "v_tomato = " << ns::v_tomato << std::endl; // 输出 10ns::v_tomato = 20;std::cout << "v_tomato = " << ns::v_tomato << std::endl; // 输出 20return 0;
}

在这个示例中：