C++——基础知识入门_c++基础 csdn

1.初识C++

1.1第一个C++程序

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

选择项目名称与位置：

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

# include <iostream>
using namespace std;

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.2注释

# include <iostream>
using namespace std;

// 1.单行注释

/*
多行注释
*/

int main()
{

	cout << "hello world" << endl;

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1.3变量和常量

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

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

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

# include <iostream>
using namespace std;

# define Weekday 7

int main()
{

	const int a = 10;

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

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


	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.4关键字

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

1.5标识符命名规则

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

2.数据类型

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

科学计数法：

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

2.1整形

2.2sizeof关键字

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

2.3实型（浮点型）

2.4字符型

用于表示单个字母

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

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

常见错误：

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

ASCII码表

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

2.5转义字符

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

2.6字符串型

表示一串字符

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

2.7布尔类型bool

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

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

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

2.8数据的输入

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

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.运算符

3.1算数运算符

3.2赋值运算符

3.3比较运算符

3.4逻辑运算符

4.程序流程结构

4.1选择结构

4.1.1if语句

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

4.1.2三目运算符

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.1.3switch语句

# include <iostream>
using namespace std;

int main()
{

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

4.2循环结构

系统生成随机数：

//time系统时间头文件
# include <ctime>

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

rand() % 100 + 1;
// rand() 生成随机数
// rand() % 100 生成 0 ~ 99 的随机数
// rand() % 100 + 1 生成 1 ~ 100 的随机数
1
2
3
4
5
6
7
8
9
10

4.2.1while循环语句

# include <iostream>
using namespace std;

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.2.2do…while循环语句

# include <iostream>
using namespace std;

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.2.3for循环语句

# include <iostream>
using namespace std;

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.2.4嵌套循环

# include <iostream>
using namespace std;

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.3跳转语句

4.3.1break语句

跳出选择结构或循环结构

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

4.3.2continue语句

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

4.3.3goto语句

不推荐使用

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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表达式
}
*/
1
2
3
4
5
6
7
8
9

6.2函数的调用

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

6.3函数的分文件编写

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

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

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

void swap(int a, int b);

1
2
3
4
5
6
7

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

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

	system("pause");

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

7.指针

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

7.1指针的定义与使用

# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

7.2空指针和野指针

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

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

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

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

7.3const修饰指针

const修饰指针的三种情况：

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

/*
常量指针
特点：指针的指向可以修改，但是指针指向的值不可以修改。
*/
const int * p = &a;
/*
指针常量
特点：指针的指向不可以修改，指针指向的值可以修改。
*/
int * const p = &a;
/*
const即修饰指针，又修饰常量
特点：指针的指向不可以修改，指针指向的值也不可以修改。
*/
const int * const p = &a;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

# include <iostream>
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;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// 封装一个使用冒泡排序对整形数组进行升序排列的函数
# include <iostream>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

8.结构体

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

8.1结构体定义和使用

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

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

#include <iostream>
using namespace std;
#include <string>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

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

8.2结构体指针

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

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

#include <iostream>
using namespace std;
#include <string>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

8.3结构体嵌套结构体

#include <iostream>
using namespace std;
#include <string>

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

8.4结构体作为函数参数

• 值传递
• 地址传递

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

8.5结构体中const使用场景

作用： 防止误操作

#include <iostream>
using namespace std;
#include <string>
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31