c++ 基础入门

9 通讯录管理系统
- 1 系统需求

1 c++ 初始

编写一个c++ 程序分4个步骤

创建项目创建文件编写代码运行程序

1.1 hello word

#include <iostream>
using namespace std;

int main() {

	cout << "hello word" << endl;

	system("pause");
	return 0;
}

// cout << "hello word" << endl; 主要内容 其他的都是框架

1.2 注释

作用:注释是代码之母

语法:

1.单行注释使用 // 描述信息 作用:单行代码进行说明

2.多行注释 /*描述信息*/ 作用: 对该段代码进行说明

提示:编辑器在编译代码的时候,会忽略注释内容

示例:

#include <iostream>
using namespace std;

/*
	这是一个多行注释
	编译器不会执行
*/

// 单行注释

/*
	main是一个程序的入口
	每一个程序都必须有这么一个main函数
	有且只有一个
*/
int main() {
	cout << "hello word" << endl;	// 这是打印hello word
	system("pause");
	return 0;
}

1.3 变量

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

描述: c++ 所有的数据都会存在内存当中,变量存在的意义是方便我们操作内存的数据

图片描述:

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

示例:

int main() {
	cout << "hello word" << endl;	// 这是打印hello word
	int a = 10;
	cout << "a=" << a << endl;		// 输出a=10 文本
	system("pause");
	return 0;
}

1.4 常量

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

**定义: ** 定义常量有两种方式:

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

示例:

#include <iostream>
using namespace std;

// 1.常量的定义方式1
#define Day 7


void main() {
	// 2.常量的定义方式2
	const int c = 16;
	cout << "is:" << Day << endl;
	cout << "is:" << c << endl;
	system("pause");
}

提示: 常量修改会报错

1.5 关键字

C++ 的关键字（保留字）完整介绍 | 菜鸟教程 (runoob.com)

1.6 命名规范

c++ 命名规范 - 知乎 (zhihu.com)

2 数据类型

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

2.1 整型

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

c++ 中能顾表示整型的列席有以下几种方式,区别在于所占内存空间不同

short 短整型 2字节

int 整型 4字节

long 长整型 4字节 linux 64位 8字节

long long 长长整型 8 字节

#include <iostream>
using namespace std;
void main() {
	// 数据类型存在的意义
	// 给变量分配合适的内存空间

	// 1. 短整型			-32768  ~  32767
	short num1 = 36000;		// 如果大于32767 会回到-号开始
	
	// 2. 整型
	int num2 = 10;

	// 3. 长整型
	long num3 = 10;

	// 4. 长长整型
	long long num4 = 10;

	cout << "num1=" << num1 << endl;
	cout << "num2=" << num2 << endl;
	cout << "num3=" << num3 << endl;
	cout << "num4=" << num4 << endl;

	system("pause");
}

2.2 sizeof关键字

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

语法: sizeof(数据类型/变量)

示例:

#include <iostream>
using namespace std;
void main() {
	// 数据类型存在的意义
	// 给变量分配合适的内存空间

	// 1. 短整型			-32768  ~  32767
	short num1 = 36000;		// 如果大于32767 会回到-号开始

	// 2. 整型
	int num2 = 10;

	// 3. 长整型
	long num3 = 10;

	// 4. 长长整型
	long long num4 = 10;

	cout << "num1=" << sizeof(num1) << endl;
	cout << "num2=" << sizeof(num2) << endl;
	cout << "num3=" << sizeof(num3) << endl;
	cout << "long long=" << sizeof(long long) << endl;

	system("pause");
}

2.3 实型(浮点型)

作用: 用于表示小数

浮点类型变量分为两种:

1.单精度 float

2.双精度 double

#include <iostream>
using namespace std;
void main() {
	// 1.单精度 float
	// 2.双精度 double

	float f1 = 3.1415926535f;		// 不加f计算机第一时间会认为是double类型
	// 如果数据超过7位有效数字 那么 后面的都会省略 四舍五入 
	cout << "f1 = " << f1 << endl;
	cout << "f1 size= " << sizeof(f1) << endl;			// 4

	double d1 = 3.14;		// 有效数字 15-16
	cout << "d1 = " << d1 << endl;
	cout << "d1 size = " << sizeof(d1) << endl;      // 8
	system("pause");
	// 默认情况下 输出一位小数 ,只会显示6位有效数字 
}

