1. C++面向过程

一、C++简介

1.1 C++的产生及其特点

• 从C语言发展演变而来，解决了C语言中存在的一些问题，并增加了对面向对象程序设计方法的支持
  • 与其他高级语言相比，C语言可以直接访问物理地址；与汇编相比它具有良好的可读性和可移植性
• C++于1980年由贝尔实验室的Bjarne Stroustrup创建
• 特点：
  • 尽量兼容C语言
  • 支持面向对象的方法
    • 对象是程序的基本单元
    • 对象的属性需要用某种类型的数据来表示
    • 对象的功能和行为由成员函数来实现，函数的实现归根到底是算法的设计

1.2 Hello World

/*** #include头文件，既用于声明头文件以供多个文件使用，同时也用来声明函数原型，以便于在整个程序中使用 ***/
#include 

// 主函数，程序入口
int main(){
    std::cout << "Hello World !" << std::endl;
    std::cout << "Welcome to C++ ! " << std::endl;
    return 0;
}

二、C++语法基础

2.1 标识符命名规则

• 以字母或者下划线开始
• 可以由大写字母、小写字母、下划线或数字0~9组成
• 区分大小写
• 不能是C++关键字或操作符

2.2 注释

1. 单行注释：//注释描述
2. 多行注释：/* 注释描述 */

2.3 变量

• 作用：给一段指定的内存空间命名，方便操作这段内存
• 语法：数据类型 变量名 = 初始值;

#include
using namespace std;

int main() {

	//变量的定义
	//语法：数据类型  变量名 = 初始值

	int a = 10;
	cout << "a = " << a << endl;
	
	system("pause");
	return 0;
}

2.4 常量

• 作用：记录程序中不可更改的数据
• 定义方式：
  • #define 宏常量：#define 常量名 常量值
    • 没有数据类型，只是简单的字符串替换，不能进行安全检查
  • const常量：const 数据类型 常量名 = 常量值
    • 常类型，创建时必须初始化
    • 编译期概念，即编译时用到的地方都会替换成相应的值，可节省空间，避免不必要的内存分配

//1、宏常量
#define day 7

int main() {
	cout << "一周里总共有 " << day << " 天" << endl;
	//day = 8;  //报错，宏常量不可以修改

	//2、const修饰变量
	const int month = 12;
	cout << "一年里总共有 " << month << " 个月份" << endl;
	//month = 24; //报错，常量是不可以修改的
	
	system("pause");
	return 0;
}

• const对象默认为文件局部变量
  • 默认情况下，const对象被设定为仅在文件内有效，如果要在不同的程序文件中使用同一个const对象，则必须要显示声明extern，并初始化
  • 多个文件之间共享const对象，那么不管是声明还是定义都可添加上extern关键字，这样就只需要定义一次即可

// file_1.cpp
// 定义并初始化了一个常量，该常量可以被其他文件访问
extern const int bufSize = fcn();

// file_2.h
// 与file_1.cpp中定义的bufSize是同一个
extern const int bufSize;

// file_1.cpp定义并初始化了bufSize，因此显然是一个定义，加上了extern则可以被其他文件访问
// file_2.h头文件中的声明也由extern做了限定，其作用是指明bufSize并非本文独有，它的定义将在别处出现

2.5 数据类型

• 作用：
  • 存储所需要的尺寸
  • 取值空间
  • 对齐信息
  • 可执行的操作
• 不同变量类型之间的唯一区别就是内存空间大小
  • 1 byte = 8 bit
  • 1 bit 可为0或1
  • 有符号数signed，需要有一位表示符号+/- ；无符号数unsigned

2.5.1 整型 int

1. sizeof关键字
   1. 作用：统计数据类型所占内存大小
   2. 语法：sizeof( 数据类型 / 变量)
   3. 例如：sizeof(float)
   4. 整型内存大小的一个结论：short < int <= long <= long long

2.5.2 浮点型（实型）

1. 作用：表示小数

2. 分成两种：float、double

