观道观
0%

C++入门

发表于 更新于 分类于
本文字数： 28k 阅读时长 ≈ 25 分钟

本文介绍了C++的基本知识包括C++初识、数据类型、运算符、程序流程结构、数组、函数、指针、结构体。最后总结知识点，编写了一个简单的通讯录管理系统。

参考：黑马程序员课程

C++入门

1C++初识

1.1第一个C++程序

书写hello world!

1
2
3
4
5
6
7
8
9
#include <iostream>
using namespace std;

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

1.2注释

//单行注释

/**/多行注释

1.3变量

变量存在的意义：方便我们管理内存空间。

变量创建的语法：数据类型 变量名 = 变量初始值；

1
2
3
4
5
6
7
8
9
#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	cout << "a=" << a << endl;
	system("pause");
	return 0;
}

1.4 常量

作用：用于记录程序中不可更改的数据

c++定义常量的两种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include<iostream>
using namespace std;
//常量的定义方式
//1.#define宏常量

//2.const修饰的变量

//1.#define 宏常量
#define Day 7
int main()
{
	cout << "一周总共有：" << Day << "天" << endl;
	
	//const 修饰的变量
	const int month = 12;
	cout << "一年总共有：" << month << "月" << endl;
	//month = 24 报错，常量是不可修改的
	system("pause");
	return 0;
}

1.5 标识符命名规则

作用：C++规定给标识符（变量、常量）命名时，有一套自己的规则

  • 标识符不能是关键字
  • 标识符只能由字母、数字、下划线组成
  • 第一个字符必须为字母或下划线
  • 标识符中字母区分大小写

2 数据类型

2.1 数据类型

image-20231210153935095

2.2 sizeof关键字

可以利用sizeof求出数据类型的占用内存的大小。

1
2
3
4
5
//sizeof(数据类型/变量)

//整型大小比较

//short<int<=long<=long long

2.3 实型（浮点型）

作用：用于表示小数

1.单精度 float

2.双精度 double

image-20231210154909225

默认double，float 声明时若想为float则需加f。

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

//科学计数法

float f2 = 3e2; //3*10^2;

2.4 字符型

作用：字符型变量用于显示单个字符

语法：char ch = 'a';

  • [ ] 注意1：子啊显示字符型变量时，用单引号将字符括起来，不要用双引号。

  • [ ] 注意2：单引号内只能有一个字符，不可以是字符串

  • C和C++中字符型变量只占用1个字节

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

2.5 转义字符

“ \ \ “代表一个反斜杠”\“

2.6 字符串型

作用：用于表示一串字符

1.C风格字符串：char 变量名[] = ”字符串“

2.C++风格字符串： string 变量名 = ”字符串值“

C++风格字符串需加入头文件，#include<string>

2.7 布尔类型

作用：布尔数据类型代表真或假的值

1
2
3
4
5
6
7
8
9
//创建bool数据类型

bool flag = true; //代表真 1

cout << flag << endl;

//2.查看bool类型占用的空间

cout << sizeof(flag) << endl; //等于1

2.8数据的输入

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
//1、整型

int a = 0;

cin >> a;

// 2.浮点型

float f = 3.14f;

cin >> f;

// 字符型

char ch = 'a';

cin >> ch;

//字符串型

string str = "hello";

cin >> str;

//布尔数据

bool flag = false;

cin >> flag;//非0的值都为真

3 运算符

3.1 算术运算符

image-20231210162129314

image-20231210162238426

两个整数相除，结果依然是整数，将小数部分去除，向下取整。

在除法运算中，除数不能为0。

两个小数是不可以做取模运算的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//前置递增

int a = 10;

++a;

//后置递增

int b = 10;

b++;

//前置和后置的区别

//前置递增，先让变量+1 然后进行表达式运算

//后置运算 先进行表达式运算 后让变量+1

3.2 赋值运算符

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

int a = 10;

a = 100;

// +=

a = 10;

a += 2; //a = 10+2 = 12

// -=

a = 10;

a - = 2;

//*=

a = 10;

a *= 2; //a = a*2

// %=

a = 10;

a %= 2; //a = a % 2;

3.3 比较运算符

image-20231210164016670

3.4 逻辑运算符

image-20231210164136929