科学计数法

// 科学计数法
float f2 = 3e2f;    // 3* 10 ^2    e后是正数那么就是10的*次方
float f3 = 3e-2f;    // 3* 0.1 ^2  e后是负数那么就是0.1的*次方

2.4 字符型

作用: 字符类型变量用于显示当个字符

语法: char ch = 'a'

注意1:在显示字符型变量时,用单引号,不要用双引号

注意2: 单引号只能有一个字符,不能是字符串

c和c++中字符型变量只占1个字节

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

#include <iostream>
using namespace std;
void main() {
	// 1. 字符类型变量创建方式
	char ch = 'a';
	cout << ch << endl;
	// 2. 字符类型变量所占内存大小
	cout << sizeof(ch) << endl;			// 1个字节
	// 3. 字符型变量错误
		// 1. '' 号   2. 只有有一个
	// 4. 字符型变量对应ASCII编码
	cout << (int)ch << endl;
	system("pause");
}

ASCII 对应十六进制:

0-9 48-57

A-Z 65-90

a-z 97-122

2.5 转义字符

\a 响铃(BEL) 007
\b 退格(BS) 008
\f 换页(FF) 012
\n 换行(LF) 010
\r 回车(CR) 013
\t 水平制表(HT) 009
\v 垂直制表(VT) 011
\ 反斜杠 092
? 问号字符 063
' 单引号字符 039
" 双引号字符 034
\0 空字符(NULL) 000
\ddd 任意字符三位八进制
\xhh 任意字符二位十六进制

2.6 字符串类型

作用:用于表示一串字符串

两种风格:

C风格字符串 char 变量名[] = "字符串";

示例:
```
char st1[] = "hello word ";
```
1. C++风格字符串

示例:

#include <iostream>
#include <string>
using namespace std;
void main() {
	string str1 = "hello word";
	system("pause");
}

2.7 布尔类型

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

bool类型有两个值:

true -- 真 -- 1
false -- 假 -- 0

bool 占1个字节大小

#include <iostream>
using namespace std;
void main() {
	// 1 .bool 数据类型 定义
	bool flag = true;
	cout << flag << endl;  // 1
	flag = false;
	cout << flag << endl;  // 0
	// 2. bool数据类型占用内存空间
	cout << sizeof(flag) << endl;
}

2.8 数据的输入

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

关键字: cin

语法: cin >> 变量

#include <iostream>
using namespace std;
void main() {
	// 整型输入
	int a = 0;
	cout << "请输入整型变量" << endl;
	cin >> a;
	cout << a << endl;

	// 浮点型输入
	float f1 = 0;
	cout << "请输入浮点数变量" << endl;
	cin >> f1;
	cout << f1 << endl;

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

}

3 运算符号

作用: 执行代码的运算

算数运算符赋值运算符比较运算符逻辑运算符

3.1 算数运算符

 +  - * / % ++ --

两个整数相除得到的值为整数

#include <iostream>
using namespace std;
void main() {
	// 前置递增 先让变量 + 1 后做表达式运算
	int a = 10;
	int b = ++a * 10;  // 11 * 10 = 110
	cout << b << endl;
	// 后置递增 先表达式运算 后 +1

	int a2 = 10;
	int b2 = a2++ * 10; // 10*10 得到的值给了b2 后 a2 变 11
	cout << b2 << endl;
}

3.2 赋值运算符

= += -= *= /=  %=

3.3 比较运算符

== > < != >= <=

3.4 逻辑运算符

非 > 与 > 或

! && ||

在c++中只要不是0都等于真 !!a 双重否定等于真

4 程序流程结构

c++ 支持最基本的三种程序运行结构: 顺序结构,选择结构,循环结构

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

4.1 选择结构

4.1.1 if语句

作用: 满足条件时执行

