C++——基础知识入门

1.初识C++

1.1第一个C++程序

创建新项目，选择创建C++的空项目：

选择项目名称与位置：

在源文件中添加C++文件：

# include 
using namespace std;

int main()
{
	// 不换行
	cout << "hello world" ;
	// 换行，换行加个 << endl
	cout << "hello world" << endl;
	// 所以说，这个就是单纯的换行
	cout << endl;

	system("pause");

	return 0;
}

1.2注释

# include 
using namespace std;

// 1.单行注释

/*
多行注释
*/

int main()
{

	cout << "hello world" << endl;

	system("pause");

	return 0;
}

1.3变量和常量

就是给一个指定的空间起名，方便操作这个空间。
创建变量：数据类型 变量名 = 变量初始值；

常量：记录程序中不可更改的数据
定义常量的方法：

• # define 宏常量：# 常量名 常量值
  • 通常在文件上方定义，表示一个常量。
• const修饰的变量：const 数据类型 常量名 = 常量值
  • 通常在变量定义前加关键字const，修饰该变量为常量，不可修改。

# include 
using namespace std;

# define Weekday 7

int main()
{

	const int a = 10;

	cout << "a = " << a <<endl;

	cout << "一周有:" << Weekday << "天" << endl;


	system("pause");

	return 0;
}

1.4关键字

C++中预先保留的单词，定义变量或者常量的时候不可以使用

1.5标识符命名规则

• 标识符不能是关键字
• 标识符只能由字母、数字、下划线组成
• 第一个字符必须为字母或者下划线
• 标识符中字母区分大小写
• 最好可以通过标识符知道它的含义

2.数据类型

数据类型存在的意义： 给变量分配一个合适的内存空间。

科学计数法：

• 3e2：3 * 10²
• 3e-2:3 * 0.1²

2.1整形

数据类型	占用空间	取值范围
short（短整型）	2字节	（-215 ~ 215-1 ）
int（整形）	4字节	（-231 ~ 231-1 ）
long（长整形）	Windows为4字节，Linux为4字节(32位)，8字节(64位)	（-231 ~ 231-1 ）
long long（长长整形）	8字节	（-263 ~ 263-1 ）

2.2sizeof关键字

统计数据类型所占内存大小

2.3实型（浮点型）

数据类型	占用空间	有效数字范围
float（单精度）	4字节	7位有效数字
double（双精度）	8字节	15~16位有效数字

2.4字符型

用于表示单个字母

• 字符型变量只占一个字节。
• 字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放到存储单元。

# include 
using namespace std;

int main()
{
	char ch = 'a';

	cout << ch << endl;
	cout << sizeof(ch) << endl;
	/*
	a
	1
	*/
	// 字符型变量对应的ASCII编码
	// a 97
	// A 65
	cout << (int)ch << endl;
	// 97
	// 可以通过ASCII给字符型变量赋值
	char ch2 = 98;
	cout << ch2 << endl;
	// b

	system("pause");

	return 0;
}

常见错误：

• 使用双引号：char ch = “a”；
• 单引号内放多个字符：char ch = ‘asd’；

ASCII码表

• ASCII非打印控制字符：ASCII表上的数字0~31分配给了控制字符，用于控制外围设备。
• ASCII打印字符：数字32~126分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。

