README.md · aqs-dwr/training_22

# 常量与变量
## 1.常量

### 1.1 数字常量

（如1,3.1415926,-1e7)

### 1.2 字符常量

(如 'a' 'c' 'b' '\0x41' '\253')

转义字符（符号）：
以\（反斜杠）开头的字符序列，会将反斜杠
之后的内容解释成其他含义而不是字符本身

常用的转义字符如下：
- \n 换行
- \t 水平制表（相当于tab）
- \b 退格（删除一个字符）
- \\\\ 输出反斜杠本身
- \0xhhh 或 \xhhh 输出十六进制ASCII码所代表的值
- \ddd 输出八进制ASCII吗所代表的值
- \\\" \\\' 输出单引号或双引号本身
	
### 1.3 字符串常量

（如 "abc", "a", "","abc cba")

注意：'a'表示的是字符常量，而"a"表示的是字符串常量

### 1.4 符号常量
（在预编译时符号常量会被替代）

例如：声明符号常量MAX：#define MAX 10086
那么在之后编译的过程中，代码中出现的MAX都会被替换成10086 
	
## 2.变量
### 2.1 变量类型
- int（整型，占4字节） 
- short（短整型，占2字节）
- long long（长整型，占8字节）
- char （字符型，占1字节）
- float (单精度浮点类型，占4字节）
- double (双精度浮点类型，占8字节）
- bool （布尔类型，只有 true 和 false 两个值, 占1字节） 
	
**了解一下** 
- char *(字符串类型，占n+1字节，n为字符串长度） 
- std::string （C++提供的字符串类型，占据空间不直观看出来）

### 2.2 变量声明和定义
- int a;（声明一个整型变量a）
- float a;(声明一个单精度浮点型变量a）
- 其他类型同理

如果要给变量赋初值的话，在变量后面加上 = 就行

例如：
- int a=1; （声明整型变量a并赋初值1）
- float a=1.0 (声明单精度浮点变量a并赋初值1.0)
- char c='a' (声明字符型变量并附初值'1')

### 2.3 常变量

在程序运行时常变量的值不会改变
声明: 在类型关键字前加上const关键字
例如：
- const double pi=3.1415926535897932384626433832795;
- const double e =2.718281828;
- const int MAX = 10086;

### 2.4 变量的运算
#### 2.4.1 算术运算符
>+，-，*，/，%，++，--

#### 2.4.2 关系运算符
> \>, <, >=, <=, ==, !=

#### 2.4.3 逻辑运算符
> &&, ||, !

#### 2.4.4 数学运算函数（在cmath库中）
>sin/cos/tan(x)
asin/acos/atan(x) 反三角函数
pow(x,y) x的y次幂
sqrt(x)  x的开方（等价于pow(x,1/2)）
	...
#### 2.4.5 复合运算符
>   a+=x =>(等价于) a=a+x
	a-=x => a=a-x
	a*=x => a=a*x
	a/=x => a=a/x
	a%=x => a=a%x
	特别地： 
	a+=1 => a++ => a=a+1
	a-=1 => a-- => a=a-1

# 程序设计基础
## 0.计算机具备的5项基本功能：

赋值，加，跳转，输入，输出

## 1.基本的输入和输出 
### 1.1 输入 
C语言，scanf()函数

C++， std::cin>>(...)>>(...);

### 1.2 输出

C语言，printf()函数
	
C++， std::cout<<(...)<<(...)

演示程序：
```c++
//分别用 C 和 C++ 的方式进行输入和输出
#include <iostream> //C++ 输入输出头文件
#include <stdio.h>  //C 语言输入输出头文件

int main(){
    int a,b;

//C++
    std::cin>>a;
    std::cout<<a<<std::endl;

//C
    scanf("%d",b);
    printf("%d\n",b);

return 0;
}
```

演示说明：
对于scanf和printf来说，系统需要通过%后面的字符来判断数据类型。常用的类型有: 
- %d 十进制整数
- %lld 十进制长整型整数 
- %.xf（%f） 保留x位的单精浮点型 .x可省略
- %.xlf(%lf)  保留x位的双精浮点型 .x可省略
- %c 字符类型
- %s 字符串类型
	
对于std::cin 和std::cout来说，系统会自动判别需要输入（输出）的变量类型。因此只需要std::cin>> std::cout<<即可。

除此之外，C++还提供了std::endl作为换行 std::cout<<std::endl => std::cout<<"\n" => printf("\n")

虽然C++的输入输出看起来更加方面，但是花费的时间是C语言的3倍，且在进行小数点控制很不方便（书本中格式控制的部分有讲）

## 2.条件控制语句（只讲if-else）
```c++
if(判断条件1)
{
	如果条件1满足，执行这一部分的代码
	否则跳过这一部分的执行 
}
else if(判断条件2)
{
	如果条件1不满足，会进行条件2判断
	如果条件2满足，执行这一部分代码
	否则跳过这一部分执行
	可省略 
} 
else if(...)
{
	同理 
}
else
{
	当所有条件都不满足时，会执行这一部分的代码
	可省略 
}
```

if-else 可以嵌套，书上有，这里只演示一下，不讲

## 3.循环语句(只讲while for）
### 3.1 while
当条件满足时就执行循环体里面的内容，条件不满足时自动退出循环体
```cpp
while(条件) {
    当条件满足时，则会执行这一部分的代码。
    执行完毕后再次判断条件是否满足，若满足则重复上述步骤
    不满足则退出循环体
}
```
### 3.2 for
```c++
for(语句1;条件1;语句2){}
```
1. 在初次进入循环体时会执行语句1
2. 之后进行条件1判断，若为真则继续执行循环体
3. 单次循环执行结束后，会执行语句2，再进行条件1判断，若为真则继续执行循环体
4. 重复执行步骤3，直至条件1不满足时自动退出循环体

## 3.3 循环控制（break 和 continue）
break: 直接跳出当前的循环
continue:  跳过循环体之后的语句，直接开始下一次循环

# 作业1
1.输出以下图案
```
*** * * *** *** *** *** ***
*   * *  *    * * *   *   *   
**  ***  *  *** * * *** ***
*    *   *  *   * * *     *
*    *   *  *** *** *** ***

2.输入一个华氏温度，输出其摄氏温度，公式为C=(5/9)*(F-32)
  要求保留两位小数
 
3.求解一元二次方程ax^2+bx+c=0(a!=0)，不考虑同根或无根情况 
  要求输入a,b,c 输出x1 x2，保留三位小数 
   
4.给出一个百分制的成绩，要求输出成绩等级A~E。
	90以上为A 80~89为B 70~79为C 60~69为D 59以下为E

5.输入3个整数，按由小到大的顺序输出

6.输入两个整数，求出他们的最大公因数和最小公倍数
	（提示，用辗转相除法）
	
7.输出所有的水仙花数
	水仙花数：指一个三位数整数，每位数字的立方之和等于这个数本身
	例如153是一个水仙花数，因为1^3+5^3+3^3=153

8.求解一元二次方程ax^2+bx+c=0(a!=0)，需要判断同根或无根情况 
  要求输入a,b,c 输出x1 x2（x1!=x2)
  					x1=x2=(x1==x2)
					no root(无根情况) 
保留七位小数

9.输出1000以内的完全数
	完全数：该数除自身外的所有因子之和等于这个数本身
	例如：6的因子有1,2,3，1+2+3=6 因此6是一个完全数

10.用枚举法求解三阶幻方
	三阶幻方：将数字1~9填入一个3*3的方格中，使得每行每列
			  以及对角线三个数之和都相等。每个数字只能填
			  一次。
		例如  4 9 2
			  3 5 7
			  8 1 6
	答案不止这一个，要求输出所有的答案 
```

# 函数
## 1.函数是什么
高中数学：函数是一种映射关系，表现形式是一个数学表达式在给定一个自变量后经过数学表达式的计算得到一个新的值，即函数值。例如 f(x)=x^2 给定x=1,f(x)就=2；给定x=4，f(x)就=16
			  
高等数学：函数的自变量可以有n个，其它定义与高中数学相同

以n=2举例，有这么一个函数f(x,y)=xy，给定x=1,y=2;那么f(x,y)=2；给定x=3,y=5，那么f(x,y)=15

C语言：函数是可以用于实现一项或多项功能的代码模块，有输入参数和返回值。输入和返回值可以省略其一，也可以都省略 
	
## 2.函数声明以及定义
### 2.1声明

声明函数首先要指定函数的返回值类型。返回值类型跟变量类型一样，但是多了一个void类型表示函数没有返回值
	
声明函数的第二步是命名函数名。跟变量名一样，可以自己命名
	
声明函数第三步是指定传入的参数类型和在函数体中的变量名，变量之间用逗号隔开
	
声明函数第四步，在结尾加上分号。
	
至此，我们完成了函数的声明
	
### 2.2定义

函数的定义是最关键的部分，主要就是实现函数的功能
	
函数定义的前三步与声明相同
	
定义第四步，编写函数体，用大括号括起来，为函数的执行语句
	
至此，函数的定义也就完成了
	
>通常情况下，定义就包括了声明。
在定义函数前，一定要先构思好要用函数来实现什么功能,同时要想好传入的参数和传出的参数是什么类型，表示什么意思。这一点在编程中慢慢体会
	
举例：
- 定义无返回值，有两个输入参数 
- 定义返回值为float，有一个输入参数
- 定义无返回值，无输入参数

```c++
//定义无返回值，有两个输入参数 
void func1(int a,int b){
    ...//函数体
}

//定义返回值为float，有一个输入参数
float func2(int a){
    .../函数体

return (float);//返回一个float类型的值
}

//定义无返回值，无输入参数
void func3(){
    ...//函数体
}
```

### 2.3 函数的调用
函数调用格式如下：
```
函数名(参数1，参数2，...）
```	
如果函数有返回值，那么可以定义一个类型与函数返回值相同的变量a,用
```
a=函数名(参数1，参数2，...）
```
将函数的返回值赋给a 。函数体本身也带有函数的返回值 
	 
## 3.函数的嵌套调用：
>说白了就是函数A调用函数B，函数B调用函数C，......
	
## 4.函数的递归调用
这里不讲，简单来说就是我调我自己

## 5.内联函数
在编译器编译时会用函数的代码直接替换掉调用的语句，使得调用时不再需要跳转，增加执行速度。适用于需要经常调用的函数
	
在声明或定义时在函数的返回值类型前面加上inline关键字即可

注：递归调用的函数不能声明为内联函数
	
## 6.函数的默认值 
函数在声明的时候参数可以带有默认值，在调用的时候可以缺省相应传入的参数。如果没有参数传入，函数就以默认值带入；如果有参数传入，函数就会以传入的参数带入。

注意：带有默认值的参数右边的所有参数均不能不带默认值，否则会报错
	
例如：
```c++
int func(int a,int b=0,int c=1); //正确 
int func(int a=0,int b,int c);
//报错，因为a带默认值而a右边的参数b，c没带默认值
```

# 数组
## 1. 一维数组
### 1.1 一维数组的声明
**类型名 数组名[常量]**
如：
```c++
int a[10];
```
表示数组名为 a，长度为10（下标取值为0~9）

在最新的编译器中，可以使用变量指定数组的长度。即如下声明也是合法的：
```c++
int n=10;
int a[n];
```

### 1.2 一维数组的使用

例如，我们要得到以下一段序列{0,1,2,3,4,5,6,7,8,9}

那么可以用以下两种方式进行赋值：

```c++
//method 1
int a[10]={0,1,2,3,4,5,6,7,8,9};

//method 2
int a[10];
for(int i=0;i<10;i++){
	a[i]=i;
}
```

### 1.3 二维数组和多维数组

二维数组的声明如下：
```c++
int a[10][10];
```
多维数组同理，其余与一维数组类似。

# 练习2
```
1. 编写一个输入参数为n，返回值为n!的函数，并调用

2. 利用数组保存斐波那契数列的前 100 项和

3. 编写一个函数，用于判断某个数是不是质数。如果是则返回true,否则返回false
   之后利用这个函数，证明哥德巴赫猜想在1000以内都是成立的
   即，输出6-1000中所有的偶数可以写成哪两个质数和
   例如6=3+3
   	   8=3+5
	   10=3+7 
（提示：可以先求出1000以内的素数保存在数组中，再到这个数组中寻找两个素数之和恰好为这个偶数）
```

# 指针与引用
## 1.引用
### 1.1 关于值与地址
以仓库中的货物储存为例，值指的是这个货物是什么，包括类型以及数量，而地址则表示这个货物具体存放的位置。

对于计算机中，也是这个概念。变量值存放的位置也就是变量的地址。如何知道变量存放的地址呢？这就是引用的概念。
	
如下，我们定义一个整型变量
```c++
int a;
```
那么，a 表示的就是a的数值，而 &a 则表示 a 数值的存地址，在计算机中通常以16进制表示。

& 符号也称为引用符号 （或者叫取址符号）

运行以下代码，查看效果：
```c++
int a=1;
std::cout<<a<<" "<<&a;
return 0;
```
由此便知道了为什么scanf函数中的变量要使用&符号 
	
对于数组而言，数组名即为首元素的地址。且由于数组在内存中是连续存储的，所以给首元素的址加上几就是第几个元素的位置

即：
```c++
int arr[maxn];
//arr => &arr[0]
//arr+i => &arr[i]
``` 
	
## 2.指针
指针变量用于存储对应变量的地址信息
指针的声明如下：
```c++
int *p; //表示声明一个int类型的指针变量 
p=&a;   //将a的地址赋给指针p
```

访问指针指向地址的值：
```c++
std::cout<<*p //输出的指针p指向区域的值 
```
有以下声明：
```c++
	int *p;
	int a;
	p=&a;
```
说明p是________, a是_______(填 指针变量、普通变量)
	
有下列关系:
- p  &a  表示地址
- *p  a  表示值 
		
## 3.指针与引用的应用 
有如下函数
```c++
void double_num(int x, int y){
	y=x*2;
}
```
在主函数中调用
```c++
int main(){
	int a=2,b=0;
	double(a,b);
	std::cout<<b;
} 
```
会惊奇地发现b的值没有变化！这是为什么呢？这跟C语言的函数调用机制有关 、

函数调用时，C会把传入的参数复制一份，供调用的数使用。函数在对变量进行操作时，操作的只是参数的副本。在函数结束后，副本被回收，被修改的参数无法传回函数，导致变量值不变。

那怎么办呢？ 用指针！

把函数写成如下形式
```c++
void double_num(int x, int *y){
	*y=x*2;
} 
int main(){
	int a=2,b=0;
	int *p=&b;
	double_num(a,p);
	std::cout<<b;	
}	
```

可是不想用指针怎么办呢？（指针太麻烦了）
还有一种写法，如下： 
```c++
void double_num(int x, int &y){
		y=x*2;
} 
int main(){
	int a=2,b=0;
	double_num(a,b); 
	std::cout<<b;	
}
```

函数中声明为引用表示对变量起别名（这么说好理解些）

以上面的例子，变量b在main函数里面叫b，在函double_num里面叫y，但是它是同一个变量。

就好比一个人叫张三，朋友们都叫她三姐，父母叫她三，男朋友叫她三三，但这都指的是一个人（你们抓鲁迅关我周树人什么事QAQ）

言归正传。引用的方法不只是能够让传入的变量有能发生改变，同时还不需要复制内存。对于目前常见的变量类型，如int double，复制所占用的空间和时间基本上可以忽略不计。但是对于一些大的数据类型（如一张图片）复制时所需
的时间和空间开销就会显得尤为明显。因此，在以后编程中，参数的传递建议使用引用传递。

如果不想让传入的参数发生改变，例如在做学生信息理系统时，学生的学号是很关键的信息，不能发生改变。这个时候只需要在传参数的类型前加上const关键字即可。以上面的例子修改：
```c++
void double_num(int x, const int &y){
		y=x*2;
	} 
int main(){
	int a=2,b=0;
	double_num(a,b); 
	std::cout<<b;	
}
```
那么这样是没办法通过编译的。因为在 double_num 函数中修改了 const 修饰的变量值。但是依然有方法可以修改 y 的值，但这样就失去了 const 修饰的意义。这里就不讲了，感兴趣的话可以自己研究一下。
	
# 字符串
## 1. C语言中的字符串：
字符串，顾名思义，是由字符组成的串，因此本质上是char类型的数组。

字符串由双引号引起，例如"Hello world'\0'"

字符串跟字符最大的区别在于，字符串结尾有一个'\0'符号表示串结束
   
- 字符串定义：char str="Hello World"
   
- 字符串输入：scanf("%s",str); or std::cin>>str;

- 字符串输出：printf("%s",str); or std::cout<<str;
   
- 字符串操作：
   - strlen(str) 求字符串str的长度
   - strcpy(str1,str2) 将str2的值赋给str1 （覆盖str1原本的值）
   - strcat(str1,str2) 将str1和str2拼接，存在str1中
   - 访问字符串第i个字符，直接str[i]即可 
   
(C++中的字符串会在讲到 STL 的时候介绍，很方便，更常用)

# 结构体
## 1.结构体是什么
对于我们来说，这是承接面向过程和面向对象的一个桥梁，所以一定要掌握。掌握了结构体，面向对象就掌握了一半

看一个例子：
```c++
struct rectangle{
	int length;
	int width;
	int area;
}; 
```

这表示定义了一个结构体名为rectangle的结构体，结构体中包括三个类型为int的成员变量:

>length, width, area

声明结构体： 
```c++
struct rectangle rect; 
```
表示声明一个类型为rectangle的结构体rect
			 
在C++中，可以省略struct关键字
```c++
rectangle rect; 
```
rect 包含属于他的三个成员变量

访问成员变量：利用. 运算符。如：
```c++ 
rect.length; 
rect.width; 
rect.area;
```
结构体数组声明，略，跟声明普通数组一样的逻辑

## 2.结构体指针  
```c++
rectangle *ptr;
```
表示这是一个rectangle类型的指针，&rect表示rect这个结构体的地址

## 3.new 和 delete 
如上，若只是声明了*ptr而不对其进行赋值（地址），则ptr会被认为是空指针，值为0x0 (NULL nullptr)
	
若在程序中访问了空指针，会直接导致程序崩溃，因此要避免访问空指针的情况发生
	
C和C++都提供了内存空间申请的机制，这里只讲C++的new 和 delete。
>C语言为 malloc 和 free 感兴趣的也可以自行学习一下。

### 3.1 new
用法：new (类型名)

例如，在上面我们声明了*ptr指针，此时指向NULL
	
那么我们可以这么声明: 
```cpp
rectangle *ptr = new rectangle
```
系统就会分配一段rectangle类型大小的空间。并令ptr指针指向这片空间

注：结构体指针访问成员变量时，需要用->符号，即 ptr->length ptr->witdh等等
### 3.2 delete

用法: delete (指针)（只能对指针使用） 
例如：
```cpp
delete ptr
```
则会把ptr指向的空间释放掉，并令ptr变成NULL

可以运行以下代码尝试：
```c++
#include <iostream>

struct rectangle{
	int width;
	int length;
	int area;
	bool isSquare;
};
int main(){
	rectangle a[10],b; //声明结构体数组、变量
	// delete b; //报错，new 和 delete 只能对指针使用
	rectangle *ptr=new rectangle;//申请空间，并令 ptr 指向它
	ptr->area=1;
	printf("%d\n",ptr->area);
	delete ptr; //释放 ptr 指向的空间
	
	//对元素赋值
	a[1].width=1; 
	a[1].length=2;
	a[1].area=2;
	a[1].isSquare=false;
	return 0;
}
```

# 练习3
```
3.定义一个Day结构体，结构体中包含int类型的4个成员变量，year,month,day,week。
	(1)定义一个函数input，用于输入前3个成员变量(year,month,day)
	（void类型，传入参数的类型为Day）
	(2)定义一个函数whatDay,用于计算当天是星期几（设每年的1月1日为星期一，且每年都是平年） 
	(3)定义一个函数findDay,用于查询当天的前n天或者后n天是星期几
	(4)完成上述三项后，在main函数中测试功能

4.我们知道，在二维平面中唯一确认一个矩形，最简单的方式是要知道矩形的角点的坐标
  且至少需要知道对角线上的两个角点 
  现在我们采用这种方式确认一个矩形(正矩形，即边与坐标轴平行或垂直)，请完成以下任务：
  (1) 定义一个矩形rectangle类型结构体，其中包含两个点坐标的成员变量（坐标原点建议取矩形中心，后面方便） 
  	  (提示1:每个点由两个坐标表示，因此需要声明4个成员变量)
	  (提示2:建议使用double类型，后面方便)
  (2) 定义一个函数，用于求这个被唯一确定的矩形的面积和周长
  (3) 定义一个函数，用于求这个矩形的中心点坐标
  (4) 定义一个函数，用于求这个矩形的其余两个角点的坐标 
  (5) 若这个矩形可以发生旋转，则唯一确认还需增加一个旋转角度的参数。
  	  请据此定义一个旋转矩形RotatedRect类型结构体
  (6) 在RotatedRect类型结构体中，定义并实现(2)-(4)小题所要求的函数（需另外选择函数名）
  (7) (附加题) 定义一个函数，求矩形在围绕中心旋转x°后四个角点的坐标
  	  并更新成员变量中角点的值和旋转角度的值。 
```

# 类与对象
## 1.类的概念
类其实和结构体差不多，也有类名和成员变量的概念。这些概念在此不再重复
	
类相较于结构体，主要多了以下几项属性：
1. 类的成员不仅有变量，还可以有函数
2. 类的成员可以区分为公有(public)、私有(private)、保护(protectd)类型 
3. 类具有构造函数和析构函数
4. 类可以继承与派生
	
## 2.类的声明
```cpp
class Student{
public:
	//声明变量或函数;
private:
	//声明变量或函数;
protected:
 	//声明变量或函数; 
}; 
```

## 3.public private protected类型
public 指公有声明。程序的任何地方都可以访问对象当中的公有成员

private  私有声明。除了该类的成员函数，其它任何函数中都不能调用其私有成员

protected 被保护声明。该声明主要在继承与派生中用到，现阶段可以认为与private等价
	
声明时，编译器识别到对应的关键字，从该关键字往下都为对应类型的成员变量，直到遇到另一个关键字或者声明结束

举个栗子：
```cpp
class Student{
public:
	...
	...
	...
	//(这里全都是公有成员)
private:
	...
	...
	...
	//(这里全都是私有成员)
protected:
	...
	...
	...
	//(这里全都是保护成员)
}; 
```

如果一开始就缺省关键字的话，则编译器默认声明的为私有类型
	
再举个栗子：
```cpp
class Student{
	...
	...
	...
	//(这里全都是私有成员)
public:
	...
	...
	...
	//(这里全都是公有成员)
}; 
```

对于编程而言，需要有一个统一的规范，因此一般程序员都会按照public, private, protected顺序进行声明
	
## 4.声明一个对象
```cpp
Student stu;
```
表示声明了一个名为stu的Student类型的对象

由于对象的概念是C++特有的，因此，不需要且**不能**在Student前面加上class关键字
	
栗子1：按照上述的方法构造Student类，包含公有成员姓名，电话号码，学号；以及私有变量教务系统账号密码，家庭住址。构造完成后创建stu类，并尝试修改和访问其中的公有变量和私有变量

```cpp
#include<iostream>
#include<string>
class Student{
public:
	std::string name;
	int telephone;
	int id;
private:
	std::string password;
	std::string addr;
};

int main(){
	Student stu;
	std::cin>>stu.name>>stu.telephone>>stu.id;
	std::cout<<"Student: "<<stu.name
			 <<"\ntel: "<<stu.telephone
			 <<"\nid: "<<stu.id<<std::endl;
	
	std::cin>>stu.password>>stu.addr;
	std::cout<<stu.password<<stu.addr;
	
	/*这么写会报错，注意查看报错信息是啥*/
	/*之后把最后两行注释掉，观察是否报错*/
	/*问题1：报错的原因是由于什么引起的？*/
}
```

## 5.成员函数
通过上面的例子，我们可以发现，类的特性能够保证信息的隐蔽，但是又会造成新的问题：如何对私有变量进行修改和访问呢？
	
前面提到，私有变量只能被同类当中的成员函数调用。这当然就需要用到类当中的另外一个特性——成员函数。在成员函数中，访问同类的成员变量就和访问普通变量一样轻松。例如有以下代码段
```cpp
class add{
public:
	int sum(){
		return a+b;
	}
private:
	int a=2;
	int b=3;
};

int main(){
	add obj;
	obj.sum();
	return 0;
}
```
在成员函数中的a，b，就是调用该函数的对象中的a,b的值。在main函数的第二行中，sum函数返回的就是obj.a+obj.b的值。 
	
## 6.成员函数的声明与定义
一般来说，为了增加代码的可读性，使代码呈现得更加清晰，通常不会直接在类中定义函数
	
我们往往采取类中声明，类外定义的方式。类外定义的类成员函数需要在函数名前加上类名和取域符( :: )

例如，上面的代码段会被写成如下形式：
```cpp
class add{
public:
	int sum(); 
private:
	int a;
	int b;
};

int add::sum(){
	return a+b;
}

int main(){
	add obj;
	obj.sum();
	return 0;
}	 
```
更近一步地，为了进一步提高可读性，我们会将类及其成员的声明部分写在头文件中，定义部分写在源文件中。

上述例子可被写为如下形式：

sum.h文件中：
```cpp
class add{
public:
	int sum(); 
private:
	int a;
	int b;
}; 
```

sum.cpp文件中：
```cpp
#include"sum.h"
int add::sum(){
	return a+b;
} 
```
main.cpp文件中：
```cpp
#include"add.cpp"
//如果使用CMake构建则不需要引用cpp文件，需要引用的是.h文件 
int main(){
	add obj;
	obj.sum();
	return 0;
} 
```
栗子2：创建一个文件夹Student,在里面创建student.h student.cpp main.cpp三个文件

在student.h文件中，声明类名为Student的类及其成员。其中公有成员变量有 姓名，电话号码，学号，以及write 和 search函数；私有变量有家庭住址和教务系统密码。
		  
在student.cpp文件中，定义write和search函数。其中write函数用于修改所有信息（输入信息）；search函数用于查找所有信息（输出所有信息） 
		  
在main.cpp函数中，定义主函数，声明对象为stu的对象，调用上述定义的函数对该对象的所有信息进行修改和访问

student.h
```cpp
#include<iostream>
#include<string>
class Student{
public:
	std::string name;
	int telephone;
	int id;
	void write();
	void search();
private:
	std::string password;
	std::string addr;
};
```
student.cpp
```cpp
#include"student.h"
void Student::search(){
	std::cout<<"The student name is: "<<name<<std::endl;
	std::cout<<"The telephone number is: "<<telephone<<std::endl;
	std::cout<<"The student's ID is: "<<id<<std::endl;
	std::cout<<"The password is:"<<password<<std::endl;
	std::cout<<"The address is "<<addr<<std::endl;
}

void Student::write(){
	std::cout<<"Input name you want to change: ";
	std::cin>>name;
	std::cout<<"Input telephone number you want to change: ";
	std::cin>>telephone;
	std::cout<<"Input ID you want to change: ";
	std::cin>>id;
	std::cout<<"Input password you want to change: ";
	std::cin>>password;
	std::cout<<"Input address you want to change: ";
	std::cin>>addr;
}
```
main.cpp
```cpp
#include"student.cpp"

int main(){
	Student stu;
	stu.write();
	stu.search();
	return 0;
}
```

## 7.构造函数和析构函数 
在类中定义的变量是没办法赋予初始值的。虽然有的编译器不会报错，但是这样操作是非常不安全的。

因此在类中，引入了构造函数的概念
	
构造函数与其它函数不同，不需要用户调用，而是在创建对象的时候自动执行。
	
**！！！注意，这里的创建对象指的是给对象分配存储空间，这点很重要**

构造函数有以下特点：
- 函数名与类名相同
- 可以有或没有输入参数
- 不能有返回值，且不能指定返回值类型 
- 必须是公有声明（新编译器好像不一定） 
	
有以下声明：
```cpp
class add{
public:
	add(int x=0,int y=0);
	int sum(); 
private:
	int a;
	int b;
};

add::add(int x,int y){
	a=x;
	b=y;
}

int add::sum(){
	return a+b;
}
```
那么声明 add fyt; 则有fyt.a=0 fyt.b=0;
如果声明 add fyt(3,4) 则有 fyt.a=3 fyt.b=4;
	
析构函数与构造函数是对应的，指的是在对象被释放时会执行的函数，同样不需要用户调用。其特点与构造函数相同

不同点在于函数名为类名前面加一个~符号

例如	~add();

对于对象指针而言，释放内存即执行delete ptr

对于对象变量而言，当程序运行超出其作用域后，会自动被释放 (作用域的概念会在例3程序中以注释的形式给出。)

注意：之前提到构造函数只有在给对象分配空间后才会执行。什么意思呢？

举个栗子。如果我们声明 add *ptr,此时是不会执行构造函数的。因为系统并没有为这个指针分配存储空间，这个指针指向空，只有执行ptr = new add时才会执行构造函数。

如果声明的是对象，如
```cpp
add fyt;
```

那么声明结束后系统就会为其分配存储空间，也就会立即执行构造函数
	
栗子3：体会构造函数和析构函数的工作原理
		
建立一个add类型的类，并定义构造函数和析构函数（最好有输出，方便观察）,分别利用声明对象和声明对象指针的方法，观察构造函数和析构函数的作用（分别写成两个main文件:main_ptr,main）

add.h
```cpp
#include<iostream>
class add{
public:
	add();
	~add();
};

```
add.cpp
```cpp
#include"add.h"
add::add(){
	std::cout<<"I have been created!!!\n\n\n";
}
add::~add(){
	std::cout<<"I have been destoryed!!!\nOh! Don't let me die!!!\n\n\n";
}
```

main.cpp
```cpp
#include"add.cpp"
int main(){
	/*作用域：在某个大括号内声明的变量，其作用域只能在大括号内。
	离开了大括号就相当于离开了作用域，变量便被释放
	下面的栗子，a1是在if语句中被声明的
	一旦离开了if语句，a1就会被释放*/
	if(true){
		add a1;
	}
	add a2;
	return 0;
}
```

main_ptr.cpp
```cpp
#include"add.cpp"
int main(){
	add *ptr;
	ptr=new add;
	//问题2：将上面这条语句注释掉（或删掉）再执行，看看会发生什么。并想想这是为什么 
	delete ptr;
	return 0;
}
```
	
栗子4：构建一个rect类，包含构造函数，析构函数，以及print函数。成员变量包括长，宽，周长，面积。print函数用于输出这4个信息。构造函数中，需要用户在声明时提供长宽作为初始化，之后通过构造函数计算出其周长和面积；析构函数中，需要在释放前将成员变量的值都赋为0，并提示说这个对象已被释放（同样需要用对象和对象指针的方法，写成两个文件）

rect.h
```cpp
#include<iostream>
class rect{
public:
	rect(int length,int width);
	~rect();
	void print();
private:
	int length;
	int width;
	int area;
	int circuit;
}; 
```

rect.cpp
```cpp
#include"rect.h"
rect::rect(int length,int width){
	/*在这里讲一下this指针
	这个是C++提供的关键字，主要是为了解决变量名冲突
	在这个例子中，函数的输入参数和类成员变量名一致(length 和 width) 
	为了区分开，引入了this指针
	length width 指代传入的参数或者在函数中另外定义的变量
	而要访问成员变量，则需要用this->(成员变量名)
	如果命名没有冲突，则可以省略写this指针
	但是建议成员变量名在成员函数定义中都带上this指针，可以增加代码的可读性*/
	
	this->length=length;
	this->width=width;
	this->area=length*width;
	this->circuit=2*(length+width); 
	std::cout<<"The rectangle has been created.\n";
}

rect::~rect(){
	this->length=0;
	this->width=0;
	this->area=0;
	this->circuit=0;
	std::cout<<"This rectangle has been destoried.\n";
}

void rect::print(){
	std::cout<<"The length of this rectangle is: "<<this->length<<std::endl;
	std::cout<<"The width of this rectangle is: "<<this->width<<std::endl;
	std::cout<<"The area of this rectangle is: "<<this->area<<std::endl;
	std::cout<<"The circuit of this rectangle is: "<<this->circuit<<std::endl;
}
```

main.cpp
```cpp
#include"rect.cpp"
int main(){
	if(true){
		rect rectangle(3,4);
		rectangle.print();
	}
	rect rectangle(3,5);
	rectangle.print();
	return 0;
}
```

main_ptr.cpp
```cpp
#include"rect.cpp"
int main(){
	rect *ptr;
	ptr = new rect(3,5);//这里要知道动态申请的空间要怎么进行构造函数传参 
	ptr->print();
	delete ptr;
	return 0;
}
```

# 练习4
```
1. 声明一个Student类，并声明公有成员变量name,telephone,ID
	私有成员变量 password, address
	定义构造函数，提示用户在创建对象时交互性地输入公有成员信息
	并设置address为"Please change your address"，password为123456
	
	定义析构函数，提示用户该对象已被释放
	
	定义search函数，提示用户需要输入密码进行查询。若连续3次错误，则直接返回
	
	定义ChangePassword函数，用于修改用户密码。如果原始密码输入错误三次，则直接返回
	
	（需按照常用规范来，将声明和定义放在不同的文件中）
	
2. C++中提供了特有的字符串类型std::string。（在下节课讲STL时会详细讲解） 
   这个类型本质上就是一个类
   现在让你自己用char类型和面向对象思想编程实现它在STL中的部分功能
   （注：本题共有5小问，其中前3问为必做题，后2问为附加题） 
	（1）创建一个MyString类，类中包含公有成员变量data数组(char类型，长度为256)
		 同时声明构造函数和析构函数， 
		 以及成员函数length(),substring(int start,int end,MyString &s),copyTo(MyString &s); 
	（2）定义构造函数，使成员变量data[0]='\0'，之后提示用户进行赋值，并输出创建信息
		 定义析构函数，输出释放信息
	（3）定义length()函数，用于求字符串的长度
   *（4）定义substring(int start,int end,MyString &s)函数
		 用于求该字符串的字串（从start开始到end结束）,并将其赋给s
		 注意错误输入的处理（例如start<0或end过大） 
   *（5）定义copyTo函数，用于将当前字符串的值赋给s
```
# *类的补充知识点
## 1.继承与派生
我们常用的是公有继承，但是你们之后专业课可能会涉及到私有继承以及保护继承。各个成员变量的属性在不同继承模式下各不相同。

## 2.多态性（函数重载）
一般函数都可以实现重载，但必须要求输入参数的数量或者类型不同。否则会出现二义性，编译器报错

例如以下代码，包括继承派生，以及函数重载：
```cpp
#include<iostream>
class Length{//基类 
public:
	int length;
	int width;
private:
	int abc;
};

class Rect : public Length//派生类 
{
public:
	Rect();
	Rect(int a,int b);
	Rect(int a,int b);
	int cir;
	int area;
};

Rect::Rect(){
	this->length=1;
	this->width=1;
	printf("fun1\n");
}

Rect::Rect(int a,double b){
	this->length=a;
	this->width=a;
	printf("fun2\n");
}

Rect::Rect(int a,int b){
	this->length=a;
	this->width=b;
	printf("fun3\n");
}

int main(){
	Rect rect1(2,3); //输出 fun3
	Rect rect2(2,3.0f);//输出 fun2
	Rect rect3();//输出 fun1
	return 0;
}
```

## 3.C++11新特性：auto关键字
auto会自动识别其声明变量的类型
例如:
- auto i=0 那么i就是int型
- auto i=1.1lf 那么i就是double型
- auto i='A' 那么i就是char型

注意，如果直接写auto i，编译器会报错,因为编译器不知道 i 具体是什么类型。

# STL
C++的STL(Standard Template Library 标准模板库)提供了很多的实用模板。这些内容可以为我们编程提供很多便利，不再需要重复造轮子了。

常用的一些 STL 内容如下：
### std::string
std::string 是C++特别提供的字符串类型，其功能远强于C语言中的char数组
利用这个类型，可以实现一系列的运算
1. 赋值：s2=s1
2. 判断是否相等 s2==s1
3. 求字符串长度，s.length()
4. 求子串： s.substr(start,end)
5. 后接字符串 s1+s2 (ex: "123"+"123"="123123") 
6. 访问单个字符 s[i] (这里的s[i]也可以是一个字符串，之后会介绍到)

### std::vector
这个是容器类，使用时需要指定容器内的数据类型。如std::vector\<int\> std::vector\<double\>

容器的常用操作有
- 将元素压入容器 buf.push_back(a)(a为元素，与容器类型相同，相当于加入到容器的尾部)
- 将尾部元素删除 buf.pop_back()
- 容器中元素个数 buf.size()
- 判断容器是否为空 buf.empty() 为空返回true 不为空返回false 
- 容器的首元素地址 buf.begin() 尾元素地址 buf.end() (之后会用到)
- 在容器的第i个元素后面插入元素 buf.insert(buf.begin()+i,a)
- 访问第i个元素 buf[i] 
- 清除所有元素 buf.clear()

栗子：建立一个存储int类型的容器类，往容器中加入元素1，3，之后在1后面插入2，之后将其中的元素一个个地删除。操作过程中实时输出容器信息（说明：可能会用到内联函数）
```cpp
#include<iostream>
#include<vector>

inline void print(const std::vector<int> &buf){
	printf("buffer's elemenets are:\n");
	if(buf.size()==0){
		printf("Buffer has no element.\n");
		return;
	}
	for(auto i=0;i<buf.size();i++){
		printf("%d ",buf[i]);
	}
	printf("\n");
}

int main(){
	std::vector<int> buf;
	buf.push_back(1);
	print(buf);
	buf.push_back(3);
	print(buf);
	buf.insert(buf.begin()+1,2);
	print(buf);

buf.pop_back();
	print(buf);
	buf.pop_back();
	print(buf);
	buf.pop_back();
	print(buf);
	return 0;
}

```

### std::sort
排序函数，采用的是快速排序的算法。

函数用法：对于数组从0到n排序，用法如下：
```cpp
std::sort(&a[0],&a[n+1]);
```
对于数值和字符，排序默认为升序；对于字符串，则按照字典序升序.自定义排序方式在之后会讲到
		  
对容器(std::vector)从头到尾排序，用法如下：
```cpp
std::sort(buf.begin(),buf.end()); 
```		  
自定义排序：

如果只使用默认排序方式，只能进行单一的排序，且只能对C++内置的类型进行排序，十分不方便

sort函数提供了自定义排序方式，方便开发人员按照自己的意愿进行排序。具体做法为：
1. 声明一个bool类型的cmp函数，包含两个传入参数，类型需与参与排序的数组或容器中元素类型相同。
2. 定义这个函数（比较难用一般性的话说清楚，一会看具体例子）
3. 在排序中将这个函数作为参数传入。如 
```cpp
std::sort(&buf[0],&buf[n],cmp);
```	
栗子：
1. 将int型数组按照降序进行排序
2. 将std::string类型数组进行字典序降序排序
3. 将double型容器内的元素按照降序进行排序
4. 定义一个my结构体，其中包括x，y成员变量。再声明一个结构体数组并对这个数组进行排序，排序规则为：按x大小升序；若x相等，则按照y升序

参考代码（注意观察 cmp 函数的定义）
```cpp
//1~2
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
bool cmp(int x,int y){
	bool flag=(x<y);
	return flag;
}

bool cmp2(std::string s1,std::string s2){
	return s1>s2;
}

int main(){
	int seq[10]={5,2,3,1,9,7,8,6,4};
	std::string str[3]={"anbxjs","basjdk","baalkjd"};
	std::vector<int> buf;
	buf.push_back(5);
	buf.push_back(2);
	buf.push_back(3);
	buf.push_back(1);
	buf.push_back(9);
	buf.push_back(7);
	buf.push_back(8);
	buf.push_back(6);
	buf.push_back(4);
	std::sort(&str[0],&str[3],cmp2);
	for(int i=0;i<3;i++){
		std::cout<<str[i]<<std::endl;
	}
	return 0;
}
```

```cpp
//4
#include<iostream>
#include<algorithm>

struct My{
	int x;
	int y;
};

bool cmp(My m1, My m2){
	if(m1.x==m2.x){
		return m1.y<m2.y;
	}
	else{
		return m1.x<m2.x;
	}
}

int main(){
	My m[5];
	for(int i=0;i<5;i++){
		std::cin>>m[i].x>>m[i].y;
	}
	std::sort(&m[0],&m[5],cmp);
	
	for(int i=0;i<5;i++){
		std::cout<<m[i].x<<" "<<m[i].y<<std::endl;
	}
	return 0;
}

```

### std::next_permutation
这个函数工程里用不到，是一个纯数学的运算，只为填坑（在练习1中的三阶幻方的题目，如果换成四阶幻方，则运算时间需要将近四个小时）。这个函数是用来求一个数组的下一组全排列
  
执行代码，观察输出：
```cpp
int a[3]={1,2,3};
while(std::next_permutation(&a[0],&a[3])){
   	printf("%d %d %d\n",a[0],a[1],a[2]);	
}
```

那么用来算4阶幻方是不是会快一点呢？

# 下一步学习

在学完 C/C++ 后，需要进入到 Ubuntu 系统中进行学习。需要安装以下软件或库：

- Ubuntu，建议安装 20.04 版本
- VSCode （代码编辑器）
- OpenCV 建议安装 4.5.2-4.5.5 版本（记得把相关依赖也安装上） 
- net-tools (网络管理工具)
- cutecom (串口调试工具)
- 大恒相机驱动（注意选择对应平台和架构）
- ros (Ubuntu 20.04 对应着 noetic 版本)

aqs-dwr/training_22

简介

发行版

贡献者

近期动态

aqs-dwr/training_22 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

aqs-dwr/training_22