#include <iostream>
using namespace std;
void main() {
	int score = 0;
	cin >> score;
	if (score >= 350 ) {
		cout << "一本大学" << endl;
	}
	else if(score < 350 &&  score > 0){
		cout << "不行呀" << endl;
	}
	else {
		cout << "输入错误" << endl;
	}
}

4.1.2 三目运算符

语法: 表达式1 ? 表达式2 : 表达式3

如果表达式1的值为真那么执行表达式2,否则执行表达式3

	int a = 10;
	int b = 15;
	int c = 0;
	c = a > b ? a : b;
	cout << c << endl;

	// 在c++ 中三目运算符返回的是变量 ,可以继续赋值操作
	a > b ? a : b = 100;   // 根据最后的条件赋值

4.1.3 switch

switch (表达式){
    case  结果1:
        执行语句;
        break;
    case  结果2:
        执行语句;
        break;
    case  结果3:
        执行语句;
        break;
    default:
        执行语句;
        break;
}

4.1.4 循环结构

while

while(条件){}

int a = 15;
int b;
while (true) {
	cout << "输入:";
	cin >> b;
	if (b > a) {
		cout << "大了" << endl;
	}
	else if (b < a ) {
		cout << "小了" << endl;
	}
	else if (b == a) {
		cout << "猜对了" << endl;
		break;
	}
}

随机数生成

rand()%100+1; 		//  0-100随机数字

2.do while

do{循环语句}while(条件);

注意: 与while 的区别在于 do.. while 会先执行一次循环体 然后在判断

3.for

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

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

break continue 跳出循环...

4 .goto

Flag: // 标记

goto Flag; // 跳转到Flag

5 数组

就是一个集合,里面存放了相同类型的元素

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

特点2:数组是有连续的内存位置组成的

5.2一维数组

一维数组的定义方式三种:

数据类型数组名称[数组长度];
数据类型数组名称[数组长度] = {值1,值2,值3}
数组类型数组名称 [] = {值1,值2, 值3 ...}

#include <iostream>
using namespace std;
void main() {
	// 1. 可以通过数组名统计整个数组占用内存大小
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << "整个数组占用内存空间:" << sizeof(arr)<< endl;
	cout << "每个元素占用内存空间:" << sizeof(arr[0]) << endl;
	cout << "数组中元素个数:"<< sizeof(arr)/sizeof(arr[0]) << endl;


	// 2. 可以通过数组名查看数组首地址
	cout << "数组首地址为:" << (int)arr<< endl;   // 16进制转10进制
	cout << "数组第一个元素地址为:" << (int)&arr[0]<< endl;   // 16进制转10进制  和首地址一样
	cout << "数组第二个元素地址为:" << (int)&arr[1]<< endl;   // 加&拿到地址  两位相差4个

	// 数组名是常量,不可以进行赋值操作
	// arr = 100; // 报错!!

}

取址符号 &

5.3 二维数组

二维数组定义的4种方式

1. `数据类型 数组名 [行] [列]`
1. `数据类型 数组名 [行] [列] = {{数据1,数据2}{数据1,数据2}}`
1. `数据类型 数组名 [行] [列] = {数据1,数据2,数据3,数据4}`
1. `数据类型 数组名 [] [列] = {数据1,数据2,数据3,数据4}`

第二种方法更直观!

int arr2[2][3] = {
		{1,2,3},
		{4,5,6}
	};
	for (int i = 0; i < 2; i++)
	{
		for (int j = 0; j < 3; j++)
		{
			cout << arr2[i][j] << "  ";
		}
		cout << endl;
	};

5.4 二维数组名

查看二维数组所占内存空间

int arr2[2][3] = {
    {1,2,3},
    {4,5,6}
};
cout << "整个数组占用内存空间:" << sizeof(arr2) << endl;
cout << "单行占用:" << sizeof(arr2[0]) << endl;
cout << "单元素占用:" << sizeof(arr2[0][0]) << endl;
cout << "长度:" << sizeof(arr2) / sizeof(arr2[0][0]) << endl;

// 以上得知 行 和 列 12/4 = 3列

获取二维数组首地址