！！a//对a取两次反

4 程序流程结构

image-20231210164517155

4.1 选择结构

4.1.1 if语句

1.单行格式if语句

image-20231210164724163

if （score > 600); //加分号表示结束循环，此时为一个空循环

2.多行格式if语句

image-20231210165617463

3.多条件的if语句

image-20231210165727352

4.嵌套if语句

4.1.2 三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1 ？ 表达式2 ： 表达式3

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果

如果表达式1的值为假，执行表达式3，并返回表达式3的结果

1
2
3
//在C++中三目运算符返回的是变量，可以继续赋值

(a < b ? a : b) = 100;

4.1.3 switch 语句

作用：执行多条件分支语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
switch(表达式)

{

		case 结果1 : 执行语句;break；

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

		default : 执行语句;break;

}
//if 和 switch的区别
//switch 缺点，判断时候只能是整型或者字符型，不可以是一个区间
//switch 优点，结构清晰，执行效率高

4.2 循环结构

4.2.1 while 循环语句

image-20231210171119445

注意：在执行循环语句时，程序必须提供跳出循环的出口，否则出现死循环。

随机数：

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

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

4.2.2 do…while循环语句

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

image-20231210171629480

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//在屏幕中输出0到9这10个数字

int num = 0;

do

{

​	cout  << num << endl;

​	num++; 

}

while (num < 10);

水仙花数

案例描述：水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身

例如：1^3 + 5^3 + 3^3 = 153

请利用do……while语句，求出所有3位数中的水仙花数

1.将所有的三位数进行输出 （100~999）

2.在所有三位数中找到水仙花数

​ 水仙花数

​ 获取个位 153%10 = 3

​ 获取十位 153/10 = 15 15%10 = 5

​ 获取百位 153/100 = 1

​ 判断 个位^3 + 十位^3 + 百位^3 = 本身

4.2.3 for循环语句

注意：for循环中的表达式，要用分号进行分隔

总结：while,do……while，for都是开发中常用的循环语句，for循环结构比较清晰，比较常用

4.2.4 嵌套循环

乘法口诀表

1
2
3
4
5
6
7
for (int i=1; i<=9 ; i++){
	for (int j=1;j<=i;j++){
		cout << j << "*" << i << "=" << i*j << " ";
	}
	cout << endl;

}

4.3 跳转语句

4.3.1 break语句

image-20231210175435905

4.3.2 continue 语句

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

4.3.3 goto语句

作用：可以无条件跳转语句

语法：goto 标记；

解释：如果标记的名称存在，执行到goto语句时，会跳转到标记位置

5 数组

一维数组

image-20231210180303431

使用第二种方式时，初始化数据，没有填完，会用0填充。

可以通过数组名查看数组首地址

数组中元素的个数：sizeof(arr)/sizeof(arr[0])

数组中第一个元素的地址：(int) &arr[0]

元素逆置

1.创建数组

2.实现逆置

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

int main()
{
	//实现逆置
	//1.记录起始下标位置
	//2.记录结束下表位置
	//3.起始下标与结束下标的元素互换
	//4.起始位置++，结束位置--
	//5.循环执行
	int arr[] = { 2,9,8,7,6 };
	int start = 0;
	int end = sizeof(arr) / sizeof(arr[0])-1;
	do
	{
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;//实现互换位置
		start++;
		end--;
	} while (start < end);

	system("pause");
	return 0;

}

冒泡排序

1.比较相邻元素，如果第一个比第二个大，就交换他们两个

2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值

3.重复以上的步骤，每次比较次数-1，直到不需要比较

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