3. 默认情况下，输出一个小数，会显示出6位有效数字

2.5.3 字符型 char

1. 作用：用于显示单个字符

2. 语法：char ch = 'a';

3. 注意：

   1. 用单引号将字符括起
   2. 单引号内只能有一个字符

4. C/C++中字符型变量只占用一个字节

5. 不是把字符本身放到内存中存储，而是将对应的ASCII编码放入存储单元

   int main() {
   	char ch = 'a';
   	cout << ch << endl;
   	cout << sizeof(char) << endl;
   
   	//ch = "abcde"; //错误，不可以用双引号
   	//ch = 'abcde'; //错误，单引号内只能引用一个字符
   
   	cout << (int)ch << endl;  //查看字符a对应的ASCII码
   	ch = 97; //可以直接用ASCII给字符型变量赋值
   	cout << ch << endl;
   
   	system("pause");
   	return 0;
   }
   

6. 转义字符：用于表示一些不能显示出来的ASCII字符

   

7. 字符串型

   • C风格：char 变量名[]="字符串值"

     • 要加中括号

     int main() {
     	char str1[] = "hello world";
     	cout << str1 << endl;
         
     	system("pause");
     	return 0;
     }
     

   • C++风格：string 变量名="字符串值"

     • 要包含头文件：#include

     int main() {
     	string str = "hello world";
     	cout << str << endl;
     	
     	system("pause");
     	return 0;
     }
     

2.5.4 布尔型 bool

1. 只有两个值
   • true：本质是1，非0都是1
   • false：本质是0
2. 只占1个字节

int main() {

	bool flag = true;
	cout << flag << endl; // 1

	flag = false;
	cout << flag << endl; // 0

	cout << "size of bool = " << sizeof(bool) << endl; //1
	
	system("pause");
	return 0;
}

2.6 标准库类型string

标准库 string 表示可变长的字符序列

使用string类型时必须要首先包含string头文件

#include 

1. 定义和初始化

   string s1;		// 默认初始化，s1是一个空字符串
   
   string s2(s1);	// 直接初始化
   
   string s2 = s1;	// 拷贝初始化
   

   • 如果使用等号=初始化一个变量，实际上就是执行的拷贝初始化
   • 不使用等号=，则执行的直接初始化

   string s3(n, 'c');	// 把s3初始化为由连续n个字符c组成的串
   
   // 例如：
   string s3(5, 'c');	// s3的初始化内容是5个c组成的串：ccccc
   

2. string对象的操作

   • 执行读取操作时，string对象会自动忽略开头的空白，从第一个真正的字符开始读起
   • 输入：“ HelloWorld ”，输出：“HelloWorld”

   #include 
   
   int main() {
       string s;
       std::cin >> s;
       std::cout << s << std::endl;
       return 0;
   }
   

   • 多个输入或多个输出可以连写在一起

   string s1, s2;
   cin >> s1 >> s2;			// 第一个输入读到s1中, 第二个输入读到s2中
   cout << s1 << s2 << endl;
   

3. getline

   • 读取一整行
   • 可保留字符串中的空白符
   • getline函数的参数是一个输入流和一个string对象，函数从给定的输入流中读入内容，将读入内存的存放到string对象中
   • getline遇到换行符就结束读取操作并返回结果

   int main() {
       string line;
       
       // 每次循环都是读入一整行，
       while (getline(cin, line)) {
           cout << line << endl;
       }
       return 0;
   }
   

4. empty

   • string的成员函数
   • 根据string对象是否为空返回一个对应的布尔值

   while ( getline(cin, line) ) {
       if ( !line.empty() ) {
           count << line << endl;
       }
   }
   

5. size

   • string的成员函数
   • 返回string对象的长度，即string对象中字符的个数

   string line;
   
   while (getline(cin, line)) {
       if (line.size() > 80)
           cout << line << endl;
   }
   

   • size函数返回的是一个string::size_type类型的值

2.7 标准库类型vector

vector表示对象的集合，其中所有对象的类型都相同，集合中的每个对象都有一个与之对应的索引，该索引可用于访问对象

