C入门-基础语法

JAY.LIN 收录于 C

2025-03-11 约 8918 字预计阅读 18 分钟

$所谓数组，就是一个集合，里面存放了相同类型的数据元素特点1：数组中的每个数据元素都是相同的数据类型特点2：数组是由连续的内存位置组成的// 以为数组有三种定义方式//1. 数据类型数组名[数组长度]cout << "array数组元素如下：\n" << endl;i < 3;i++)// 数据类型数组名[数组长度] = { 10， 20， 30 }cout << "array2数组元素如下：\n" << endl;i < 3;i++)$

C++入门-基础语法

C++基础入门

helle world C++程序

#include <iostream>
using namespace std;

int main() {
	// 输出语句
	cout << "hello world" << endl;
	system("pause");

	return 0;
}

变量

作用：给一段指定的内存空间起名，方便操作这段内存

语法： 数据类型变量名 = 初始值;

#include <iostream>
using namespace std;

int main() {
	
	// 定义一个变量 
	int num = 10;

	cout << "num = " << num << endl;

	return 0;
}

**注意：对于内置类型：局部变量如果在声明时不初始化，他的初始化值是未定义的，就是垃圾值，以为这可能包含任何值，看内存的情况；对于全局变量或静态变量声明时自动初始化为0 **

常量

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

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

#include <iostream>
using namespace std;

// 定义一个宏常量
#define day 7
int main() {

	// 定义一个const常量
	const int month = 30;
	cout << "一个周有：" << day << "天" << endl;

	cout << "一个月有：" << month << "天" << endl;


	return 0;
}

关键字

作用：关键字是C++中预先保留的单词（标识符）

在定义变量或常量的时候，不要用关键字

C++的关键字如下：

提示：给变量或者常量其名称的时候，不要用C++得关键字，否则会产生歧义

标识符命名规则

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

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

建议：给标识符命名时，争取做到见名之意的效果，方便自己和他人的阅读”

数据类型

整型

C++规定在创建一个变量或则常量时，必须要指定出相应的数据类型，否则无法给变量分配内存

作用：整形变量表示的是整形类型的数据

C++中能够表示整形的类型有以下几种方式， 区别在与所占内存空间不同 ：

sizeof关键字

作用：利用sizeof关键字可以统计数据类型所占内存大小

语法： sizeof（数据类型 / 变量）

#include <iostream>
using namespace std;

int main() {

	cout << "short类型所占空间" << sizeof(short) << endl;
	cout << "int类型所占空间" << sizeof(int) << endl;
	cout << "long类型所占空间" << sizeof(long) << endl;
	cout << "longlong类型所占空间" << sizeof(long long) << endl;


	return 0;
}
 

实型（浮点型）

作用：用于表示小数

浮点型变量分为两种： 单精度float 和 双精度double ，两者的区别在与表示的有效数字范围不同

#include <iostream>
using namespace std;

int main() {

	// 定义一个float类型 注意： 如果数据后没有加f， C++平台默认为double类型， 加上f会变成float类型
	float num = 3.14f;

	cout << "float num = " << num << endl;

	double num1 = 3.14;
	cout << "double num1 = " << num1 << endl;

	// 通过运行结果我们可以发现 C++中最多只显示6为有效数字， 如果需要显示更多的有效数字，需要另外配置
	float num3 = 3.14159267832;
	cout << "float num3 = " << num3 << endl;

	double num4 = 3.14159267832;
	cout << "double num4 = " << num4 << endl;

	// 科学计算法来表示小数
	float num5 = 3e2; //  表示3 * 10^2  
	cout << "float num5 = " << num5 << endl;
	
	float num6 = 3e-2; // 表示3 * 0.1^2
	cout << "float num6 = " << num6 << endl;

	return 0;
}

字符型

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

语法： char ch = 'a';

注意1：在显示字符型变量时，用单引号将字符括起来，不要用双引号
注意2：单引号内只能有一个字符，不可以是字符串
C和C++中字符型变量只占用1字节
字符型量不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元

#include <iostream>
using namespace std;