int main()
{
	int arr[] = { 4,2,8,0,5,7,1,3,9 };
	int end = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < end - 1; i++)
	{
		for (int j = 0; j < end - i - 1; j++)
		{
			if (arr[j] < arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
	for (int i = 0; i < end; i++) {
		cout << arr[i] << " ";
	}

	system("pause");
	return 0;

}

二维数组

二维数组的定义方式：

image-20231212155522641

二维数组组名

1
2
3
4
5
6
7
8
9
10
11
12
int arr[2][3] =
{
	{1,2,3},
	{4,5,6}
};

cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
cout << "二维数组第一行占用内存：" << sizeof(arr[0]) << endl;
cout << "二维数组第一个元素占用内存为：" << sizeof(arr[0][0]) << endl;
cout << "二维数组的行数：" << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组的列数：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

6 函数

6.1 概述

作用：将一段经常使用的代码封装起来，减少重复代码

一个较大的程序，一般分为若干个程序块，每个模块实现特定的功能

6.2 函数的定义

函数的定义一般主要有5个步骤：

1.返回值类型

2.函数名

3.参数biaolie

4.函数体语句

5.return 表达式

语法：

1
2
3
4
5
6
返回值类型 函数名 （参数列表）

{
	函数体语句
	return 表达式
}

6.3 函数的调用

总结：函数定义里小括号称为形参，函数调用时传入的参数称为实参。

6.4 值传递

当我们做值传递的时候，函数的形参发生改变，并不会影响实参

6.5 函数的常见样式

常见的函数样式有4种

1.无参无返

2.有参无返

3.无参有返

4.有参有返

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
//函数常见样式
//无参无返
void test01()
{
	cout << "this is test01" << endl;
}

//有参无返
void test02(int a)
{
	cout << "this is test02" << a << endl;
}

//无参有返
int test03()
{
	cout << "this is test03" << endl;
	return 0;
}

//有参有返
int test04(int b)
{
	cout << "this is test04" << endl;
	return b;
}

6.6 函数的声明

作用：为了告诉编译器这个函数存在并链接到这个函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<iostream>
using namespace std;
//函数声明
int max(int a,int b);

int max(int a,int b)
{
	return a > b ? a : b;
}
int main()
{
	int a = 10;
	int b = 20;
	cout << max(a,b) << endl;
	system("pause");
	return 0;
}

6.7函数的分文件编写

作用：让代码结构更加清晰

函数分文件编写一般有4个步骤

1.创建后缀名为.h的头文件

2.创建后缀名为.cpp的源文件

3.在头文件中写函数的声明

4.在源文件中写函数的定义

示例：

1
2
3
4
//swap.h
#include<iostream>
using namespace std;
void swap(int a,int b);
1
2
3
4
5
6
7
8
9
10
//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
//函数的分文件编写
//实现两个数字进行交换的函数
//函数的声明
#include<iostream>
#include "swap.h"
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	swap(a,b);
	system("pause");
	return 0;
}

7 指针

7.1指针的概念

指针的作用：可以通过指针间接访问内存

  • 内存编号是从0开始记录的，一般用十六进制数字表示
  • 可以利用指针变量保存地址

7.2指针变量的定义和使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//定义指针
int a = 10;
//指针定义的语法：数据类型 * 指针变量名
int *p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址:" << &a << endl;
cout << "指针p为:" << p << endl;

//2.可以使用解引用的方式调用指针
//指针前加 * 表示解引用，找到指针指向的内存中的数据
*p = 1000;
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;

7.3指针所占的内存空间

根据操作系统的不同，指针所占内存空间不同，在32位操作系统下，所占为4个字节，在64位操作系统下，所占为8个字节（无论是什么数据类型）。

1
2
3
4
//指针所占的内存空间大小
int a = 10;
int *p = &a;
cout << "sizeof (int *) = " << sizeof(p) << endl;

7.4 空指针和野指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

1
2
3
4
5
//空指针用于给指针变量用于初始化
int *p = NULL; //地址编号指向0
//空指针是不可以进行访问的
//0~255之间的内存编号是系统占用的，不可以直接访问
*p = 100;//运行出错

野指针：指针变量指向非法空间

1
2
3
4
//野指针
int *p = (int *)0x1100;//转成指针类型
//读取访问权限冲突
cout << *p << endl;

总结：空指针和野指针都不是我们申请的空间，因此不要访问

7.5 const修饰指针

const 修饰指针有三种情况：

1
2
3
4
5
6
7
8
9
10
//1.const 修饰指针——常量指针
const int *p = &a;

//常量指针

//特点：指针的指向可以修改，但是指针指向的值不可以改。

*p = 20;//错误，指针指向的值不可以改

p = &b;//正确，指向可以更改
1
2
3
4
5
6
7
//const 修饰常量
int * const p = &a;//指针常量，int *const p是作用在*，即指针指向不可以更改

//特点：指针的指向不可以更改，指针的值可以更改

*p = 20;//正确，指向的值可以更改
p = &b;//错误，指针的指向不可以更改
1
2
3
4
5
//3.const 既修饰指针，又修饰常量
const int * const p = &a;
//特点：指针的指向和指针指向的值都不可以改
*p = 20;//错误
p = &b;//错误

7.6指针和数组

作用：利用指针访问数组中元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//指针和数组
//利用指针访问数组中的元素
int arr[10] = {1,2,3,4,5,6,7,8,9};
cout << "第一个元素：" << arr[0] << endl;
int *p = arr;//arr就是数组的首地址
cout << "利用指针访问第一个元素：" << *p << endl;
p++;//让指针向后偏移四个字节
cout << "利用指针访问第二个元素：" << *p << endl;

cout << "利用指针遍历数组" << endl;
int *p2 = arr;
for (int i=0; i<10; i++)
{
	cout << *p2 << endl;
	p2++;
}

7.7指针和函数

作用：利用指针作函数参数，可以修改变量值

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
//指针和函数
//1.值传递
void swap01(int a,int b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 20;
	int b = 10;
	swap01(a,b);
}
//2.地址传递
void swap02(int *p1,int *p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
int main()
{
	int a = 20;
	int b = 10;
	swap02(&a,&b);//把地址传进去
	system("pause");
	return 0;
}

7.8 指针、数组、函数

案例描述： 封装一个函数，利用冒泡排序，实现对整型数组的升序排序

例如数组：int arr[10] = {4,3,6,9,1,2,10,8,7,5}

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
//冒泡排序函数
void bubbleSort(int *arr,int len)
{
	for (int i =0;i < len -1;i++)
	{
		for (int j = 0;j < len-1-i;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++)
	{
		cout << arr[i] << " ";
	}
}
int main()
{
	//创建数组
	int arr[10] = {4,3,6,9,1,2,10,8,7,5};
	int len = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr,len);
	printArray(arr,len);
	system("pause");
	return 0;
}

8 结构体

8.1结构体的基本概念

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

8.2 结构体定义和使用

语法：

1
struct 结构体名 {结构体成员列表}

通过结构体构建变量的方式有三种：

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

示例：

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
//1.创建学生类型：学生包括（姓名，年龄，分数）
//自定义数据类型
struct Student
{
	//成员列表
	string name;//姓名
	int age;//年龄
	int score;//分数
}s3;
//通过学生类型创建具体学生
int main()
{
//第一种方式
	struct Student s1;
	s1.name = "张三";
	s1.age = 18;
	s1.score = 100;
	
//第二种方式
	struct Student s2 = {"李四",19,100};
	
	
//创建结构体时，就创建变量
	s3.name = "w";
	s3.age = 18;
	s3.score = 99;
	system("pause");
	return 0;
}

总结1：定义结构体时的关键字是struct，不可省略

总结2：创建结构体变量时，关键字struct可以省略

总结3：结构体变量利用操作符”.”访问成员

8.3结构体数组

作用：将自定义的结构体放入到数组中方便维护

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
struct Student
{
	//成员列表
	string name;//姓名
	int age;//年龄
	int score;//分数
};
int main()
{
	struct Student stuArray[3] = 
	{
		{"张三",18,100},
		{"李四",28,99},
		{"王五",38,66}
	};
	//给结构体数组中的元素赋值
	stuArray[2].name = "赵六";
	stuArray[2].age = 80;
	stuArray[2].score = 100;
	system("pause");
	return 0;
}

8.4结构体指针

作用：通过指针访问结构体的成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct student
{
	//成员列表
	string name;//姓名
	int age;//年龄
	int score;//分数
};
int main()
{
	//创建学生的结构体变量
	struct student s = {"张三",18,100}
	//通过指针指向结构体变量
	struct student int * p = &s;//struct可以省略，以上皆是如此
	//通过指针访问结构体变量中的数据
	cout << "姓名：" << p->name << endl;
	system("pause");
	return 0;
	
}

8.5结构体嵌套结构体

作用：结构体中的成员可以是另一个结构体

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
#include<iostream>
#include<string>
using namespace std;
//学生结构体定义
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 = 10000;
	t.name = "老王";
	t.age = 50;
	t.stu.name = "小王";
	t.stu.age = 20;
	t.stu.score = 100;
	system("pause");
	return 0;
}

8.6结构体作函数参数

作用：将结构体作为参数向函数传递

传递方式有两种：

  • 值传递——形参变实参不变
  • 地址传递——形参变实参也变

示例：

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
#include<iostream>
#include<string>
using namespace std;
//学生结构体定义
struct student
{
	//成员列表
	string name;//姓名
	int age;//年龄
	int score;//分数
};
void printStudent1(struct student s)
{
	cout << "子函数中姓名：" << s.name << endl;
}
void printStudent2(struct student *p)
{
	cout << "name is " << p->name << endl;
}
int main()
{
	struct student s;
	s.name = 20;
	s.score = 85;
	printStudent(s);
	printStudent(&s);
	system("pause");
	return 0;
}

8.7结构体中const使用场景

作用：用const来防止误操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//const的使用条件
struct Student
{
	//成员列表
	string name;//姓名
	int age;//年龄
	int score;//分数
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudents(const student s)//加const防止误操作
{
	//加入const之后，一旦有了修改操作就会报错。
	cout << "name is " << s->name << endl;
}
int main()
{
	struct Student s2 = {"李四",19,100};
	system("pause");
	return 0;
}

8.8结构体案例

8.8.1案例1

案例描述：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下

设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员

学生的成员有姓名、考试分数、创建数组存放3名老师，通过函数给每个老师及所带的学生赋值

最终打印出老师数据以及老师所带的学生数据。

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
struct Student
{
	//成员列表
	string sName;//姓名
	int age;//年龄
	int score;//分数
};
//老师的结构体
struct teacher 
{
	 string tName;
	 struct Student sArray[5];
};
void allocateSpace(struct teacher tArray[],int len)
{
	string nameSeed = "ABCDE";
	//给老师赋值
	for (int i=0;i<len;i++)
	{
		tArray[i].tName = "teacher_";
		tArray[i].tName += nameSeed[i];
		for (int j=0;j<5;j++)
		{
			tArray[i].sArray[j].sName = "Student_";
			tArray[i].sArray[j].sName += nameSeed[i];
			int random = rand() % 61 + 40;//40~100
			tArray[i].sArray[j].score = random; 
		}
	}
}
void printInfo(struct teacher tArray[],int len)
{
	for (int i=0;i<len;i++)
	{
		cout << "Teacher's name is " << tArray[i].tName << endl;
		for (int j=0;j<5;j++)
		{
			cout << "Student's name is " << tArray[i].sArray[j].sName <<
			"Student's score is " << tArray[i].sArray[j].score << endl;
		}
	}
}
int main()
{
	//随机数种子
	srand((unsigned int))time(NULL);//使得真正随机起来
	//创建3名老师的数组
	struct teacher tArray[3];
	//通过函数给3名老师的信息赋值，并给老师带的学生信息赋值
	int len = sizeof(tArray) / sizeof(tArray[0]);
	allocateSpace(tArray,len);
}

8.8.2 案例2

案例描述：

设计一个英雄的结构体，包括成员姓名、年龄、性别；创建结构体数组，数组中存放5名英雄。

通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

五名英雄的信息如下：

1
2
3
4
5
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"},

示例：

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
#include<iostream>
using namespace std;
struct Hero
{
	string name;
	int age;
	string sex;
}
void bubbleSort(struct Hero heroArray[] , int len)
{
	for (int i=0;i<len-1;i++)
	{
		for (int j=0;j<len-1-i;j++)
		{
			if (heroArray[j]<heroArray[j+1])
			{
				struct Hero temp = heroArray[j];
				heroArray[j] = heroArray[j+1];
				heroArray[j] = temp;
			}
		}
	}
}
int main()
{
	struct Hero heroArray[5] = {
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};
	int len = sizeof(heroArray) / sizeof(heroArray[0]);
	for (int i=0;i<len;i++)
	{
		cout << "name is " << heroArray[i].name << endl;
	}
	bubbleSort(heroArray,len);
	system("pause");
	return 0;
}

C++—通讯录管理系统

1.系统需求

通讯录是一个可以记录亲人，好友信息的工具。

本次主要通过C++来实现一个通讯录管理系统

系统中需要实现的功能如下：

  • 添加联系人：向通讯录中添加新人，信息包括（姓名、性别、年龄、联系电话、家庭住址）最多记录1000人
  • 显示联系人：显示通讯录中所有联系人信息
  • 删除联系人：按照姓名进行删除指定联系人
  • 查找联系人：按照姓名查看指定联系人信息
  • 修改联系人：按照姓名重新修改指定联系人
  • 清空联系人：清空通讯录中所有信息
  • 退出通讯录：退出当前使用的通讯录

2.创建项目

创建新项目

添加文件

3.菜单功能

1
2
3
4
5
6
7
8
9
10
11
12
13
//菜单界面
void showMenu()
{
	cout << "***********************" << endl;
	cout << "*** 1.add person    ***" << endl;
	cout << "*** 2.show person   ***" << endl;
	cout << "*** 3.delete person ***" << endl;
	cout << "*** 4.search person ***" << endl;
	cout << "*** 5.modify person ***" << endl;
	cout << "*** 6.clear person  ***" << endl;
	cout << "*** 0.exit          ***" << endl;
	cout << "***********************" << endl;
}

4.退出功能

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
while (true)
{
	//菜单调用
	showMenu();
	cin >> select;
	switch (select)
	{
	case 1://add person
		break;
	case 2://show person
		break;
	case 3://delete person
		break;
	case 4://search person
		break;
	case 5://modify person
		break;
	case 0://exit
		cout << "Welcome to use it next time!" << endl;
		system("pause");
		return 0;
		break;
	default:
		break;
	}
}

5.添加联系人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define MAX 1000
//菜单界面

struct Person
{
	string name;
	//性别 1 男 2 女
	int m_Sex;
	int m_Age;
	string m_Phone;
	string m_Addr;
};
struct Addressbooks
{
	struct Person personArray[MAX];
	int m_Size;
};
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
void addPerson(Addressbooks* abs)
{
	if (abs->m_Size == MAX)
	{
		cout << "通讯录已满" << endl;
		return;
	}
	else
	{
		string name;
		cout << "please input name: " << endl;
		cin >> name;
		abs->personArray[abs->m_Size].name = name;

		cout << "please input sex: " << endl;
		cout << "1--man" << endl;
		cout << "2--woman" << endl;
		int sex = 0;
		cin >> sex;
		while (true)
		{
			if (sex == 1 || sex == 2)
			{
				abs->personArray[abs->m_Size].m_Sex = sex;
				break;
			}
			cout << "error,please input right data!" << endl;
		}

		cout << "please input age: " << endl;
		int age = 0;
		cin >> age;
		abs->personArray[abs->m_Size].m_Age = age;

		cout << "please input phone :" << endl;
		string phone;
		cin >> phone;
		abs->personArray[abs->m_Size].m_Phone = phone;

		cout << "please input address :" << endl;
		string addr;
		cin >> addr;
		abs->personArray[abs->m_Size].m_Addr = addr;

		//upgrade size
		abs->m_Size++;
		cout << "add successfully" << endl;
		system("pause");//请按任意键继续
		system("cls");//清屏效果
	}
}

6.显示联系人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void showPerson(Addressbooks abs)
{
	if (abs.m_Size == 0)
	{
		cout << "this is null" << endl;
	}
	else
	{
		for (int i = 0; i < abs.m_Size; i++)
		{
			cout << "name is " << abs.personArray[i].name << "\t";
			cout << "sex is " << (abs.personArray[i].m_Sex == 1 ? "man":"woman") << "\t";
			cout << "age is " << abs.personArray[i].m_Age << "\t";
			cout << "phone is " << abs.personArray[i].m_Phone << "\t";
			cout << "address is " << abs.personArray[i].m_Addr << endl;
		}
	}
	system("pause");
	system("cls");
}

7删除联系人

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
int isExist(Addressbooks *abs, string name)
{
	for (int i = 0; i < abs->m_Size; i++)
	{
		if (abs->personArray[i].name == name)
		{
			return i;
		}
	}
	return -1;
}

void deletePerson(Addressbooks* abs)
{
	cout << "please input person if you need to delete" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret != -1)
	{
		for (int i = ret; i < abs->m_Size; i++)
		{
			abs->personArray[i] = abs->personArray[i + 1];
		}
		cout << "delete successfully" << endl;
	}
	else
	{
		cout << "without this person" << endl;
	}
}

8.查找联系人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void findPerson(Addressbooks *abs)
{
	cout << "please input name if you need to search it" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret != -1)
	{
		cout << "name is " << abs->personArray[ret].name << "\t";
		cout << "sex is " << (abs->personArray[ret].m_Sex == 1 ? "man" : "woman") << "\t";
		cout << "age is " << abs->personArray[ret].m_Age << "\t";
		cout << "phone is " << abs->personArray[ret].m_Phone << "\t";
		cout << "address is " << abs->personArray[ret].m_Addr << endl;
	}
	else
	{
		cout << "without this person" << endl;
	}
	system("pause");
	system("cls");
}