cout << "数组首地址为:" << (int)arr2 << endl;   // 16进制转10进制
cout << "数组第一个元素地址为:" << (int)&arr2[0][0] << endl;   // 16进制转10进制  和首地址一样
cout << "数组第二个元素地址为:" << (int)&arr2[0] [1]<< endl;   // 加&拿到地址  两位相差4个

6 函数

6.1 概述

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

6.2 函数定义

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

返回值
函数名
参数列表
函数体
return 表达式

语法:

返回值类型 函数名 (参数列表){
    函数体
   	return 表达式;
}

#include <iostream>
using namespace std;

// 函数定义
// 语法:
//  返回值 函数名 (参数列表)  {函数体 return表达式}

// 加法函数,实现两个int相加,并返回结果
int add(int num1,int num2) {
	return num1 + num2;
}

void  mian() {
	system("pause");
}

6.3 函数的调用

功能:使用写好的函数

语法;函数名();

示例:

#include <iostream>
using namespace std;

// 函数定义
// 语法:
//  返回值 函数名 (参数列表)  {函数体 return表达式}

// 加法函数,实现两个int相加,并返回结果
int add(int num1, int num2) {
	int sum = num1 + num2;
	return sum;
}

int  main1() {
	int sum = add(15,20);
	cout << sum << endl;
	system("pause");
	return 0;
}

6.4 值传递

6.5 函数的常见样式

无参无反
无参有反
有参无反
有参有反

6.6 函数的声明

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

告诉编译器有这个函数的存在编译型语言从上向下读如果放到main后面的话需要声明告诉他有这个函数

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

// 声明 声明可以有多次 定义只能有一次
int max(int a,int b);
int max(int a,int b);


// 定义
int max(int a,int b){
    return a > b? a:b;
}

6.7 函数的分文件编写

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

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

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

// 头文件
#pragma once
int add(int num1, int num2);

// cpp
#include <iostream>
using namespace std;
#include "swap.h"
// 加法函数,实现两个int相加,并返回结果
int add(int num1, int num2) {
	int sum = num1 + num2;
	cout << (int)&num1 << endl;
	cout << (int)&num2 << endl;

	//
	return sum;
}

// main
#include <iostream>
using namespace std;
#include "swap.h"
// 函数定义
// 语法:
//  返回值 函数名 (参数列表)  {函数体 return表达式}

int  main() {
	int a = 15;
	int b = 20;
	int sum = add(a,b);
	cout << (int)&a << endl;
	cout << (int)&b << endl;
	cout << sum << endl;
	system("pause");
	return 0;
}

7 指针

7.1 指针的基本概念

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

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

7.2 指针变量的定义和使用

指针变量定义语法: 数据类型 * 变量名

#include <iostream>
using namespace std;

void main() {
	// 1.定义一个指针
	int a = 10;
	// 我们需要定义一个指针指向a的地址
	int* p;
	p = &a;
	// 打印查看地址是否相同 相同 
	cout << &a << endl;			// 0000000B5CDCF7F4
	cout << p << endl;				// 	0000000B5CDCF7F4

	// 2.使用指针
	// 可以通过解引用方式来找到指针指向的内存
	// 指针前面加 * 代表解引用,找到指针指向的内存数据
	*p = 100;
	cout << *p << endl;
	cout << a << endl;

	// 最后结果都是100 是通过内存地址直接操作数据的
}

解引用 : *指针即可拿到指针对应内存的数据

7.3 指针所占内存空间

提问: 指针也是种数据类型,那么这种数据类型占用多少内存?

存的是十六进制数据

#include <iostream>
using namespace std;

void main() {
	int a = 10;
	int* p &a;
	cout << sizeof(p) << endl;
	cout << sizeof(char *) << endl;
	cout << sizeof(double *) << endl;
	cout << sizeof(float * ) << endl;
	cout << sizeof(short * ) << endl;
	cout << sizeof(long * ) << endl;
	cout << sizeof(long long * ) << endl;
	cout << sizeof(string * ) << endl;
	// 32 位操作系统是 4 个字节
	// 64 位操作系统是 8 个字节
}

7.4 空指针和野指针

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

用途:初始化指针变量

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