ASCII值	控制字符	ASCII值	字符	ASCII值	字符	ASCII值	字符
0	NUT	32	(space)	64	@	96	`
1	SOH	33	!	65	A	97	a
2	STX	34	"	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	，	71	G	103	g
8	BS	40	（	72	H	104	h
9	HT	41	）	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DC1	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	S	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	：	90	Z	122	z
27	ESC	59	；	91	[	123	{
28	FS	60	<	92	\	124	|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	~
31	US	63	?	95	-	127	DEL

2.5转义字符

作用： 用于显示一些不能直接表示出来的ASCII字符。

转义字符	含义	ASCII码值（十进制）
\a	警报	007
\b	退格（BS）将当前位置移到前一列	008
\f	换页（FF）将当前位置移到下页开头	012
\n	换行（LF）将当前位置移到下一行开头	010
\r	回车（CR）将当前位置移到本行开头	013
\t	水平制表（HT）（跳到下一个TAB位置）	009
\v	垂直制表（VT）	011
\\	代表一个反斜线字符"\"	092
\’	代表一个单引号字符	039
\"	代表一个双引号字符	034
\?	代表一个问号	063
\0	数字0	000
\ddd	8进制转义字符，d范围0~7	3位8进制
\xhh	16进制转义字符，h范围09，af，A~F	3位8进制

2.6字符串型

表示一串字符

• 数组风格字符串：char 变量名[] = “字符串值”；
• C++风格字符串：string 变量名 = “字符串值”；（需要有一个头文件：# include < string >）

2.7布尔类型bool

代表真或者假的值
只有两个值：

• true：代表真
• false：代表假

他们本质上就是0或者1，bool类型就占1个字节大小。

2.8数据的输入

从键盘获取数据
关键字：cin

# include 
using namespace std;

int main()
{
	// 1.整形
	int a = 0;
	cout << "请给整型变量a赋值:" << endl;
	cin >> a;
	cout << "整型变量 a = " << a << endl;

	// 2.浮点型
	float f = 3.14f;
	cout << "请给浮点型变量f赋值:" << endl;
	cin >> f;
	cout << "整型变量 f = " << f << endl;
	
	// 3.字符型
	char ch = 'a';
	cout << "请给字符型变量ch赋值:" << endl;
	cin >> ch;
	cout << "整型变量 ch = " << ch << endl;
	
	system("pause");

	return 0;
}

3.运算符

运算符类型	作用
算术运算符	用于处理四则运算
赋值运算符	用于将表达式的值赋给变量
比较运算符	用于表达式的比较
逻辑运算符	用于根据表达式的值返回真值或假值

3.1算数运算符

运算符	术语	解释
+	正号	符号
-	负号	符号
+	加
-	减
*	乘
/	除
%	取模（取余）	取余数（两个小数是不能取模的）
++	前置递增	先加一，后表达式的运算
++	后置递增	先表达式的运算，后加一
–	前置递减	同上
–	后置递减	同上

3.2赋值运算符

运算符	术语
=	赋值
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	模等于

3.3比较运算符

运算符	术语
==	等等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

3.4逻辑运算符

运算符	术语
！	非
||	或
&&	与

4.程序流程结构

4.1选择结构

4.1.1if语句

# include 
using namespace std;

int main()
{

	int score = 0;

	cout << "请输入您的分数：" << endl;
	cin >> score;
	// 单行if语句：if(条件) {条件满足执行的语句}
	if(score>=60){
		cout << "您及格了" << endl;
	}
	
	// 多行if语句：if(条件) {条件满足执行的语句} else {条件未满足执行的语句}
	if(score>=60){
		cout << "您及格了" << endl;
	}else{
		cout << "您未及格" << endl;
	}
	
	// 多条件的if语句：if(条件1) {条件1满足执行的语句} else if (条件2) {条件2满足执行的语句}...... else {所有条件都未满足执行的语句}
	if(score>=90)
	{
		cout << "成绩优秀" << endl;
	}
	else if(score>=60)
	{
		cout << "成绩及格" << endl;
	}
	else
	{
		cout << "未及格" << endl;
	}
	
	// 嵌套if语句：if(条件1) {if(条件2){if(条件3){}}}
	if(score>=60)
	{
		cout << "成绩及格" << endl;
		if(score>=90)
		{
			cout << "成绩优秀" << endl;
		}
	}
	else
	{
		cout << "未及格" << endl;
	}


	system("pause");

	return 0;
}

4.1.2三目运算符

# include 
using namespace std;

int main()
{

	// 表达式1?表达式2:表达式3;
	// 如果表达式1为真则执行表达式2，否则执行表达式3
	// 输出最大数
	int a = 10;
	int b = 20;
	int max = a>b?a:b;
	cout << max << endl;

	system("pause");

	return 0;
}

4.1.3switch语句

# include 
using namespace std;

int main()
{

	// 多条件分支语句
	/*
	switch(表达式)
	{
		case 结果1:
			执行语句;
			break;
		case 结果2:
			执行语句;
			break;
		case 结果3:
			执行语句;
			break;
		case 结果4:
			执行语句;
			break;
		...
		default:执行语句;break;
	}
	*/

	system("pause");

	return 0;
}

4.2循环结构

系统生成随机数：

//time系统时间头文件
# include 

// 添加随机数种子，利用当前系统时间生成随机数，防止每次随机数都一样。
srand((unsigned int)time(NULL));

rand() % 100 + 1;
// rand() 生成随机数
// rand() % 100 生成 0 ~ 99 的随机数
// rand() % 100 + 1 生成 1 ~ 100 的随机数

4.2.1while循环语句

# include 
using namespace std;

int main()
{
	/*
	while(循环条件)
	{
		循环语句
	}
	*/

	system("pause");

	return 0;
}

4.2.2do…while循环语句

# include 
using namespace std;

int main()
{
	/*
	先执行一遍循环语句，再进行判断循环。
	do
	{
		循环语句;
	}
	while(循环条件);
	*/

	system("pause");

	return 0;
}

4.2.3for循环语句

# include 
using namespace std;

int main()
{
	/*
	for(起始表达式;条件表达式;末尾循环体)
	{
		循环语句;
	}
	*/

	system("pause");

	return 0;
}

4.2.4嵌套循环

# include 
using namespace std;

int main()
{
	/*
	for(起始表达式;条件表达式;末尾循环体)
	{
		循环语句;
		for(起始表达式;条件表达式;末尾循环体)
		{
			循环语句;
		}
	}
	*/

	system("pause");

	return 0;
}

4.3跳转语句

4.3.1break语句

跳出选择结构或循环结构

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

4.3.2continue语句

作用： 在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下次循环。

4.3.3goto语句

不推荐使用

# include 
using namespace std;

int main()
{
	/*
	作用：无条件跳转
	用法：goto 标记；  执行到goto语句时，如果标记的名称存在，会跳转到标记的位置。
	*/
	cout << "第一个" << endl;
	goto FLAG;
	cout << "第二个" << endl;
	cout << "第三个" << endl;
	FLAG:
	cout << "第四个" << endl;
	cout << "第五个" << endl;
	cout << "第六个" << endl;

	system("pause");

	return 0;
}

5.数组

数组就是里面放着相同元素的一个集合
特点：

• 数组中每个数据元素都是相同的数据类型。
• 数组是由连续的内存位置组成的。

5.1一维数组

数组的定义

1. 数据类型 数组名[数组长度]；
2. 数据类型 数组名[数组长度] = {值1，值2…}；
3. 数据类型 数组名[] = {值1，值2…}；

数组名的用途

• 可以统计整个数组在内存中的长度。
  • sizeof(数组名)；
• 可以获取数组在内存中的首地址。
  • (int)数组名：这样输出十进制的首地址。
  • 数组名：这样输出十六进制的首地址。
  • (int)&数组名[0]：数组中第一个元素的地址，第一个元素的地址就是数组的首地址。
• 数组名是常量，不可以进行赋值操作。

5.2二维数组

数组的定义（推荐使用第二种

1. 数据类型 数组名[行数][列数]；
2. 数据类型 数组名[行数][列数] = {{值11，值12…}，{值21，值22…}…}；
3. 数据类型 数组名[行数][列数] = {值1，值2，值3，值4，值5…}；
4. 数据类型 数组名[][列数] = {值1，值2，值3，值4，值5…}；

数组名的用途

• 查看二维数组所占内存空间
• 获取二维数组首地址

6.函数

作用： 将一段经常使用的代码封装起来，减少代码重复，较大程序会分为若干个程序块，每个模块实现特定的功能。

6.1函数的定义

/*
语法：
返回值类型 函数名(参数列表)
{
	函数体语句

	return表达式
}
*/

6.2函数的调用

# include 
using namespace std;
// 函数的声明：如果要调用的函数定义在需要调用它的后面，则需要声明函数。
int add(int num1,int num2);

int main()
{
	int a = 1;
	int b = 2;
	// 调用函数的时候，传过去的a，b有实际的数值，他们成为实参。
	int c = add(a, b);

	cout << "c=" << c << endl;

	system("pause");

	return 0;
}

// 定义的时候num1与num2没有真正的数据，此时它是形参。
int add(int num1, int num2)
{
	int sum = num1 + num2;
	return sum;
}

注意： 值传递时形参在函数中发生任何改变，都不会影响实参值。

6.3函数的分文件编写

作用： 让代码结构更清晰
步骤：

• 创建后缀名为.h的头文件
• 创建后缀名为.cpp的源文件
• 在头文件中写函数的声明
• 在源文件中写函数的定义

// swap.h
# include 
using namespace std;
// 函数的声明

void swap(int a, int b);

// swap.cpp
# include "swap.h"

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

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

}

// main函数所谓源文件
# include 
# include "swap.h"
// 使用双引号括起来是自己写的，使用尖括号括起来是调用别人写的。
using namespace std;

int main()
{
	int a = 1;
	int b = 2;
	
	swap( a, b);

	system("pause");

	return 0;
}

7.指针

作用： 通过指针间接访问内存。

7.1指针的定义与使用

# include 
using namespace std;

int main()
{
	// 定义指针
	int a = 10;
	// 指针定义的语法：数据类型 * 指针变量名；
	int * p;
	//指针变量记录变量a的地址
	p = &a;
	// 使用指针
	cout << "a的地址为：" << &a << endl;
	cout << "a的地址为：" << p << endl;
	// 可以通过解引用的方式找到指针指向的内存存储的值。
	cout << "指针p指向内存空间所存储的值" << *p << endl;
	// 可以通过这种方式来改变指定内存空间存储的值
	*p = 100;
	cout << "a = " << a << endl;
	cout << "*P = " << *p << endl;
	
	system("pause");

	return 0;
}

在32位操作系统下指针所占内存空间固定为4字节，64位操作系统为8字节（无论是int、double… 各种类型的指针都一样）

7.2空指针和野指针

空指针： 指针变量指向内存中编号为0的空间。
用途： 初始化指针变量。
注意： 空指针指向的内存是不可以访问的。

野指针： 指针变量指向非法的内存空间，在程序中避免出现野指针。

// 定义空指针
int *p = NULL;

// 定义野指针
int *p = (int *)0x1234;
// 0x1234这个内存空间并不是自己的，没有操作它的权限。

7.3const修饰指针

const修饰指针的三种情况：

1. const修饰指针：常量指针。
2. const修饰常量：指针常量。
3. const即修饰指针，又修饰常量。

/*
常量指针
特点：指针的指向可以修改，但是指针指向的值不可以修改。
*/
const int * p = &a;
/*
指针常量
特点：指针的指向不可以修改，指针指向的值可以修改。
*/
int * const p = &a;
/*
const即修饰指针，又修饰常量
特点：指针的指向不可以修改，指针指向的值也不可以修改。
*/
const int * const p = &a;

7.4指针、数组与函数的联合使用

# include 
using namespace std;

void swap(int * p1, int * p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}

int main()
{
	int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

	// 利用指针访问数组中的元素
	int *p = arr;  // arr就是数组的首地址
	cout << "利用指针访问第一个元素:" << *p << endl;
	p++; // 让指针向后便宜4个字节，此时指针指向第二个元素。
	cout << "利用指针访问第二个元素:" << *p << endl;

	cout << "利用指针遍历数组：" << endl;
	// 利用指针便利数组
	int * p2 = arr;
	for (int i = 0; i < 10; i++)
	{
		cout << *p << endl;
		p++;
	}
	
	//地址传递，会改变实参值
	int a = 10;
	int b = 20;

	swap(&a, &b);

	cout << "交换后的a:" << a << endl;
	cout << "交换后的b:" << b << endl;
	
	system("pause");

	return 0;

}

// 封装一个使用冒泡排序对整形数组进行升序排列的函数
# include 
using namespace std;

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;	
			}
		}
	}
}


int main()
{
	int arr[10] = {4, 3, 6, 9, 1, 2, 7, 5, 8};
	bubbleSort(arr, 9);
	
	system("pause");

	return 0;
}

8.结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

8.1结构体定义和使用

语法： struct 结构体名 {结构体成员列表}；
通过结构体创建变量的三种方式：

• struct 结构体名 变量名
• struct 结构体名 变量名 = {成员1值，成员2值…}
• 定义结构体时，顺便创建变量

#include 
using namespace std;
#include 
struct Student
{
	string name;
	int age;
	int score;
}s3;
// 定义结构体的时候顺便创建变量

int main()
{
	// struct关键字在创建变量时可以省略
	struct Student s1;
	s1.name = "张三";
	s1.age = 15;
	s1.score = 90;

	struct Student s2 = {"李四", 16, 89};
	
	s3.name = "王五";
	s3.age = 16;
	s3.score = 91;
	
	system("pause");

	return 0;
}

结构体数组： struct 结构体名 数组名[元素个数] = {{}，{}，{}，…}

8.2结构体指针

通过指针访问结构体中的成员

• 利用操作符 -> 可以通过结构体指针访问结构体属性

#include 
using namespace std;
#include 
struct Student
{
	string name;
	int age;
	int score;
};

int main()
{
	// 创建学生结构体变量
	Student s = {"张三", 18, 100};

	// 通过指针指向结构体变量
	Student *p = &s;
	
	// 通过指针访问结构体变量中的数据
	cout << "姓名：" << p->name << "年龄：" << p->age << "分数：" << p->score << endl; 
	
	system("pause");

	return 0;
}

8.3结构体嵌套结构体

#include 
using namespace std;
#include 

struct Student
{
	string name;
	int age;
	int score;
};

struct Teacher
{
	int id;
	string name;
	int age;
	struct Student stu;
};

int main()
{
	// 创建老师
	Teacher t;
	t.id = 100;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 18;
	t.stu.score = 89;
	
	cout << "老师的姓名：" << t.name << "老师的年龄：" << t.age << "老师的编号：" << t.id << << "老师的学生的姓名：" << t.stu.name << "老师的学生的年龄：" << t.stu.age << "老师的学生的成绩：" << t.stu.score << endl; 
	
	system("pause");

	return 0;
}

8.4结构体作为函数参数

• 值传递
• 地址传递

与普通的参数一样，值传递只是传递值，改变形参不会改变实参。

8.5结构体中const使用场景

作用： 防止误操作

#include 
using namespace std;
#include 
struct Student
{
	string name;
	int age;
	int score;
};

void printStudents(const Student * s)
{
	//s->age = 100; // 使用const修饰后，一旦有修改的操作就会报错，可以防止误操作。
	// 在这里，如果不使用地址传递，直接用值传递，就算修改了也不会改变最原始数据的值，那么为什么不用呢？
	    // 因为如果使用值传递，就需要重新开辟一块地址空间，如果传过来的数据量太大，会消耗大量空间，而使用地址传递，只需要开辟一块指针的空间。
	cout << "学生姓名：" << s->name << " 年龄：" << s->age << " 分数：" << s->score << endl; 
}

int main()
{
	// 创建学生结构体变量
	Student s = {"张三", 18, 100};

	printStudents(s);
	
	cout << "姓名：" << s.name << "年龄：" << s.age << "分数：" << s.score << endl; 
	
	system("pause");

	return 0;
}