9.修改联系人

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
void modifyPerson(Addressbooks *abs)
{
	cout << "please input name if you need to modify it" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret != -1)
	{
		string name;
		cout << "please input name: " << endl;
		cin >> name;
		abs->personArray[ret].name = name;

		cout << "please input sex: " << endl;
		cout << "1--man" << endl;
		cout << "2--woman" << endl;
		int sex = 0;
		cin >> sex;
		while (true)
		{
			if (sex == 1 || sex == 2)
			{
				abs->personArray[ret].m_Sex = sex;
				break;
			}
			cout << "error,please input right data!" << endl;
		}

		cout << "please input age: " << endl;
		int age = 0;
		cin >> age;
		abs->personArray[ret].m_Age = age;

		cout << "please input phone :" << endl;
		string phone;
		cin >> phone;
		abs->personArray[ret].m_Phone = phone;

		cout << "please input address :" << endl;
		string addr;
		cin >> addr;
		abs->personArray[ret].m_Addr = addr;

		cout << "modify successfully" << endl;
	}
	else
	{
		cout << "without this person" << endl;
	}
	system("pause");//请按任意键继续
	system("cls");//清屏效果
}

10.清空联系人

1
2
3
4
5
6
7
void cleanPerson(Addressbooks* abs)
{
	abs->m_Size = 0;
	cout << "clear successfully" << endl;
	system("pause");
	system("cls");
}