int main() {

	char ch = 'a';
	
	cout << ch << endl;

	// char所占内存大小
	cout << "char占的内存大小:" << sizeof(char) << endl;	 

	// 字符型变量常见错误
	// char ch2 = "b"; // 创建字符型变量的时候，要使用单引号
	// char ch3 = 'abcedf' // 创建字符型变量时候， 单引号只能有一个字符

	return 0;
}

转义字符

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

现阶段我们常用的转义字符有： \n、\\、\t

字符串型

作用：用于表示一串字符

两种风格：

C语言字符串： char 变量名[] = "字符串值" （ 注意：C语言的字符串需要使用双引号括起来 ）
C++语言字符串： string 变量名 = "字符串值" ( 注意：C++字符串需要导入头文件 #include<string> )

#include <iostream>
using namespace std;
// C++使用字符串， 必须首先导入string的包
#include <string>

int main() {

	// 创建C语言风格的字符串
	char str[] = "hello world";

	cout << "C语言风格字符串：" << str << endl;

	// C ++ 风格的字符串
	string str2 = "C++ hello world";
	cout << "C++语言风格字符串：" << str2 << endl;
	
	return 0;
}
### 布尔类型bool
作用 ： 布尔值类型代表真或则假的值
bool类型只有两个值：
* true：  真（本质是1）
* false： 假（本质0）
* **bool类型占一个字节的大小**

```cpp
#include <iostream>
using namespace std;

int main() {

	bool flag = true;
	
	cout << "flag = " << flag << endl;
	cout << "bool值所占大小: " << sizeof(bool) << endl;

	return 0;
}

注意：在C++ 中非0的值都是真

数据的输入

作用：用于从键盘获取数据

关键字： cin

语法： cin >> 变量

#include <iostream>
using namespace std;

int main() {

	int a = 0;
	
	cout << "请输入一个int类型的值：" << endl;
	
	cin >> a;

	cout << "输入的值是： " << a << endl;

	return 0;
}

运算符

作用：用于执行代码的运算

算术运算符

作用：用于处理四则运算

算数运算符包含一下符号：

注意：C++中两个整数相除的结果依然是一个整数，会自动将小数部分去除

两个小数也是可以相除的，但是不可以取模（求余数%）：

#include <iostream>
using namespace std;

int main() {

	double d1 = 3.14;
	double d2 = 1.1;

	cout << "小数相处：" << d1 / d2 << endl;
	// 注意： 小数是不可以求余数（%）的

	return 0;
}

赋值运算符

作用：用于将表达式的值赋给变量

赋值运算符包括以下集合符号：

比较运算符

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

比较运算符有以下符号：

逻辑运算符

作用：用于根据表示式的值返回真值或假值。

程序流程结构

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

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

选择结构

if语句

作用：执行满足条件的语句

if语句的三种形式：

单行格式if语句： if（条件）{ 条件满足执行语句 }
多行格式if语句：
多条件if语句：

三目运算符

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

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

解释：

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

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

switch语句

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

switch（表达式）
{
	case 结果1： 执行语句； break；
	case 结果2： 执行语句； break；
	
	.....
	
	default: 执行语句； break；
	
}

if 和 switch区别
- switch缺点：判断时候只能是整形或者字符型，不可以是一个区间
- switch优点：结构清晰，执行效率高
注意：
- switch语句中表达式类型只能是整形或者字符型
- case里如果没有break，那么程序会一直向下执行
- 总结：与if语句相比，对于多条件执判断时，switch的结构清晰，执行效率高，缺点是switch不可以判断区间

循环结构

while循环

作用：满足循环条件，执行循环语句

语法： while（循环条件）{ 循环语句 }

解释：只要循环条件的结果为真，就执行循环语句

do…while循环

作用：满足循环条件，执行循环语句

语法: do { 循环语句 } while（循环条件）

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

for循环

作用：满足循环条件，执行循环语句

语法： for（起始表达式；条件表达式；末尾循环体）{ 循环语句 }

跳转语句

beak语句

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

break使用的时机：

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

continue 语句

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

goto语句

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

语法： goto 标记

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

#include <iostream>
using namespace std;

int main() {

	cout << "1" << endl;

	goto FLAG;

	cout << "2" << endl;

	cout << "3" << endl;
	
	FLAG :

	cout << "4" << endl;

	return 0;
}

注意：在程序中不建议使用goto语句，以免造成程序流程混乱

数组

概述

所谓数组，就是一个集合，里面存放了相同类型的数据元素

特点1：数组中的每个数据元素都是相同的数据类型

特点2：数组是由 连续的内存 位置组成的

一维数组

一维数组的定义

一维数组有如下三种定义方式：

#include <iostream>
using namespace std;

int main() {
	
	// 以为数组有三种定义方式

	//1. 数据类型 数组名[数组长度]
	int array[3];
	array[0] = 10;
	array[1] = 20;
	array[2] = 30;
	cout << "array数组元素如下：\n" << endl;
	for (int i = 0; i < 3; i++)
	{
		cout << array[i] << endl;
	}

	// 数据类型 数组名[数组长度] = { 10， 20， 30 }
	int array2[3] = { 40, 50, 60 };
	cout << "array2数组元素如下：\n" << endl;
	for (int i = 0; i < 3; i++)
	{
		cout << array2[i] << endl;
	}

	// 数据类型 数组名[] = { 10, 20, 30 };
	int array3[] = { 70, 80, 90 };
	cout << "array3数组元素如下：\n" << endl;
	for (int i = 0; i < 3; i++)
	{
		cout << array3[i] << endl;
	}

	return 0;
}

注意：

数据类型数组名[数组长度] = { 值1，值2，…}，也就是上述代码中第二种申明方式，如果在初始化数据的时候，没有全部填写完，会用0来填补剩余数据
数组名的命名规范和变量名命名规范一致，不要和变量重名
数组中下表是从0开始索引

一维数组的数组名

一维数组名的用途：

可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址

二维数组

二维数组的定义方式

#include <iostream>
using namespace std;

int main() {

	// 二维数组有四种定义方式

	//1. 数据类型 数组名[行数][列数]；
	int array[2][2];
	array[0][0] = 1;
	array[0][1] = 2;
	array[1][0] = 3;
	array[1][1] = 4;

	//  数据类型 数组名[行数][列数] = { {数据1,数据2}, {数据3, 数据4} };
	int array2[2][2] = { {1,2}, {3, 4} };

	// 数据类型 数组名[行数][列数] = { 数据1， 数据2， 数据3， 数据4 }
	int array3[2][2] = { 1, 2, 3, 4 };

	// 数据类型 数组名[][列数] = { 数据1， 数据2， 数据3， 数据4 }
	int array4[][2] = { 1, 2, 3, 4 };

	return 0;
}

建议：以上4种定义方式，利用第二种更加直观，提高代码的可读性

二维数组的名称

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

函数

函数的定义

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

函数值类型
函数名
参数列表
函数体语句
return 表达式

#include <iostream>
using namespace std;


int sum(int num1, int num2) {
	return num1 + num2;
}

int main() {

	/*
		函数返回值类型 函数名（参数列表）{
			
			函数体语句

			return 返回语句表达式
		}
	*/
	return 0;
}

函数的调用

功能：使用定义好的函数

语法： 函数名（参数）

#include <iostream>
using namespace std;

/*
	定义中的num1 和num2 称为形式参数 简称形参
*/

int total(int num1, int num2) {
	return num1 + num2;
}

int main() {

	int a = 10;
	int b = 20;
	// 调用时， a, b 称为实际参数， 简称实参

	cout << total(a, b) << endl;

	
	return 0;
}

值传递

所谓值传递，就是函数调用时实参将数值传入形参
值传递时，如果形参发生，并不会影响实参

#include <iostream>
using namespace std;

void swap(int num1, int num2) {
	cout << "num1 交换前的值：" << num1 << endl;
	cout << "num2 交换前的值：" << num2 << endl;

	int temp = num1;
	num1 = num2;
	num2 = temp;

	cout << "num1 交换后的值：" << num1 << endl;
	cout << "num2 交换后的值：" << num2 << endl;
}

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);

	cout << "a 交换后的值：" << a << endl;
	cout << "b 交换后的值：" << b << endl;


	return 0;
}

函数的常见样式

常见的函数样式有4种：

无参无返
有参无返
无参有返
有参有返

#include <iostream>
using namespace std;

// 无参无返
void test() {
	cout << "无参无返 test函数" << endl;
}

// 有参无返
void test2(int a) {
	cout << "有参无返 a:" << a << endl;
}

// 无参有返
int test3() {
	
	cout << "无参有返" << endl;
	return 2;
}

// 有参有返
int test4(int a, int b) {
	return a + b;
}

注意：无类型无法创建变量，因为无法分配内存

函数的声明

作用：告诉编译器函数名称如何调用函数，函数的实际主题可以单独定义。

函数的声明可以多次，但是函数的定义只能有一次

#include <iostream>
using namespace std;

// 函数的申明（提前告诉编译器函数的存在， 可以利用函数的申明）
int sum2 (int a, int b);
// 可以申明多次
int sum2(int a, int b);

int main() {


	return 0;
}

// 函数的定义
int sum2(int a, int b) {

	return a + b;
}

函数的分文件编写

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

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

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

// .h文件
#pragma once

#include <iostream>
using namespace std;

// 声明一个交换方法
void swap_test(int* a, int* b);

// .cpp的实现文件
#include "swap.h"

void swap_test(int* a, int* b) {
	cout << "交换之前的值a:" << *a << endl;
	cout << "交换之前的值b:" << *b << endl;

	int* temp = a;
	*b = *a;
	*a = *temp;

	cout << "交换之后的值a:" << *a << endl;
	cout << "交换之后的值b:" << *b << endl;
}

// 测试文件
#include <iostream>
using namespace std;
#include "swap.h"

int main() {

	// 调用函数
	int a = 10;
	int b = 20;

	swap_test(&a, &b);

	return 0;
}

输出结果：

指针

指针的基本概念

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

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

指针变量的定义和使用

指针变量的定义和语法： 数据类型 * 指针变量名

#include <iostream>
using namespace std;

int main() {

	//1.定义一个指针
	int a = 10;
	// 指针定义
	int* p;
	p = &a;

	cout << "a的地址为：" << &a << endl;
	cout << "指针p为： " << p << endl;
	return 0;
}

结果：

指针所占的内存空间

指针也是数据类型，那么这种数据类型占用多少内存空间？

#include <iostream>
using namespace std;

int main() {
	int a = 10;

	int* p;
	p = &a;

	cout << *p << endl;
	cout << sizeof(p) << endl;
	cout << sizeof(char*) << endl;
	cout << sizeof(float*) << endl;
	cout << sizeof(double*) << endl;

	return 0;
}

结果：

本次代码运行环境是在64位操作系统环境下进行的。

在32位操作系统下，指针是占4个字节空间大小，不管是什么数据类型
在64位操作系统下，指针是占8个字节空间大小

空指针和野指针

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

#include <iostream>
using namespace std;

int main() {

	// 指针变量p指向内存地址编号为0的空间
	int* p = NULL;

	// 访问空指针报错
	// 内存编号为0 ~ 255为系统所占用，不允许用户访问
	cout << *p << endl;

	// 野指针
	int* p1 = (int*)0x1100;

	//访问野指针报错
	cout << *p1 << endl;
	return 0;
}

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

const修饰指针

const 修改指针有三种情况：

const 修饰指针：常量指针
const 修饰常量：指针常量
const 即修饰指针，又修饰常量

#include <iostream>
using namespace std;

int main() {
	
	int a = 10;
	int b = 10;

	// const 修饰的是指针，指针指向可以改变，但是指针指向的值不可以改变
	const int* p = &a;
	p = &b; // 正确
	//*p = 100; // 报错

	// const 修饰的是常量， 指针指向不可以改变， 指针指向的值可以更改
	int* const p2 = &a;
	//p2 = &b; 错误
	*p2 = 100;// 正确

	// const 既修饰指针又修饰常量
	const int* const p3 = &a;
	//p3 = &b; 错误
	// *p3 = 100; 错误

	// const 既修饰指针又修饰常


	return 0;
}

总结：看const 右侧紧跟着是指针还是常量，是指针就是常量指针，是常量就是指正常量

指针和数组

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

#include <iostream>
using namespace std;

int main() {

	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr; // 指针指向数组的地址

	cout << "第一个元素：" << arr[0] << endl;
	cout << "指针访问第一个元素：" << *p << endl;

	for (int i = 0; i < 10; i++)
	{
		// 利用指针便利数组
		cout << *p << endl;
		p++;
	}

	return 0;
}

结果：

注意：数组名就是数组的首地址

指针和函数

作用：利用指针作函数参数，可以修改实参的值。

#include <iostream>
using namespace std;

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

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

int main() {

	int a = 10;
	int b = 20;

	swap(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "---------------------" << endl;
	swap2(&a, &b);

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

	return 0;
}

结果：

总结：如果不想修改实参，就用值传递，如果想修改实参，就用地址传递

结构体

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

结构体的定义和使用

语法： struct 结构体名 { 结构体成员列表 } ；

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

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

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

// 定义一个结构体
struct Student
{
	// 姓名
	string name;

	// 年龄
	int age;

	// 分数
	int score;
} s3; // 这是第三种方式创建结构体

int main() {

	//1. 创建一个结构体 (前面的struct 是可以省略的)
	struct Student s1;
	s1.name = "张三";
	s1.age = 18;
	s1.score = 99;

	cout << "姓名：" << s1.name << "年龄：" << s1.age << "分数：" << s1.score << endl;

	// 2. 第二种方式创建结构体
	Student s2 = { "李四", 19, 80 };

	cout << "姓名：" << s2.name << "年龄：" << s2.age << "分数：" << s2.score << endl;

	s3.name = "王五";
	s3.age = 30;
	s3.score = 100;
	cout << "姓名：" << s3.name << "年龄：" << s3.age << "分数：" << s3.score << endl;

	return 0;
}

结果：

注意：在C++中结构体创建的时候， struct关键字可以省略，但是定义的时候不能省略

总结1：定义结构体时的关键字是struct，不可省略
总结2：创建结构体变量时，关键字struct可以省略
总结3：结构体变量利用操作符 . 访问成员

结构体数组

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

语法： struct 结构体名数组名 [元素个数] = { {}, {}, {}}

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

// 定义一个结构体
struct Person
{
	string name;
	int age;
};

int main() {

	// 定义一个结构体数组名

	Person persons[] = { {"张三", 18 }, { "李四", 50 }, { "王五", 40 } };

	for (size_t i = 0; i < 3; i++)
	{
		cout << "姓名：" << persons[i].name << "年龄：" << persons[i].age << endl;
	}

	return 0;
}	

结果：

结构体指针

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

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

#include <iostream>
using namespace std;

// 定义一个结构体
struct Person1
{
	string name;
	int age;
};

int main() {

	// 定义一个结构体
	Person1 person = { "张三", 18 };

	// 申明一个结构体的指针
	Person1* p = &person;

	// 通过指针方法属性
	cout << "姓名：" << p->name << "  年龄：" << p->age << endl;



	return 0;
}

结果：

总结：结构体指针可以通过->操作符访问结构体的成员

结构体嵌套结构体

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

例如：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

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

// 定义一个学生结构体
struct Student
{
	string name;
	int age;
	int score;
};

// 定义换一个老师的结构体
struct Teacher
{
	int id;
	string name;
	Student stu;
};

int main() {

	// 创建一个老师结构体
	Teacher teacher;
	teacher.id = 1;
	teacher.name = "王老师";
	
	Student stu = { "张三",19,20 };
	teacher.stu = stu;

	cout << "老师姓名：" << teacher.name << "  老师教导的学生：" << teacher.stu.name << endl;

	return 0;
}

结果：

总结：在结构体中可以定义另一个结构体作为成员，用来解决实际问题。

结构体做函数参数

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

传递方式有两种：

值传递
地址传递

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

// 申明一个结构体
struct Person2
{

	string name;
	int age;
};


// 值传递
void printStudent(Person2 person) {

	person.name = "修改名称";

	cout << "姓名： " << person.name << "  年龄：" << person.age << endl;
}

// 指针传递
void printStudent2(Person2 *person) {

	person->name = "李四";

	cout << "姓名： " << person->name << "  年龄：" << person->age << endl;
}



int main() {

	// 创建一个结构体
	Person2 person = { "张三", 19 };
	
	printStudent(person);
	cout << "姓名：" << person.name << "   年龄：" << person.age << endl;

	printStudent2(&person);
	cout << "姓名：" << person.name << "   年龄：" << person.age << endl;

	return 0;
}

结果：

结构体中的const使用场景

作用：用const来放置

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

struct Person3
{
	string name;
	int age;
};

// 将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent3(const Person3* p) { // 加const防止函数体中的误操作
	//p->age = 100; // 操作失败，因为加了const修饰，一旦有修改操作就会报错，可以防止我们误操作
	cout << "姓名：" << p->name << "  年龄：" << p->age << endl;
}

int main() {
	Person3 person = { "张三", 19 };
	printStudent3(&person);

	return 0;
}

案例：通讯管理系统

系统中主要功能如下：

添加联系人：向通讯录中添加新人
显示联系人：显示通讯录中的所有联系人信息
删除联系人：按照姓名删除指定联系人信息
查找联系人：按照姓名查找指定联系人信息
修改联系人：按照姓名重新修改指定联系人
清空联系人：清空通讯录中所有信息
退出通讯录系统：退出当前使用的通讯录

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

//  定义一个宏
#define MAX 1000 // 最大数

// 定义联系人结构体
struct Person
{
	string name; //姓名
	// 性别： 1 男  2女
	int m_Sex;
	int m_Age;
	string m_Phone;
	string m_Addr;
};

// 定义通讯录看结构体
struct Addressbooks
{
	Person personArray[MAX]; // 通讯录中保存的联系人数组
	int m_Size; // 通讯录中的人员个数
}; 

// 添加一个人到通讯录
void addPerson(Addressbooks * p) {
	if (p->m_Size == MAX)
	{
		cout << "通讯录已满，无法在添加人员了" << endl;
		return;
	}
	else
	{
		// 姓名
		string name;
		cout << "请输入姓名：" << endl;
		cin >> name;
		p->personArray[p->m_Size].name = name;

		// 性别
		cout << "请输入性别：" << endl;
		cout << "男：1；女 ： 2" << endl;
		int gender = 0;
		while (true)
		{
			cin >> gender;
			if (gender == 1 || gender == 2)
			{
				p->personArray[p->m_Size].m_Sex = gender;
				break;
			}
			cout << "输入有误，请重新输入" << endl;
		}
		

		// 年龄
		int age;
		cout << "请输入年龄：" << endl;
		cin >> age;
		p->personArray[p->m_Size].m_Age = age;

		// 手机号
		string phone;
		cout << "请输入手机号码：" << endl;
		cin >> phone;
		p->personArray[p->m_Size].m_Phone = phone;

		//地址
		string address;
		cout << "请输入地址：" << endl;
		cin >> address;
		p->personArray[p->m_Size].m_Addr = address;

		p->m_Size += 1;

		cout << "添加成功" << endl;
		// 请按任意键继续
		system("pause");
		// 代表清屏操作
		system("cls");
	}
}

// 显示联系人
void showPerson(Addressbooks* p) {

	if (p->m_Size == 0)
	{
		cout << "您的通讯录还是空的，快去添加把！" << endl;
		return;
	}

	for (size_t i = 0; i < p->m_Size; i++)
	{
		cout << "姓名：" << p->personArray[i].name 
			 << "   性别：" << ((p->personArray[i].m_Sex == 1) ? "男" : "女") 
			 << "   年龄：" << p->personArray[i].m_Age 
			 << "   手机号码：" << p->personArray[i].m_Phone 
			 << "   地址：" << p->personArray[i].m_Addr << endl;
	}

	// 请按任意键继续
	system("pause");
	// 代表清屏操作
	system("cls");
}

int isExist(Addressbooks* p, string name) {
	int result = -1;
	// 根据姓名查找

	for (int i = 0; i < p->m_Size; i++)
	{
		if (p->personArray[i].name == name)
		{
			result = i;
			break;
		}
	}

	return result;
}

// 删除联系人
void deletePerson(Addressbooks* p) {
	
	cout << "请输入您要删除的联系人的名称：" << endl;
	string name;
	cin >> name;
	int result = isExist(p, name);

	if (result == -1) 
	{
		cout << "查无此人" << endl;
		return;
	}

	for (int i = result; i < p->m_Size; i++)
	{
		p->personArray[i] = p->personArray[i + 1];
	}
	p->m_Size--;
	cout << "删除成功" << endl;

	system("pause");
	system("cls");
}

void queryPerson(Addressbooks* p) {
	cout << "请输入您要查询人的姓名：" << endl;
	string name;

	cin >> name;
	int result = isExist(p, name);
	if (result == -1)
	{
		cout << "查无此人" << endl;
		return;
	}
	
	cout << "姓名：" << p->personArray[result].name
		<< "   性别：" << ((p->personArray[result].m_Sex == 1) ? "男" : "女")
		<< "   年龄：" << p->personArray[result].m_Age
		<< "   手机号码：" << p->personArray[result].m_Phone
		<< "   地址：" << p->personArray[result].m_Addr << endl;

	system("pause");
	system("cls");
}

// 显示按钮
void showMenu() {

	cout << "*********************************************" << endl;
	cout << "*****           1、添加联系人           *****" << endl;
	cout << "*****           2、显示联系人           *****" << endl;
	cout << "*****           3、删除联系人           *****" << endl;
	cout << "*****           4、查找联系人           *****" << endl;
	cout << "*****           5、修改联系人           *****" << endl;
	cout << "*****           6、退出联系人           *****" << endl;
	cout << "*****           0、退出通讯录           *****" << endl;
	cout << "*********************************************" << endl;
}

int main() {

	// 创建通讯录对象
	Addressbooks addressbooks;
	// 初始化结构体变量
	addressbooks.m_Size = 0;

	while (true)
	{
		showMenu();

		int select = 0;
		cout << "请输入您的选择：\n" << endl;
		cin >> select; 


		switch (select)
		{
		case 1:
			addPerson(&addressbooks);
			break;
		case 2:
			showPerson(&addressbooks);
			break;
		case 3:
			deletePerson(&addressbooks);
			break;
		case 4:
			queryPerson(&addressbooks);
			break;
		case 5:
			break;
		case 6:
			break;
		case 0:
			cout << "退出通讯录系统" << endl;
			return 0;
		default:
			break;
		}
	}
	

	// 请按任意键继续
	system("pause");
	
	return 0;
}

目录

C入门-基础语法

C++入门-基础语法

C++基础入门

helle world C++程序

变量

常量

关键字

标识符命名规则

数据类型

整型

sizeof关键字

实型（浮点型）

字符型

转义字符

字符串型

数据的输入

运算符

算术运算符

赋值运算符

比较运算符

逻辑运算符

程序流程结构

选择结构

if语句

三目运算符

switch语句

循环结构

while循环

do…while循环

for循环

跳转语句

beak语句

continue 语句

goto语句

数组

概述

一维数组

一维数组的定义

一维数组的数组名

二维数组

二维数组的定义方式

二维数组的名称

函数

函数的定义

函数的调用

值传递

函数的常见样式

函数的声明

函数的分文件编写

指针

指针的基本概念

指针变量的定义和使用

指针所占的内存空间

空指针和野指针

const修饰指针

指针和数组

指针和函数

结构体

结构体的定义和使用

结构体数组

结构体指针

结构体嵌套结构体

结构体做函数参数

结构体中的const使用场景

案例：通讯管理系统