示例:

int main(){
    // 指针变量p指向内存地址编号为0的空间
    int *p = NULL; 
    
    // 访问空指针报错!
    // 内存编号0-255为操作系统占用内存,不允许用户访问
    cout << *p << endl;
}

内存编号0-255为操作系统占用内存,不允许用户访问

野指针: 指针变量指向非法的内存空间

示例2

int main(){
    // 指针变量p指向内存地址编号为0x1100的空间
    int *p = (int *)0x1100;
    
    // 访问野指针报错!
	cout << *P << endl;
}

需要申请才能使用

7.5 const修饰指针

const修饰指针的三种情况

const修饰指针 --- 常量指针
const修饰常量 --- 指针常量
const即修饰指针 ,又修饰常量

int main(){
    int a = 10;
    int b = 10;
    
    // const 修饰的是指针,指针指向可以修改,指针指向的值不可修改
    const int*p = &a;
    p = &b // 正确
    *p = 200; // 错误
    
    // const修饰的是常量 指针指向不可修改 ,指针指向的值可以修改
    int * const p2 = &a;
    *p2 =  500; // 正确
    p2 = &b // 错误
        
    const int * const p = &a;
}

7.6 指针和数组

作用: 利用指针访问数组元素

int main(){
    int arr[] = {1,2,3,4,5,6,7,8,9,10}
    int * p = arr; 	// 指向arr地址
    
    cout << "第一个元素:" << arr[0] <<endl;				
    cout << "指针访问第一个元素:" << *p <<endl;		  // 首地址
    // 数组中 第一个元素地址和数组地址一样
    
    // 利用遍历来访问
    for (int i = 0; i < (sizeof(arr) / sizeof(arr[0]));i++) {
        cout << *p << endl; // 解引用拿到值
        p++;  // 指针++ 每次递增 4 个字节 本身是int指针 所以 向后移动是int大小
    }
}

7.7 指针和函数

作用: 利用指针做函数参数,可以修改实参的值

示例:

// 地址传递
void swap(int * p , int * p2){
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

void main(){
    int a = 10;
    int b = 15;
    // int * p = &a;
    // int * p2 = &b
    swap(&a,&b);
}

7.8 指针,数组,函数

指针排序算法

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

案例:

// 手敲版

#include <iostream>

using namespace std;
void maopao(int* p, int len);

void main() {
	int arr[] = { 4,3,6,9,1,2,10,8,7,5,9 };
	maopao(arr,sizeof(arr)/sizeof(arr[0]));
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		cout << arr[i] << endl;
	}
}

// 排序算法
void maopao(int * p, int len ) {
	// 拿到第一个和第二个做比较 然后 大于的向后放 每次
	int* res = p;
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (*p >= *(p + 1)) {
				int temp = *p;
				*p = *(p + 1);
				*(p + 1) = temp;
			}
			p++;
		};
		p = res;
	}
	
}

// 标准
void sort(int * arr,int len){	// int * arr 也可以写成 int arr[]
    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+1];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

8 结构体

8.1 结构体基本概念

作用: 结构体数据用户自定义数据类型,允许用户储存不同的数据类型

8.2 结构体定义和使用

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

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

struct 结构体名变量名 struct可以省略
struct 结构体名变量名 = {成员1值,成员2值} struct可以省略
定义结构体时随便创建变量

示例:

// 结构体定义
struct student{
    // 成员列表
    string name; // 姓名
    int age; 		// 年龄
    int score;		// 分数
}

#include <iostream>
using namespace std;

// 自定义数据类型
struct Student {
	// 成员列表
	string name;	// 姓名
	int age;				// 年龄
	int score;			// 分数
	bool gender;	// 性别

	
}s3;  // 顺便创建一个结构体变量 ****



void main() {
	// 1. 创建学生数据类型 : 学生包括: (姓名 ,年龄, 性别,成绩)

	// 通过学生类型创建具体类型   ****
	// 2.1 struct Student s1;
	struct Student s1;
	// 给s1属性赋值
	s1.name = "张三";
	s1.age = 15;
	s1.score = 99;
	s1.gender = true;
	cout << s1.name << s1.age << s1.score << s1.gender << endl;
	// 2.2 struct Student s2 = {....};  ****
	struct Student s2 = { "李四",18,95,false };
	cout << s2.name << s2.age << s2.score << s2.gender << endl;
	// 2.3 定义结构体是顺便创建一个结构体的变量
}