vector容纳着其他对象，因此也常称为容器（container）

• 使用vector必须包含vector头文件

#include 

using std::vector;

• vector是一个类模板
  • 模板本身不是类或函数，可将其看作编译器生成类或函数编写的一份说明
  • 当使用模板时，需要指出编译器应该把类或函数实例化成何种类型
  • 实例化：编译器根据模板创建类或函数的过程

1. 定义和初始化

   vector v1;					// T是对象类型，v1是一个空的vector对象，执行默认初始化
   
   vector v2(v1);				// v2中包含v1所有元素的副本
   vector v2 = v1;				// 同上
   
   vector v3(n, val);			// v3包含n个重复的元素, 每个元素值都是val
   
   // 值初始化
   vector v4(n)				   // 只提供容纳的元素数量，初值由元素类型决定，如int型则初值为0
   
   // 列表初始化
   vector v4{a, b, c, ...};  	// v4包含了初始值个数的元素，每个元素被赋予相应的初始值
   vector v5 = {a, b, c, ...};	// 同上
   
   

2. push_back

   • vector的成员函数，用于添加元素
   • 将一个值作为vector对象的尾元素push到vector对象的尾端

   // 将0 ~ 99的整数存储到v2中
   
   vector v2;
   
   for (int i = 0; i != 100; ++i) {
       v2.push_back(i);
   }
   

   // 从标准输入中读取单词，将其作为vector对象的元素存储
   
   string word;
   vector text;
   
   while ( cin >> word ) {
       text.push_back(word);
   }
   

   • 如果循环体内包含有向vector对象添加元素的语句，则不能使用范围for循环
     • 范围for循环语句体内不应改变其所遍历序列的大小

注意：

• 不能用下标形式给vector对象添加元素

• 可用于访问已存在的元素，下标从0开始

2.6 数据输入

• 从键盘获取输入数据

int main(){

	//整型输入
	int a = 0;
	cout << "请输入整型变量：" << endl;
	cin >> a;
	cout << a << endl;

	//浮点型输入
	double d = 0;
	cout << "请输入浮点型变量：" << endl;
	cin >> d;
	cout << d << endl;

	//字符型输入
	char ch = 0;
	cout << "请输入字符型变量：" << endl;
	cin >> ch;
	cout << ch << endl;

	//字符串型输入
	string str;
	cout << "请输入字符串型变量：" << endl;
	cin >> str;
	cout << str << endl;

	//布尔类型输入
	bool flag = true;
	cout << "请输入布尔型变量：" << endl;
	cin >> flag;
	cout << flag << endl;
	system("pause");
	return EXIT_SUCCESS;
}

2.7 类型别名

两种方式：

1. typedef

   typedef double d;	// d是类型double的同义词
   

2. 别名声明：using

   using d = double;	// 把等号左侧的名字规定成右侧的类型的别名
   

2.7.1 auto

• 让编译器通过初始值来推算变量的类型
• auto定义的变量必须要有初始值

auto a = val1 + val2;

// a初始化为val1和val2相加的结果

• auto可以在一条语句中声明多个变量，但必须注意一条声明语句只能有一个基本数据类型

auto i = 1, *p = &i;	// i是整型变量，p是整型指针

auto a = 0, b = 3.14;	// 错误！！！

2.7.2 decltype

• 选择并返回操作数的数据类型

decltype( fcn() ) sum = x;	// sum的类型是函数fcn返回类型

• 编译器会分析表达式并得到它的类型，不会实际计算表达式的值

三、运算符

• 用于执行代码运算

3.1 算术运算符

• 处理四则运算

1. 加减乘除

int main() {
	int a1 = 10;
	int b1 = 3;
	cout << a1 + b1 << endl;
	cout << a1 - b1 << endl;
	cout << a1 * b1 << endl;
	cout << a1 / b1 << endl;  //两个整数相除结果依然是整数

	int a2 = 10;
	int b2 = 20;
	cout << a2 / b2 << endl; 

	int a3 = 10;
	int b3 = 0;
	//cout << a3 / b3 << endl; //报错，除数不可以为0

	//两个小数可以相除
	double d1 = 0.5;
	double d2 = 0.25;
	cout << d1 / d2 << endl;

	return 0;
}