11.整体程序如下

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
#include<iostream>
#include<string>
using namespace std;
#define MAX 1000

struct Person
{
	string name;
	//性别 1 男 2 女
	int m_Sex;
	int m_Age;
	string m_Phone;
	string m_Addr;
};

struct Addressbooks
{
	struct Person personArray[MAX];
	int m_Size = 0;
};

void addPerson(Addressbooks* abs)
{
	if (abs->m_Size == MAX)
	{
		cout << "通讯录已满" << endl;
		return;
	}
	else
	{
		string name;
		cout << "please input name: " << endl;
		cin >> name;
		abs->personArray[abs->m_Size].name = name;

		cout << "please input sex: " << endl;
		cout << "1--man" << endl;
		cout << "2--woman" << endl;
		int sex = 0;
		cin >> sex;
		while (true)
		{
			if (sex == 1 || sex == 2)
			{
				abs->personArray[abs->m_Size].m_Sex = sex;
				break;
			}
			cout << "error,please input right data!" << endl;
		}

		cout << "please input age: " << endl;
		int age = 0;
		cin >> age;
		abs->personArray[abs->m_Size].m_Age = age;

		cout << "please input phone :" << endl;
		string phone;
		cin >> phone;
		abs->personArray[abs->m_Size].m_Phone = phone;

		cout << "please input address :" << endl;
		string addr;
		cin >> addr;
		abs->personArray[abs->m_Size].m_Addr = addr;

		//upgrade size
		abs->m_Size++;
		cout << "add successfully" << endl;
		system("pause");//请按任意键继续
		system("cls");//清屏效果
	}
}