8.3 结构体数组

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

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

示例:

#include <iostream>
using namespace std;

// 1.定义一个结构体
struct Student {
	// 成员列表
	string name;	// 姓名
	int age;				// 年龄
	int score;			// 分数
};

void main() {
	// 结构体数组

	// 2.创建一个结构体的数组
	struct Student stuArray[3] = {
		{"张三",18,100},
		{"李四",16,98},
		{"王五",17,60}
	};
	// 3.给这个结构体的数组元素进行赋值
	
	// 4. 遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名:" << stuArray[i].name << " 年龄" << stuArray[i].age << " 分数" << stuArray[i].score << endl;

	}
}

8.4 结构体指针

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

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

案例:

#include <iostream>
using namespace std;

// 1.定义一个结构体
struct Student {
	// 成员列表
	string name;	// 姓名
	int age;				// 年龄
	int score;			// 分数
};

void main() {

	// 1. 创建一个结构体变量
	struct Student s1 = {"张三",18,50};

	// 2. 通过指针指向结构体变量
	struct Student* p = &s1;
	// Student* p = &s1;

	// 3. 通过指针访问结构体变量中的数据
	cout << p->name << endl;
	cout << p->age << endl;
	cout << p->score << endl;
}

通过结构体指针访问结构体属性使用你-> 访问!!!!

8.5 结构体嵌套结构体

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

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

示例:

#include <iostream>
using namespace std;

// 1.定义一个结构体
struct Student {
	// 成员列表
	string name;	// 姓名
	int age;				// 年龄
	int score;			// 分数
};

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

void main() {

	Teacher t;
	t.age = 18;
	t.name = "王老师";
	t.id = 1;
	t.s = { "小明",18,99 };
	cout << t.s.age << endl;
	struct Teacher * p = &t;
	struct Student* p2 = &(p->s);
	cout << p2->age << endl;
}

8.6 结构体做函数参数

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

传递方式: 值传递地址传递

void printStudent(struct Student s) {
	// 修改值本身不会改变
	cout << s.age << endl;
}

void printStudent(struct Student* p) {
	// 修改值本身会改变
	cout << p->age <<  endl;
}

8.7 结构体中const使用场景

作用:用const来防止误操作

示例:

#include <iostream>
using namespace std;

// const使用场景:防止错误操作
struct Student {
	string name;
	int age;			
	int score;			
};


void printStudent(const struct Student * p ) {
	// 这里就修改不了数据了 是个常量指针 只能修改指针不能修改常量
	// 测试修改指针指向可以不
	// 测试结果人傻了! 传递进来的是 指针p1 他也会copy一份 里面所有操作都是 copy p1的地址 只是指向的值一样
	cout <<"修改前指针地址:" << p << endl;
	struct Student s2 = { "Dragon",18,20 };
	p = &s2;
	cout <<"函数内修改后指针地址:"  <<  p << endl;

}

void main() {
	struct Student s1 = { "Ben",18,20 };
	Student* p1 = &s1;
	printStudent(p1);
	cout << "函数外修改后指针地址:" << p1 << endl;
}

8.8 结构体案例

#include <iostream>
#include "swap.h"
using namespace  std;


// 学生结构体
struct student {
	int name;
	int score;

};


// 老师结构体
struct teacher {
	string name;
	// 使用 结构体指针数组存放学生信息
	student arr[5];
};

void GenStudent(struct student s) {
	cout <<"函数内部地址" <<  & s << endl;
}