2. 取模

int main() {
	int a1 = 10;
	int b1 = 3;
	cout << 10 % 3 << endl;

	int a2 = 10;
	int b2 = 20;
	cout << a2 % b2 << endl;

	int a3 = 10;
	int b3 = 0;
	//cout << a3 % b3 << endl; //取模运算时，除数也不能为0

	//两个小数不可以取模
	double d1 = 3.14;
	double d2 = 1.1;
	//cout << d1 % d2 << endl;

	return 0;
}

3. 递增递减

int main() {
	//后置递增
	int a = 10;
	a++; //等价于a = a + 1
	cout << a << endl; // 11

	//前置递增
	int b = 10;
	++b;
	cout << b << endl; // 11

	//区别
	//前置递增先对变量进行++，再计算表达式
	int a2 = 10;
	int b2 = ++a2 * 10;
	cout << b2 << endl;

	//后置递增先计算表达式，后对变量进行++
	int a3 = 10;
	int b3 = a3++ * 10;
	cout << b3 << endl;

	return 0;
}

3.2 赋值运算符

3.3 比较运算符

• 用于表达式的比较，并返回一个真值或假值

3.4 逻辑运算符

• 用于根据表达式的值返回真值或假值

四、基本控制结构

C/C++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

• 顺序结构：程序按顺序执行，不发生跳转
• 选择结构：依据条件是否满足，有选择的执行相应功能
• 循环结构：依据条件是否满足，循环多次执行某段代码

4.1 选择结构

4.1.1 if语句

1. 单行格式 if 语句

int main() {
	//选择结构-单行if语句
	//输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印
	int score = 0;
	cout << "请输入一个分数：" << endl;
	cin >> score;
	cout << "您输入的分数为： " << score << endl;

	//if语句
	//注意事项，在if判断语句后面，不要加分号
	if (score > 600) {
		cout << "我考上了一本大学！！！" << endl;
	}
    
	return 0;
}

2. 多行格式 if 语句

int main() {
	int score = 0;
	cout << "请输入考试分数：" << endl;
	cin >> score;

	if (score > 600) {
		cout << "我考上了一本大学" << endl;
	}
	else {
		cout << "我未考上一本大学" << endl;
	}

	return 0;
}

3. 多条件的 if 语句

int main() {
	int score = 0;
	cout << "请输入考试分数：" << endl;
	cin >> score;

	if (score > 600) {
		cout << "我考上了一本大学" << endl;
	}
	else if (score > 500) {
		cout << "我考上了二本大学" << endl;
	}
	else if (score > 400) {
		cout << "我考上了三本大学" << endl;
	}
	else {
		cout << "我未考上本科" << endl;
	}

    return 0;
}

/**********************等价于*************************/
else {
    if (score > 500) {
		cout << "我考上了二本大学" << endl;
	}
}

4. 嵌套if语句

// 案例需求：
// 提示用户输入一个高考考试分数，根据分数做如下判断
// 分数如果大于600分视为考上一本，大于500分考上二本，大于400考上三本，其余视为未考上本科
// 在一本分数中，如果大于700分，考入北大，大于650分，考入清华，大于600考入人大
int main() {
	int score = 0;
	cout << "请输入考试分数：" << endl;
	cin >> score;

	if (score > 600) {
		cout << "我考上了一本大学" << endl;
		if (score > 700) {
			cout << "我考上了北大" << endl;
		}
		else if (score > 650) {
			cout << "我考上了清华" << endl;
		}
		else {
			cout << "我考上了人大" << endl;
		}
	}
	else if (score > 500) {
		cout << "我考上了二本大学" << endl;
	}
	else if (score > 400) {
		cout << "我考上了三本大学" << endl;
	}
	else {
		cout << "我未考上本科" << endl;
	}

	return 0;
}