void showPerson(Addressbooks abs)
{
	if (abs.m_Size == 0)
	{
		cout << "this is null" << endl;
	}
	else
	{
		for (int i = 0; i < abs.m_Size; i++)
		{
			cout << "name is " << abs.personArray[i].name << "\t";
			cout << "sex is " << (abs.personArray[i].m_Sex == 1 ? "man":"woman") << "\t";
			cout << "age is " << abs.personArray[i].m_Age << "\t";
			cout << "phone is " << abs.personArray[i].m_Phone << "\t";
			cout << "address is " << abs.personArray[i].m_Addr << endl;
		}
	}
	system("pause");
	system("cls");
}

int isExist(Addressbooks *abs, string name)
{
	for (int i = 0; i < abs->m_Size; i++)
	{
		if (abs->personArray[i].name == name)
		{
			return i;
		}
	}
	return -1;
}

void deletePerson(Addressbooks* abs)
{
	cout << "please input person if you need to delete" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret != -1)
	{
		for (int i = ret; i < abs->m_Size; i++)
		{
			abs->personArray[i] = abs->personArray[i + 1];
		}
		cout << "delete successfully" << endl;
	}
	else
	{
		cout << "without this person" << endl;
	}
	system("pause");
	system("cls");
}

void findPerson(Addressbooks *abs)
{
	cout << "please input name if you need to search it" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret != -1)
	{
		cout << "name is " << abs->personArray[ret].name << "\t";
		cout << "sex is " << (abs->personArray[ret].m_Sex == 1 ? "man" : "woman") << "\t";
		cout << "age is " << abs->personArray[ret].m_Age << "\t";
		cout << "phone is " << abs->personArray[ret].m_Phone << "\t";
		cout << "address is " << abs->personArray[ret].m_Addr << endl;
	}
	else
	{
		cout << "without this person" << endl;
	}
	system("pause");
	system("cls");
}

