# 1.本周收获总结
下面分享我在本周通过学习所收获到的知识
## 1.1 C++中生成可执行文件的过程
### 1.1.1 预处理
源代码首先经过预处理器处理。预处理指令(#include,#define等)在这一步被执行。预处理器会展开所有的宏定义、处理条件编译指令，并将所有的#include指令替换为相应的头文件内容。预处理后的代码不再包含这些预处理指令。
作用：防止头文件被循环展开而产生编译错误；有助于减少重复代码和提高**代码复用**性。
### 1.1.2 编译
经过预处理后的代码会被传递给编译器。编译器将源代码转化成汇编语言。在这一步中，编译器会进行语法分析、语义分析、优化等处理。编译的结果是汇编代码，通常保存为.s文件。
作用：编译器在这个过程会检查语法、类型匹配等问题，**如果发现错误，编译器会报告并终止编译过程**；编译过程还包括**优化代码**，例如删除无用代码、循环展开等，以**提高程序运行时的性能**；
### 1.1.3 汇编
汇编器将汇编代码转换成机器代码(二进制指令)，对应于特定的处理器架构。汇编的结果是目标文件(Object File)，通常保存为.o或.obj格式。
作用：将源码转换为机器语言代码**使得程序能够在特定的硬件平台上运行**。汇编过程使编译过程与目标平台的底层硬件实现解耦，**提高了编译器的可移植性**。
### 1.1.4 链接
如果程序包含了多个源代码文件，或者使用了外部库，链接器会将所有目标文件及所需要的库文件合并成一个单一的可执行文件。链接器的主要工作就是将有关的目标文件彼此相连接，也就是将一个文件中引用的符号，同该符号在另外一个文件中的定义连接起来。在链接过程中，链接器解决了程序中的符号引用问题，比如函数和全局变量的地址。链接的最终产物是可执行文件。Windows系统中通常是.exe文件。
作用：链接过程允许将程序分割成多个独立的源代码文件和库文件，便于**模块化开发、代码重用和程序维护**。
## 1.2 第一个简单的C++程序
```
#include <iostream> //编译预处理命令 
using namespace std; //使用命名空间 
int add(int a,int b); //声明add函数 
int add(int a,int b) //定义add函数 
{  
 return a+b;  
};  
int main()  //主函数，程序入口
{   
 int n,m; //定义两个变量  
 cout << "Hello, World!" << '\n';  
 cout << "GO Clippers" << endl;  
 cout << endl;  
  
 cout << "Please enter two number :" << endl; //输出  
 cin >> n >> m; //输入两个变量  
 int sum = add(n,m);  
 cout << "The sum is:" << sum << endl;  
 return 0;  
}
```

### 1.2.1 头文件与源文件
一、头文件
作用：将可以被多个.cpp文件使用的函数或方法统一封装在一个文件中，当其他.cpp文件需要使用这个变量或函数时，通过#include将其包含进来就可以。

原因：这里涉及到c++++的编译模式，头文件是不被编译的，只有源文件（.CPP）文件才会被编译，当然也可以说头文件和包含他的源文件一起编译，所以为了方便这些函数的多次复用和契合c++++的分别编译，就可以将这些变量和函数放在.h文件中，谁需要用谁就#include下就可以了。

使用：头文件中写些变量声明了，函数声明了，类的定义了之类的，具体的可以查看文末引用的文献，那里面讲的详细。

引用：系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找。用户自定义的头文件用双引号括起来，编译器首先会在用户目录下查找，然后再到c++安装目录下查找，最后在系统文件中查找。

二、源文件

.CPP文件，称为c++ ++源文件，里面放的都是c++++的源代码。.cpp文件里面的东西都是相对独立的，在编译（compile）时不需要与其他文件互通，只需要在编译成目标文件后在与其他的目标文件做一次链接（link）就行。比如，在文件a.cpp中定义一个全局函数“void a(){}”，而在文件b.cpp中需要调用这个函数。即使这样，文件a.cpp和文件b.cpp并不需要互相知道对方的存在，而是可以分别的对他们进行编译，编译成目标文件之后再链接，整个程序就可以运行了。

### 1.2.2 #include指令
#include的两种方式，分别为：

<1>#include<header.h>
这种形式用于包含标准库头文件或者项目特定的头文件，但不是当前源文件所在的目录。
编译器首先会在系统头文件目录中查找该头文件，这些目录通常由编译器的配置指定。
如果在系统头文件目录中找不到，编译器可能会尝试在用户指定的其他目录中查找。
这种方式不会在当前源文件所在的目录中查找头文件。

<2>#include"header.h" 或 #include"header"：
这种形式用于包含与源文件位于同一目录下的头文件，或者项目内部的头文件。
编译器首先会在当前源文件所在的目录中查找头文件。
如果在当前目录中找不到，编译器会按照包含标准库头文件的方式去查找。
这种方式通常用于项目内部的头文件，以避免与系统头文件发生命名冲突。

总结来说，#include<>主要用于包含**标准库头文件和系统级别的头文件**，而#include""主要用于包含**项目内部的头文件**。正确使用这两种形式可以帮助编译器更快地找到头文件，并减少不必要的搜索，从而提高编译效率。
### 1.2.3 宏定义
第一种方式
```
#include <iostream> 
#define A 10 
using namespace std;  
  
int main()  
{  
 cout << A << endl;  
 return 0;  
}
```
第二种方式
```
#include <iostream> 
#define SQUARE(x) x * x  
using namespace std;  
  
int main()  
{  
 cout << "SQUARE(5): " << SQUARE(5) << endl;  
 cout << "SQUARE(5 + 1): " << SQUARE(5 + 1) << endl;  
 // 宏展开为 5 + 1 * 5 + 1，这里会得到错误的结果 11  
 return 0;  
}
```

### 1.2.4 命名空间
C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称都存在于全局作用域中，可能导致很多冲突。这时候就使用到了命名空间，目的是对标识符的名称进行本地化，避免命名冲突。
定义一个命名空间：
```
namespace mynamespace
{
    int a;
    int b;
}
```
使用命名空间的方式：
(1)加作用域限定符(指定命名空间)
编译器若要查找一个函数，它的**默认查找的顺序是：先局部，再全局域**。它不会主动到命名空间去找，除非我们加上作用域限定符之后才会进去查找。
```
#include <iostream> 
namespace firstnamespace
{  
 int a=1;  
}  
namespace secondspace
{  
 int a=2;  
} 
 
int main() 
{  
 int a=0;  
 /**  
 * 加上作用域限定符后才会去指定的命名空间查找  
 */  
 std::cout << a << std::endl;  
 std::cout << firstnamespace::a << std::endl;  
 std::cout << secondspace::a << std::endl;  
 return 0;  
}
```
此时会输出：
```
D:\Local\workplace\Test1\cmake-build-debug\Test1.exe
0
1
2
Process finished with exit code 0
```
(2)直接展开命名空间
当我们需要重复调用一个命名空间里面的函数时，每一次调用我们就需要指定一下命名空间，多少有点麻烦。我们可以使用下面一条语句：

```
using namespace firstnamespace;
```
代码如下：
```
#include <iostream> 
namespace firstnamespace
{  
 int a=1;  
}  
namespace secondspace
{  
 int a=2;  
}  
using namespace firstnamespace;  
int main() 
{  
 std::cout << a << std::endl;  
 std::cout << firstnamespace::a << std::endl;  
 std::cout << secondspace::a << std::endl;  
 return 0;  
}
```
运行结果为：
```
D:\Local\workplace\Test1\cmake-build-debug\Test1.exe
1    //通过展开命名空间访问a属性
1
2
Process finished with exit code 0
```
这时查找的优先级会变成：**局部>全局=命名空间**。在全局和命名空间同时存在同名函数或变量时,展开了命名空间之后，**相当于把命名空间里面的东西释放到了全局中**，如果之前全局域中存在了同名函数，那么就会报错。
(3)展开指定成员

```
#include <iostream> namespace firstnamespace
{  
 int a=1;  
 int b=13;  
}  
namespace secondspace
{  
 int a=2;  
}  
using firstnamespace::a;  
int main() 
{   
 std::cout << a << std::endl;  
 std::cout << a << std::endl;  
 std::cout << firstnamespace::a << std::endl;  
 //因为只展开了命名空间的a属性，在使用b属性时仍需通过作用域限定符指定  
 std::cout << firstnamespace::b << std::endl;  
 std::cout << secondspace::a << std::endl;  
 return 0;  
}
```
以上代码的运行结果为：
```
D:\Local\workplace\Test1\cmake-build-debug\Test1.exe
1    //展开命名空间firstnamespace的a属性
1    //展开命名空间firstnamespace的a属性
1    //通过作用域限定符指定firstnamespace的a属性
13    //通过作用域限定符指定firstnamespace的b属性
2    //通过作用域限定符指定secondnamespace的a属性

Process finished with exit code 0
```

这种方法解决了直接展开命名空间时可能会引起的命名冲突的问题。

## 1.3 C++基础
在C++中，我学习了一些基础语法，并且我对与Java不同的部分进行了总结。
[变量与常量](http://192.168.6.130/wiki/#/view/20/1415)
[指针](http://192.168.6.130/wiki/#/view/20/1418)
[函数](http://192.168.6.130/wiki/#/view/20/1434)
[结构体](http://192.168.6.130/wiki/#/view/20/1464)