4.1.2 三目运算符

• 语法：表达式1 ? 表达式2 ：表达式3
  • 如果表达式1的值为真，执行表达式2，并返回表达式2的结果；
  • 如果表达式1的值为假，执行表达式3，并返回表达式3的结果。

int main() {
	int a = 10, b = 20, c = 0;
	c = a > b ? a : b;
	cout << "c = " << c << endl;

	//C++中三目运算符返回的是变量,可以继续赋值
	(a > b ? a : b) = 100;

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	return 0;
}

4.1.3 switch语句

• 执行多条件分支语句
• switch语句中表达式类型只能是整型或者字符型
• case里如果没有break，那么程序会一直向下执行

switch(表达式) {
	case 结果1：执行语句; break;

	case 结果2：执行语句; break;

	...

	default:执行语句;break;
}

//请给电影评分 
//10 ~ 9   经典   
// 8 ~ 7   非常好
// 6 ~ 5   一般
// 5分以下 烂片
int main() {
	int score = 0;
	cout << "请给电影打分" << endl;
	cin >> score;

	switch (score) {
	case 10:					// 没有break就会继续往下执行
	case 9:
		cout << "经典" << endl;
		break;
	case 8:
		cout << "非常好" << endl;
		break;
	case 7:
	case 6:
		cout << "一般" << endl;
		break;
	default:
		cout << "烂片" << endl;
		break;
	}

	return 0;
}

4.2 循环语句

4.2.1 while循环

• 满足循环条件，执行循环语句

int main() {
	int num = 0;
	while (num < 10) {
		cout << "num = " << num << endl;
		num++;
	}
	
	return 0;
}

4.2.2 do…while循环

• 与while的区别在于do…while会先执行一次循环语句，再判断循环条件

int main() {
	int num = 0;

	do {
		cout << num << endl;
		num++;
	} while (num < 10);

	return 0;
}

4.2.3 for循环

• 语法：for(起始表达式; 条件表达式; 末尾循环体) { 循环语句; }

int main() {
	for (int i = 0; i < 10; i++) {
		cout << i << endl;
	}

	return 0;
}

/*****************等价于***********************/
int i = 0;
bool condition = true;
for(;condition;) {
    i++;
    if(!(i < 10))
        condition = false;
}

4.3 break语句

• 用于跳出选择结构或者循环结构

• break使用的时机：

  • 出现在switch条件语句中，作用是终止case并跳出switch
  • 出现在循环语句中，作用是跳出当前的循环语句
  • 出现在嵌套循环中，跳出最近的内层循环语句

int main() {
	//2、在循环语句中用break
	for (int i = 0; i < 10; i++) {
		if (i == 5)	{
			break; //跳出循环语句
		}
		cout << i << endl;
	}

	return 0;
}

4.4 continue语句

• 在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环

int main() {
	for (int i = 0; i < 100; i++) {
		if (i % 2 == 0) {
			continue;
		}
		cout << i << endl;
	}

	return 0;
}

五、指针

5.1 指针的基本概念

• 指针是一个整数，存储一个内存地址
  • 电脑中的内存就像是一条大街，街边都是房子，每栋房子都有一个门牌号和地址，将每栋带地址的房子想象成一个字节的数据（1 byte）
    • 现在有人网购，需要送货上门；有人需要寄快递，把东西送出去。那么需要一个方法来获取正确的门牌号地址，也要能够从房子里搬东西出去，即能够从内存中，对那些byte进行read和write
    • 指针就是那个地址，告诉我们房子在什么地方 —— 指定的字节的在电脑内存的哪个位置
• 语法：数据类型* 变量名;
  • 数据类型types对指针本身而言完全没有意义，因为所有指针都是一个整数，存放一个内存地址
    • 数据类型代表的是存放在这个内存中的数据的类型