void modifyPerson(Addressbooks *abs)
{
	cout << "please input name if you need to modify it" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret != -1)
	{
		string name;
		cout << "please input name: " << endl;
		cin >> name;
		abs->personArray[ret].name = name;

		cout << "please input sex: " << endl;
		cout << "1--man" << endl;
		cout << "2--woman" << endl;
		int sex = 0;
		cin >> sex;
		while (true)
		{
			if (sex == 1 || sex == 2)
			{
				abs->personArray[ret].m_Sex = sex;
				break;
			}
			cout << "error,please input right data!" << endl;
		}

		cout << "please input age: " << endl;
		int age = 0;
		cin >> age;
		abs->personArray[ret].m_Age = age;

		cout << "please input phone :" << endl;
		string phone;
		cin >> phone;
		abs->personArray[ret].m_Phone = phone;

		cout << "please input address :" << endl;
		string addr;
		cin >> addr;
		abs->personArray[ret].m_Addr = addr;

		cout << "modify successfully" << endl;
	}
	else
	{
		cout << "without this person" << endl;
	}
	system("pause");//请按任意键继续
	system("cls");//清屏效果
}

void cleanPerson(Addressbooks* abs)
{
	abs->m_Size = 0;
	cout << "clear successfully" << endl;
	system("pause");
	system("cls");
}