void main() {
	/*
	学校毕业设计,每名老师带5个学生,总共3名老师,需求如下
		设计学生和老师的结构体
		其中老师的结构体中,有老师姓名和一个存放5名学生的数组做成员
		学生的成员有 姓名,考试分数,创建3名数组存放老师,通过函数给每个老师及所带的学生进行赋值
		最终打印老师数据以及老师带的学生数据
	*/
	
	// 创建3个老师
	struct teacher teacherAll[3] = {
		{"王老师"},
		{"刘老师"},
		{"张老师"}
	};

	// 创建15个学生并给老师们添加下方
	int teacherLen = sizeof(teacherAll) / sizeof(teacherAll[0]);
	for (int i = 0; i < teacherLen; i++)
	{
		// 每次添加5个
		for (int j = 0; j < 5; j++)
		{
			 student s =  {( i+1)*( j+1),18 + (j+1)*(i+1) };
			teacherAll[i].arr[j] = s;

		}
	}

	for (int i = 0; i < teacherLen; i++)
	{
		cout << "我是" << i << "老师" << "我的学生有" << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "我叫" << teacherAll[i].arr[j].name << "分数是:" << teacherAll[i].arr[j].score << endl;
		}
		cout << "===============" << endl;
	}



}

案例2 结构体排序

#include <iostream>
#include "swap.h"
using namespace  std;
/*
	设计一个英雄结构,包括成员姓名,年龄,性别,创建结构体数组,数组中存放5名英雄
	通过冒泡怕徐算法,将数组中的英雄安装年龄升序,最终打印
*/

struct person {
	string name;
	int age;
	string gender;
};
void main() {
	person Aperson[5] = {
		{"刘备",23,"男"},
		{"关羽",56,"男"},
		{"张飞",18,"男"},
		{"马超",21,"男"},
		{"黄忠",33,"男"},
	};
	// 冒泡排序
	// len = 5
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 4-i; j++)
		{
			if (Aperson[j].age > Aperson[j+1].age) {
				person temp = Aperson[j];
				Aperson[j] = Aperson[j + 1];
				Aperson[j + 1] = temp;
			}
		}
	}

	for (int i = 0; i < 5; i++)
	{
		cout << Aperson[i].age << endl;
	}

}

9 通讯录管理系统

1 系统需求

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

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

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

#include <iostream>
#define MAX 1000
using namespace std;


/// <summary>
/// 人员结构体
/// </summary>
struct Person
{
	string m_name;
	int m_Gender;
	int m_Age;
	string m_Mobile;
	string m_Addr;
};

/// <summary>
/// 通讯录结构体
/// </summary>
struct AddresBooks {
	struct Person m_personArr[MAX];
	int m_Size;   // 通讯录中人员个数
};

/// <summary>
/// 用户选择页面
/// </summary>
void showMenu() {
	cout << "*****************************" << endl;
	cout << "*****    1.添加联系人   *****" << endl;
	cout << "*****    2.显示联系人   *****" << endl;
	cout << "*****    3.删除联系人   *****" << endl;
	cout << "*****    4.查找联系人   *****" << endl;
	cout << "*****    5.修改联系人   *****" << endl;
	cout << "*****    6.清空联系人   *****" << endl;
	cout << "*****    7.退出通讯录   *****" << endl;
	cout << "*****************************" << endl;
};


/// <summary>
/// 添加联系人
/// </summary>
void addPerson(AddresBooks * p) {

	// 判断通讯录满了没
	if (p->m_Size == MAX) {
		cout << "通讯录已满,无法添加" << endl;
		return;
	}
	// 创建一个人员结构体
	Person ps;
	cout << "输入姓名:";
	cin >> ps.m_name;
	cout << "输入性别:";
	cin >> ps.m_Gender;
	cout << "1-男  2-女" << endl;
	cout << "输入年龄:";
	cin >> ps.m_Age;
	cout << "输入电话:";
	cin >> ps.m_Mobile;
	cout << "输入地址:";
	cin >> ps.m_Addr;
	// 输入完毕后添加到通讯录
	p->m_personArr[p->m_Size] = ps;
	// 修改size = 1;
	p->m_Size++;
	// 添加成功清屏
	system("cls");
}