int main() {
	//指针的定义：数据类型* 变量名 ;
	int a = 10; 	//定义整型变量a
	int* p = &a;	//定义并初始化指针, 指向变量a的地址

	cout << &a << endl; //打印数据a的地址
	cout << p << endl;  //打印指针变量p
}

5.2 指针的使用

• 在指针前面加一个星号*，即可访问指针指向内存中存储的数据，并对其进行操作
  • 星号*也称为解引用符
• 这也称为Dereferencing（逆向引用，解引用）

//通过*操作指针变量指向的内存
cout << "*p = " << *p << endl;

六、引用

• 本质上只是指针的一个拓展
  • 没有reference能做而pointer不能做的事
• 与指针的区别：
  • reference必须引用一个已存在的变量，引用本身并不是一个新的变量，不真正占用内存
• 定义引用：数据类型& 引用名

int main() {
	int a = 10;
	int &b = a; // b是a的别名
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
    
    // b是a的别名，修改b的值就是在修改a的值
	b = 100;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	return 0;
}

• 注意事项：
  • 引用必须初始化
  • 引用在初始化之后，不可以改变

int main() {
	int a = 10;
	int b = 20;
    /***引用必须初始化***/
	// int &c; 	   // 错误！！！
    
	int &c = a;  	
    
    /***引用一旦初始化后，就不可以更改***/
	// c = b; 		// 错误！！！

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	return 0;
}

七、函数

7.1 函数的定义与声明

• 函数的组成：

  返回类型 函数名字(参数列表) {
      函数体
  }
  

• 函数的声明（也称为函数接口）：

  • 与定义的区别：函数声明不需要函数体
  • 函数接口三要素：
    • 返回类型
    • 函数名
    • 形参类型

• 一般在头文件中进行声明，在源文件中定义

  • 含有函数声明的头文件应该被包含到定义函数的源文件中

7.2 参数传递

• 每次调用函数都会重建它的形参，并用传入的实参对形参进行初始化

7.2.1 值传递

• 实参的值被拷贝给形参，形参和实参是两个相互独立的对象
  • 实参被值传递，函数被传值调用
  • 函数对形参做的所有操作都不会影响实参

7.2.2 引用传递

• 形参是引用类型，那么它将直接绑定到对应的实参上
  • 实参被引用传递，函数被传引用调用

7.3 函数分文件编写

• 作用：让代码结构更加清晰
• 步骤：
  • 创建后缀名为 .h 的头文件
    • 在头文件中写函数的声明
  • 创建后缀名为 .cpp 的源文件
    • 引用上一步的.h头文件
    • 在源文件中写函数的定义
  • 在主函数中调用函数，引用该函数的头文件

示例：

swap.h 头文件

# include 

//实现两个数字交换的函数声明
void swap(int a, int b);

swap.cpp 源文件

// 双引号""代表自定义的头文件
# include "swap.h"

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

main.cpp 主程序文件

# include 
# include "swap.h"

int main(){
    int a = 10;
    int b = 20;
    swap(a, b);
    
    return 0;
}

7.4 例子：冒泡排序

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个；
2. 对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值；
3. 重复以上步骤，每次比较次数-1，直到不需要比较。

• 排序总轮数 = 元素个数 - 1
• 每轮对比次数 = 元素个数 - 排序轮数 - 1

// 利用冒泡排序实现升序序列
#include 

// 冒泡排序函数 参数1 数组的首地址 参数2 数组长度
void bubbleSort(int* arr, int len) {
	for (int i = 0; i < len - 1; i++) {
		for (int j = 0; j < len - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}

// 打印数组
void printArray(int* arr, int len) {
	for (int i = 0; i < len; i++) {
		std::cout << arr[i] << std::endl;
	}
}

int main() {
	// 1、创建数组
	int arr[10] = { 4, 3, 6, 9, 1, 2, 10, 8, 7, 5 };
	int len = sizeof(arr) / sizeof(arr[0]);

	// 2、创建函数，实现冒泡排序
	bubbleSort(arr, len);

	// 3、打印排序后的数组
	printArray(arr, len);

	system("pause");
	return 0;
}