初步入门C ++之类的概念

0 Hello World!

#include <iostream>														//相当于#include <stdio.h>

int main(int argc, char argv[])
{
  char				c;
  
  std::cout << "Hello World!\n" << std::endl;	//std是一个标准库的命名空间，cout是其中的一个对象，代表标准输出流。
  																						//::表示作用域解析运算符(scope resolution operator)。			  																						 	    它用于访问某个命名空间或类中的成员。
  c = std::cin.get();
  std::cout << "You entered: " << c << std::endl;
  return 0;																				
}

1 编译过程

​ 编译分为预处理，编译，汇编，链接四个基本过程，他们的作用如下：

1. 预处理：预处理由预处理器 CPP 完成，它会将 .c 文件预处理为 .i 文件( .i 文件的本质还是一个 .c 文件)。预处理就是将预处理命令，宏等进行简单的展开和替换。预处理会将 #define 宏定义替换展开后删除，判断条件编译，将 #include<> 头文件复制粘贴进来，同时删除注释，添加行号和文件标识，还会保留 #pragma 编译器指令。

2. 编译：编译由编译器 CC 完成，它会将 .i 文件变为 .s 文件。编译器首先会检查语法规则，然后将 C 语言翻译为等效的，优化后的汇编语言，我们语言的可移植性也从这里体现，对于不同的平台，我们只需要选择不同的编译器即可，这样，同一个 C++ 语言源代码，就能生成在不同平台上的汇编语言文件。(Ps：编译器的优化等级并不是越高越好，我们常用的配置是 OS，它约等于 O2 等级)。

3. 汇编：汇编由汇编器 AS 完成，它会将 .s 文件汇编为 .o 文件( windows 下是 .obj 文件)。汇编就是将汇编语言转化为对应的二进制文件，也称目标文件，目标文件至少有代码段和数据段两段组成。

4. 链接：链接由链接器 LD 完成。它会将 .o 目标文件通过链接变为 ELF 文件，即可执行文件。链接会将动态库或者静态库与本文件进行链接，我们在 #include<头文件> 的时候，头文件中只有函数的声明信息，那么函数体在哪里找呢，没错，就是在动态库和静态库里，而将这些库，声明联合到一起的过程，便称之为链接，链接是通过函数的签名来找到对应的函数体的，同时main函数的入口也是在这个时候确定下来的。

2 类

2.1 类的概念

​ 简单来说，类是一种数据类型，其实就是数据与函数的结合体，在 C 语言中，若我们需要计算多个矩形的面积，我们一般会定义多个矩形的数据，然后调用相应的函数来计算他们：

int area(int x, int y)
{
  area = x * y;
  return area;
}


int main(int argc, char* argv[])
{
  	int x1,y1,area1;
  	int x2,y2,area2;
  	int x3,y3,area3;

    x1 = 2;
    y1 = 5;
    area1 = area(x1, y1);
    printf("area1:%d", area1);

    x2 = 4;
    y2 = 20;
    area2 = area(x2, y2);
    printf("area2:%d", area2);

    x3 = 30;
    y3 = 1;
    area3 = area(x3, y3);
    printf("area3:%d", area3);
}

但是在面向对象编程中，当我们有了类的概念后，就可以将数据与函数集合起来管理，如下：

#include <iostream>

class rect
{
public:				//类默认的变量是private私有的，为了让外面可以访问，我们使用使用public公开这些变量。
    int     x;
    int     y;
    int     area;

    void area_printf()
    {
        area = x * y;
        std::cout << area << std::endl;	
        return;
    }
};

int main(int argc, char* argv[])
{
    rect rect1,rect2,rect3;

    rect1.x = 2;
    rect1.y = 5;
    rect1.area_printf();

    rect2.x = 4;
    rect2.y = 20;
    rect2.area_printf();

    rect3.x = 30;
    rect3.y = 1;
    rect3.area_printf();
}

//我们解读一下这段代码：

1. 定义一个类 rect ，其中包括 x，y，area 数据和一个 void area_printf() 的方法
2. 可以看到该方法中需要 x，y，area 数据，但是我们并没有用形参传入 void area_printf，但是为什么可以正常运行呢？
3. 因为这个类已经包含了这三个数据了，所以可以直接使用。
4. 也就是说，我们每声明一个新的 rect 类，就会自动生成对应的 x，y，area 数据。在这个类里面的函数，也就是“方法”，就可以使用这些数据了，这也是为什么我们说，类其实就是，数据和函数的结合体。

2.2 构造函数与析构函数

​ 之前我们了解到，在类中我们可以创建不同的函数，即不同的“方法”。那我们现在来思考一个问题，当我们创建一个新的类时，若里面有很多的数据需要初始化，我们可以写一个初始化的方法然后调用它，但是显然当类的数量多起来的时候，代码就会显得冗余了，但是c++为我们提供了构造函数与析构函数，构造函数会在类被创建时自动执行，这样就免去了我们调用它的过程，反之，当一个类被销毁时，我们往往需要释放其中 malloc() 的内存。那么在类被销毁时，自动调用的函数，就称为析构函数。

#include <iostream>

class rect
{
public:
    int     x;
    int     y;
    int     area;

    //以下是两个构造函数
    rect()	//构造函数不需要返回值，也可以没有参数，创建 rect1,rect2,rect3 时会自动创建
    {
        x = 0;
        y = 0;
    }
    rect(int x_input, int y_input)	//重载构造函数，即同名的函数，参数不一样
    {
        x = x_input;
        y = y_input;
    }

    void area_printf()
    {
        area = x * y;
        std::cout << area << std::endl;
        return;
    }

    //以下是析构函数
    ~rect()
    {
        std::cout << "This Class Has Clean" << std::endl;
    }
};

void test_function()
{
    rect rect1;
    rect rect2(2, 4);
    rect rect3(11, 9);

    rect1.area_printf();
    rect2.area_printf();
    rect3.area_printf();

}//当函数退出时，创建的类会被销毁

int main(int argc, char* argv[])
{
    test_function();
    return 0;
}