void showPerson(AddresBooks * p_abs) {
	for (int i = 0; i < p_abs->m_Size; i++)
	{
		cout << "	姓名: " << p_abs->m_personArr[i].m_name;
		switch (p_abs->m_personArr[i].m_Gender)
		{
			case 1:
				cout << "	性别: 男";
				break;
			case 2:
				cout << "	性别: 女";
				break;
		}
		cout << "	年龄: " << p_abs->m_personArr[i].m_Age;
		cout << "	电话: " << p_abs->m_personArr[i].m_Mobile;
		cout << "	地址: " << p_abs->m_personArr[i].m_Addr << endl;
		cout << "" <<endl;

	}
}


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

void deletePerson(AddresBooks * abs) {
	cout << "请输入删除联系人名字" << endl;
	string name;
	cin >> name;
	int ret = isExist(abs,name);
	if (ret == -1) {
		cout << "查无此人" << endl;
		return;
	}
	else {
		for (int i = ret; i <= abs->m_Size; i++)
		{
			abs->m_personArr[i] = abs->m_personArr[i + 1];
		}
		abs->m_Size--;
	}
	system("cls");
}


void checkPerson(AddresBooks * p_abs) {
	cout << "输入查找联系人名字:";
	string name;
	cin >> name;
	int ret = isExist(p_abs, name);
	if (ret == -1) {
		cout << "查无此人" << endl;
		return;
	}
	else {
		cout << "	姓名: " << p_abs->m_personArr[ret].m_name;
		switch (p_abs->m_personArr[ret].m_Gender)
		{
		case 1:
			cout << "	性别: 男";
			break;
		case 2:
			cout << "	性别: 女";
			break;
		}
		cout << "	年龄: " << p_abs->m_personArr[ret].m_Age;
		cout << "	电话: " << p_abs->m_personArr[ret].m_Mobile;
		cout << "	地址: " << p_abs->m_personArr[ret].m_Addr;
	}
	system("cls");
}


void updatePerson(AddresBooks * abs) {
	cout << "输入查找联系人名字:";
	string name;
	cin >> name;
	int ret = isExist(abs, name);
	if (ret == -1) {
		cout << "查无此人" << endl;
		return;
	}
	else {
		// 创建一个人员结构体
		Person ps;
		cout << "输入姓名:";
		cin >> ps.m_name;
		cout << "输入性别:";
		cin >> ps.m_Gender;
		cout << "1-男  2-女" << endl;
		cout << "输入年龄:";
		cin >> ps.m_Age;
		cout << "输入电话:";
		cin >> ps.m_Mobile;
		cout << "输入地址:";
		cin >> ps.m_Addr;
		// 输入完毕后添加到通讯录
		abs->m_personArr[ret] = ps;
		// 添加成功清屏
		system("cls");
	}
	system("cls");
}


void clearPerson(AddresBooks * abs) {
	abs->m_Size = 0;
	system("cls");

}

/// <summary>
/// 主函数
/// </summary>
/// <returns></returns>
int main() {
	//创建一个通讯录结构体
	AddresBooks Abs;
	// 初始化通讯录数据 
	Abs.m_Size = 0;

	int select = 0;
	while (true) {
		showMenu();
		cin >> select;
		switch (select) {
			
			case 1: // 添加联系人
				addPerson(& Abs);   // 使用地址传递 修改实参数
				break;
			
			case 2: // 显示联系人
				showPerson(& Abs);
				break;

			
			case 3: // 删除联系人
				deletePerson(&Abs);
				break;

			
			case 4: // 查找联系人
				checkPerson(&Abs);
				break;

			
			case 5: // 修改联系人
				updatePerson(&Abs);
				break;

			
			case 6: // 清空联系人
				clearPerson(&Abs);
				break;

			
			case 7: // 退出通讯录
				cout << "欢迎下次使用!" << endl;
				system("pause");
				return 0;
				break;

		}
	}
	return 0;
}

相关阅读:
selenium获取Cookie操作
 分布式锁-常用技术方案
 合成模式(Composite)-结构型
 享元模式-结构型
 桥接模式-结构型
 适配器模式-结构型
 建造者模式-创建型
 单例和原型模式-创建型
 外观(门面)模式-结构型
 JDK QUEUE队列
原文地址：https://www.cnblogs.com/lddragon/p/16047865.html