//菜单界面
void showMenu()
{
	cout << "***********************" << endl;
	cout << "*** 1.add person    ***" << endl;
	cout << "*** 2.show person   ***" << endl;
	cout << "*** 3.delete person ***" << endl;
	cout << "*** 4.search person ***" << endl;
	cout << "*** 5.modify person ***" << endl;
	cout << "*** 6.clear person  ***" << endl;
	cout << "*** 0.exit          ***" << endl;
	cout << "***********************" << endl;
}

int main()
{
	//创建通讯录结构体变量
	Addressbooks abs;
	int select = 0;//创建用户选择输入的变量
	while (true)
	{
		//菜单调用
		showMenu();
		cin >> select;
		switch (select)
		{
		case 1://add person
			addPerson(&abs); //利用地址传递，可以修改实参
			break;
		case 2://show person
			showPerson(abs);
			break;
		case 3://delete person
			deletePerson(&abs);
			break;
		case 4://search person
			findPerson(&abs);
			break;
		case 5://modify person
			modifyPerson(&abs);
			break;
		case 0://exit
			cleanPerson(&abs);
			cout << "Welcome to use it next time!" << endl;
			system("pause");
			return 0;
			break;
		default:
			break;
		}
	}
	

	system("pause");
	return 0;
}
-------------本文结束感谢您的阅读-------------

欢迎关注我的其它发布渠道