C++基础
当时agent还没开始时，都在看编程语言。这是学习的C++
·
第一个C++程序
#include <iostream>
using namespace std;
int main()//main是一个程序的入口 每个程序都必须有 有且仅有一个
{
cout<<"hello world"<<endl;
system("pause");//暂停
}
基本概念
注释
单行注释 //
多行注释 /* */
变量
作用：给一段指定的内存空间起名，方便操作这段内存
语法：数据类型 变量名 = 初始值；
C++在创建变量时，必须给变量一个初始值，否则会报错
#include <iostream>
using namespace std;
int main()
{
int a = 10;
cout<<"a="<<a<<endl;//10
system("pause");
return 0; //每一个c++需要一个返回值 return 0
}
常量
作用：用于记录程序中不可更改的数据
-
#define宏常量：#define 常量名 常量值- 通常定义在文件上方
-
const修饰的变量const数据类型 常量名=常量值- 通常在变量定义前加上关键字
const，修饰该变量为常量，不可修改
- 通常在变量定义前加上关键字
//1、宏常量
#define Day 7
int main(){
//Day=14;//错误 Day是常量 不可修改
cout<<"一天总共有："<<Day<<"天"<<endl;
//2.const修饰变量
const int month = 12;
//month = 24; //报错，常量是不可以修改的
return 0;
}
关键字
- 系统征用 C++中预先保留的单词（标识符）
- 在定义变量和常量时，不用关键字给变量或者常量起名称
标识符
- 标识符不能是关键字
- 标识符只能由字母、数字、下划线组成
- 第一个字符必须是字符或下划线
- 标识符中字母区分大小写
数据类型
C++规定在创建一个变量或者常量时，必须要指定出相应的数据类型，否则无法给变量分配内存
整型
sizeof关键字
作用：利用sizeof关键字可以统计数据类型所占内存大小
语法：sizeof(数据类型/变量)
short < int <= long <= long long
实型(浮点型)
作用：用于表示小数
int main(){
float f1 = 3.14f;
double d1 = 3.14;
cout << f1 << endl;
cout << d1 << endl;
cout << "float sizeof=" << sizeof(f1) << endl;//4
cout << "double sizeof=" << sizeof(d1) << endl;//8
//科学计数法
float f2 = 3e2;//3 * 10 ^ 2
float f3 = 3e-2;//3 * 0.1 ^ 2
return 0;
}
字符型
作用：字符型变量用于显示单个字符
语法：char ch = 'a';
- 字符型变量只占用1个字符
- 字符型变量不是把字符本身放到内存中，而是将ASCII编码放入到存储单元中
int main(){
char ch = 'a';
cout << ch << endl; // a
cout << sizeof(char) << endl; //1
//ch = "a";//错误，不可以使用双引号
//ch = 'abcd';//单引号只能引用一个字符
cout<<(int)ch<<endl;//查看字符a对应的ASCII码 97
return 0;
}
转移字符
作用：表示不能显示出来的ASCII字符
\n 换行
\\ 反斜杠
\t 制表位
字符串型
作用：用于表示一串字符
char [] = "字符串值"
string 变量名 = "字符串值"
布尔类型bool
作用：布尔数据类型代表真或假的值
bool类型只有两个值，占用一个字节
- true 真 1
- false 假 0
数据的输入
作用：用于从键盘获取数据
cin >> 变量
int main(){
//整型输入
int a = 0;
cout << "请输入整型变量：" << endl;
cin >> a;
cout << a << endl;
//浮点型输入
double d = 0;
cout << "请输入浮点型变量：" << endl;
cin >> d;
cout << d << endl;
//字符型输入
char ch = 0;
cout << "请输入字符型变量：" << endl;
cin >> ch;
cout << ch << endl;
//字符串型输入
string str;
cout << "请输入字符串型变量：" << endl;
cin >> str;
cout << str << endl;
//布尔类型输入
bool flag = true;
cout << "请输入布尔型变量：" << endl;
cin >> flag;
cout << flag << endl;
system("pause");
return EXIT_SUCCESS;
}
运算符
- 在除法运算中，除数不能为0
- 整数相除 = 整数
- 只有整型变量可以进行取模运算
- 前置递增 先让变量+1 然后进行表达式运算
- 后置递增 先进行表达式运算 然后让变量+1
//加减乘除
int main() {
int a1 = 10;
int b1 = 3;
cout << a1 + b1 << endl;
cout << a1 - b1 << endl;
cout << a1 * b1 << endl;
cout << a1 / b1 << endl; //两个整数相除结果依然是整数
int a2 = 10;
int b2 = 20;
cout << a2 / b2 << endl;
int a3 = 10;
int b3 = 0;
//cout << a3 / b3 << endl; //报错，除数不可以为0
//两个小数可以相除
double d1 = 0.5;
double d2 = 0.25;
cout << d1 / d2 << endl;
system("pause");
return 0;
}
赋值运算符
作用：用于将表达式的赋值给变量
int main() {
//赋值运算符
// =
int a = 10;
a = 100;
cout << "a = " << a << endl;
// +=
a = 10;
a += 2; // a = a + 2;
cout << "a = " << a << endl;
// -=
a = 10;
a -= 2; // a = a - 2
cout << "a = " << a << endl;
// *=
a = 10;
a *= 2; // a = a * 2
cout << "a = " << a << endl;
// /=
a = 10;
a /= 2; // a = a / 2;
cout << "a = " << a << endl;
// %=
a = 10;
a %= 2; // a = a % 2;
cout << "a = " << a << endl;
system("pause");
return 0;
}
比较运算符
作用：用于表达式的比较，并返回一个真值或假值
int main() {
//赋值运算符
// =
int a = 10;
a = 100;
cout << "a = " << a << endl;
// +=
a = 10;
a += 2; // a = a + 2;
cout << "a = " << a << endl;
// -=
a = 10;
a -= 2; // a = a - 2
cout << "a = " << a << endl;
// *=
a = 10;
a *= 2; // a = a * 2
cout << "a = " << a << endl;
// /=
a = 10;
a /= 2; // a = a / 2;
cout << "a = " << a << endl;
// %=
a = 10;
a %= 2; // a = a % 2;
cout << "a = " << a << endl;
system("pause");
return 0;
}
逻辑运算符
作用：用于根据表达式的值返回真值或假值
程序流程结构
选择结构
依据条件是否满足，有选择地执行相应功能
if语句
int main() {
//选择结构-单行if语句
//输入一个分数，如果分数大于600分，视为考上一本大学，并在屏幕上打印
int score = 0;
cout << "请输入一个分数：" << endl;
cin >> score;
cout << "您输入的分数为： " << score << endl;
//if语句
//注意事项，在if判断语句后面，不要加分号
if (score > 600)
{
cout << "我考上了一本大学！！！" << endl;
}
system("pause");
return 0;
}
三目运算符
作用：实现简单的判断
表达式1? 表达式2:表达式3
如果表达式1真，执行表达式2，并返回表达式2的结果
如果表达式1假，执行表达式3，并返回表达式3的结果
int main() {
int a = 10;
int b = 20;
int c = 0;
c = a > b ? a : b;
cout << "c = " << c << endl;
//C++中三目运算符返回的是变量,可以继续赋值
(a > b ? a : b) = 100;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
system("pause");
return 0;
}
switch语句
执行多条件分支语句
case中没有break，程序会一直执行下去
if和switch的区别？
switch的缺点：判断只能是整型或者字符型，不可判断区间
switch的优点：结构清晰，执行效率高
循环结构
while循环语句
只要循环条件的结果为真，就执行循环语句
do…while循环语句
区别：do…while会先执行一次循环语句，在判断循环条件
水仙花数
水仙花数是指一个3位数，它的每个位上的数字的3次幂之和等于它本身
int main(){
int num = 100;
do {
//找水仙花数
int a = 0; //个位
int b = 0; //十位
int c = 0; //百位
a = num % 10;//获取数字的个位
b = num / 10 % 10;//获取数字十位
c = num / 100;//获取数字百位
//如果是水仙花数，打印输出
if(a*a*a + b*b*b + c*c*c = num){
cout<<num<<endl;
}
num++;
}while(num<1000);
}
for循环语句
作用：满足循环条件，执行循环语句
乘法口诀
#include<iostream>
using namespace std;
int main(void)
{
for (int i = 1; i < 10; i++)
{
for (int j = 1; j <= i; j++)
{
cout << j <<"*"<< i<<"="<< i* j<<" ";
}
cout << endl;
}
system("pause");
return 0;
}
嵌套循环
跳转语句
return语句
return 用于从函数中返回值并结束函数的执行。当程序执行到 return 语句时，函数将立即返回，并且可以选择性地返回一个值给调用者。
int square(int x) {
return x * x; // 返回 x 的平方并结束函数
}
当你在一个 for 循环中使用 return 关键字时，它会结束整个函数的执行，而不仅仅是结束当前的循环。
return 语句会立即终止函数的执行，并将指定的值返回给调用者。
void someFunction() {
for (int i = 0; i < 10; ++i) {
if (i == 5) {
return; // 结束函数的执行
}
std::cout << i << " ";
}
std::cout << "This will not be printed." << std::endl;
}
int main() {
someFunction(); // 调用函数
std::cout << "Function execution finished." << std::endl;
return 0;
}
当 i 的值等于 5 时，return 语句被执行，导致 someFunction() 函数立即结束执行。
因此，for 循环和后续的语句都不会被执行，而 main() 函数中的代码会继续执行。
break语句
作用：用于跳出选择结构或者循环结构
- 出现在switch条件语句中，作用是终止case并跳出switch
- 出现在循环语句中，作用是跳出当前的循环语句
- 出现在嵌套循环中，跳出最近的内层循环语句
continue语句
作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
区别：continue并没有使得整个循环终止，break会跳出循环
数组
数组就是一个集合，里面存放了相同类型的数据元素
- 数组中的每个数据元素都是相同的数据类型
- 数组是由连续的内存位置组成的 => 放在同一块连续的内存空间中
一维数组
定义
- 数据类型 数组名 [数组长度];
- 数据类型 数组名 [数组长度] = {值1, 值2…};
- 数据类型 数组名 [] = {值1, 值2…};
# include<iostream>
using namespace std;
int main(){
//数据类型 数组名 [数组长度]
int arr[5];
//给数组元素赋值
arr[0] = 10 ;
arr[1] = 9 ;
arr[2] = 8 ;
arr[3] = 7 ;
arr[4] = 6 ;
//访问数组元素
cout<<arr[0]<<endl;
//数据类型 数组名 [数组长度] = {值1, 值2....}
//如果在初始化时，没有全部填写完，会用0进行填写
int arr2[5] = {10,20,30,40,50};
for(int i = 0 ; i < 5 ; i++){
cout<<arr2[i]<<endl;
}
// 数据类型 数组名 [] = {值1, 值2....}
//定义数组的时候，必须有初始的长度
int arr3 [] = {10,20,30,40,60,56,22};
for(int i = 0 ; i < 8 ; i++){
cout<<arr3[i]<<endl;
}
system("pause");
}
// 可以通过数组名统计整个数组占用内存大小
int arr[] = {1,2,3,4,5,6,7,8,9,10};
cout<<"整个数组占用内存空间为："<<sizeof(arr)<<endl;//40 int 4个字符
cout<<"每个元素占用内存空间为："<<sizeof(arr[0])<<endl;// 4
cout<<"数组中元素个数为："<<sizeof(arr)/sizeof(arr[0])<<endl;//10
// 可以通过数组名查看数组首地址
cout<<"数组首地址为："<<arr<<endl;//16进制
cout<<"数组首地址为："<<int(arr)<<endl;//10进制
//数组名是一个常量，不可进行赋值操作
数组逆置
#include<iostream>
using namespace std;
int main(void)
{
int temp = 0;
nt nums[5] = { 1,2,3,4,5};
int start = 0;
int end = sizeof(nums)/sizeof(nums[0]) -1 ;
while (start < end)
{
temp = nums[start];
nums[start] = nums[end];
nums[end] = temp;
end--;
start++;
}
for (int i = 0; i < 5; i++)
{
cout << nums[i];
}
return 0;
}
冒泡排序
#include<iostream>
using namespace std;
int main(){
/*
1.比较相邻的元素。如果第一个比第二个大，就交换；
2.对每一对相邻元素做同样的工作，执行完毕后，找到第一个最大值；
3.重复以上步骤，每次比较的次数-1
*/
int arr[9] = {4,2,8,0,5,7,1,3,9};
// 总共排序轮数为：元素个数-1
for(int i = 0;i < 9;i++){
//内层循环对比 次数=元素个数-当前轮数-1
for(int j = 0;j<9-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;i<9;i++){
cout<<arr[i]<<" ";
}
}
二维数组
二维数组就是在一维数组的基础上多加一个维度，就是在一维数组里面存储一维数组
- 数据类型 数组名[行][列];
- 数据类型 数组名[行][列] = {{数据1，数据2}，{数据3，数据4}};
- 数据类型 数组名[行][列] = {数据1，数据2，数据3，数据4};
- 数据类型 数组名[][列] = {数据1，数据2，数据3，数据4};
#include<iostream>
using namespace std;
int main(void)
{
int score[3][3] = { {60,50,40},{10,20,30},{70,80,90} };
//嵌套循环解决
//外层行数，内层列数
for (int i = 0; i < 3; i++)
{
int temp = 0;
for (int j = 0; j < 3; j++)
{
temp += score[i][j];
}
cout << temp << endl;
}
}
- 二维数组大小：
sizeof(arr) - 二维数组第一行大小：
sizeof(arr[0]) - 二维数组元素大小：
sizeof(arr[0][0]) - 二维数组行数：
sizeof(arr) / sizeof(arr[0]) - 二维数组列数：
sizeof(arr[0]) / sizeof(arr[0][0]) - 二维数组首地址：
arr - 二维数组第一行地址：
arr[0] - 二维数组第二行地址：
arr[1] - 二维数组第一个元素地址：
&arr[0][0] - 二维数组第二个元素地址：
&arr[0][1]
函数
- 作用：将一段经常使用的代码封装起来，减少重复代码
函数的定义
- 返回值类型：一个函数可以返回一个值，在函数中定义
- 函数名 ：给函数起个名称
- 参数列表：使用该函数时，传入的数据
- 函数体语句：{}内的代码，函数内需要执行的语句
- return表达式：和返回值挂钩，函数执行完成后，返回相应的数据
语法：
返回值类型 函数名(参数列表)
{
函数语句;
return 表达式;
}
函数的调用
功能： 使用定义好的函数
语法：函数名(参数)
值传递
- 就是函数调用时将参数值传给形参
- 值传递时，如果形参发生变化，并不会影响到实参
- void不需要返回值
函数的常见样式
- 无参无返
void test01(){
cout<<"test01"<<endl;
}
//函数调用
test01();//test01
- 有参无返
void test02(int a){
cout<<"test02,a="<<endl;
}
//函数调用
test02(2);//test02,a=2
- 无参有返
int test03(){
cout<<"test03"<<endl;
return 1000;
}
//函数调用
int num1 = test03();// test03 1000
- 有参有返
int test04(int a){
cout<<"test04"<<endl;
return a;
}
//函数调用
int num2 = test04(10);// test04 10
函数的声明
作用： 告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
函数的声明可以有很多次，定义只能有一次
//声明：提前告诉编译器函数的存在，可以利用函数的声明
int max(int a,int b);
int main(){
int a = 10;
int b = 4;
cout<<max(a,b)<<endl;
}
//定义 代码是一行一行调试
int max(int a ,int b)
{
return a+b;
}
函数的分文件编写
作用： 让代码结构更加清晰
函数分文件编写4个步骤：
- 创建后缀名
.h的头文件 - 创建后缀名为
.cpp的源文件 - 在头文件中写函数的声明
- 在源文件中写函数的定义
//swap.h文件
#include<iostream>
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;
}
指针
概念
指针的作用： 可以通过指针间接访问内存。指针就是地址
- 内存编号是从0开始记录的，一般用16进制数字标识。
- 可以利用指针变量保存地址。
指针变量的定义和使用
指针变量定义语法：数据类型* 指针变量名
int a = 10;
int * p ;
//让指针记录变量a的地址
p = &a;
cout<<"a的地址:"<<&a<<endl;//00FFA5C
cout<<"指针p:"<<p<<endl;//00FFA5C
//使用指针
//可以通过解引用(指针前面加*)方式来找到指针指向的内存数据
*p = 1000;
cout<<"a:"<<a<<endl;//1000
指针所占内存空间
在32位操作系统下无论是什么类型的指针，都占4个字节的内存空间
64位 -> 8个字节
空指针
空指针： 指针变量指向内存中编号为0的空间（内存条每一条都有编号，0-255之间的内存编号是系统占用的，不可以访问）
用途： 初始化指针变量
注意： 空指针指向的内存空间是不可以访问的 int* p = NULL;
野指针
指针变量指向非法的内存空间
//指针变量p指向内存地址编号为0x1100的空间
int * p = (int *)0x1100;
//访问野指针报错
cout<<*p<<endl;
const修饰指针
const修饰指针有3种情况
- const修饰指针 —> 常量指针
//常量指针：指针的指向可以修改，指针指向的值不可以修改
const int * p = &a;
//指针指向可以修改
p= &b;
//报错，指针指向的值不可以修改
*p=20;
- const修饰常量 —> 指针常量
// 指针常量：指针的指向不可以改，指针指向的值可以改
// const p 常量
int * const p = &a;
*p = 100;//正确
p = &b; // 错误
- const既修饰指针，又修饰常量
// 指针的指向和指针指向的值都不可以改变
// const p 常量
// const int* 修饰指针
const int* const p = &a;
指针和数组
作用： 利用指针访问数组元素
int main(){
int arr[] = {1,2,3,4};
cout<<"第一个元素："<<arr[0]<<endl;// 1
//指向数组的指针
int* p = arr;// arr就是数组首地址
cout<<"指针访问第一个元素："<<*p<<endl;// 1
p++;//将指针往后移4个字节
cout<<"指针访问第二个元素："<<*p<<endl;// 2
int * p2 = arr;
for(int i = 0 ; i < 10; i++){
//利用指针遍历数组
cout<<*p2<<endl;
p++;
}
return 0;
}
指针和函数
作用： 利用指针作函数的参数，可以修改实参的值
地址传递：会改变实参
值传递：不会改变实参
void swap(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;// 20
cout<<"b："<<b<<endl;// 10
return 0;
}
指针、数组、函数
封装一个函数，利用冒泡排序，实现对整型数组的升序排列
#include<iostream>
using namespace std;
// 2.创建函数，实现冒泡
// 参数1 数组的首地址
// 参数2 数组的长度
void PopSort(int* a,int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len-i - 1; j++)
{
int temp = 0;
// 如果 j>j+1 交换
if (a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
int main(void)
{
//1.创建数组
int arry[5] = { 6,2,4,8,5 };
// 数组长度 = sizeof(arry)/sizeof(arry[0])
PopSort(arry, 5);
for (int i = 0; i < 5; i++)
{
cout << arry[i];
}
return 0;
}
结构体
概念
结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
结构体定义和使用
语法：struct 结构体名称{结构体成员列表};
通过结构体创建变量的方式有三种 struct 在创建变量时可以省略
- struct 结构体名 变量名
struct Student s1 - struct 结构体名 变量名 = （成员1值，成员2值…)
`struct Student s1 = {....}` - 定义结构体时顺便创建变量
s3
// 学生的数据类型:姓名 年龄 分数
// 自定义数据类型，一些类型集合组成的一个类型
// 语法 struct 类型名称{成员列表}
// 定义时 struct 不可以省略
struct Student
{
//成员列表
string name;
int age;
int score;
}s3;
// 通过学生类型创建具体的学生
int main()
{
// struct 在创建变量时可以省略
struct Student s1;// Student s1;
// 给s1属性赋值，通过.访问结构体变量中的属性
s1.name = "张三";
s1.age = 20;
s1.score = 100;
cout<<"姓名："<<s1.name<<"年龄："<<s1.age<<"分数："<<s1.score<<endl;
struct Student s2 = {"李四",19,99};
s3.name= "王五";
s3.age = 16;
s3.score = 98;
return 0;
}
结构体数组
作用： 将自定义的结构头放入到数组中方便维护
语法：struct 结构体名 数组名[元素个数]= {{},{}...{}};
struct Student
{
//成员列表
string name;
int age;
int score;
};
// 通过学生类型创建具体的学生
int main()
{
struct Student arr[3] =
{
{"李四",19,99},
{"李四",19,99},
{"李四",19,99},
}
arr[2].name = "赵六";
for(int i=0;i<3;i++){
cout<<"姓名："<<arr[i].name<<"年龄："<<arr[i].age<<"分数："<<arr[i].score<<endl;
}
}
结构体指针
作用：通过指针访问结构体中的成员
利用操作符->可以通过结构体指针访问结构体属性 p->name
struct Student
{
//成员列表
string name;
int age;
int score;
};
// 通过学生类型创建具体的学生
int main()
{
// 创建学生结构体变量
struct Student stu = {"李四",19,99};
// 通过指针指向结构体变量
struct student * p = &stu;
// 通过指针访问结构体变量中的数据
// 通过结构体指针 访问结构体的属性 使用 ->
cout<<"姓名："<<p->name<<"年龄："<<p->age<<"分数："<<p->score<<endl;
return 0;
}
结构体嵌套结构体
作用： 结构体中的成员可以是另一个结构体
例如： 每个老师辅导一个学员，一个老师的结构体中，记录一个学生的的结构体
// 学生的数据类型:姓名 年龄 分数
struct Student
{
//成员列表
string name;
int age;
int score;
};
// 老师的数据类型:职工编号 姓名 年龄 子结构体学生
struct Teacher
{
//成员列表
int id;
string name;
int age;
struct Student std;//子结构体 学生
};
int main()
{
Teacher t;
t.id = 1;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 20;
t.stu.score = 60;
}
结构体做函数参数
作用： 将结构体作为参数向函数中传递
传递方式有两种
- 值传递-无法改变实参
- 地址传递-可以改变实参
struct Student
{
//成员列表
string name;
int age;
int score;
};
//打印学生信息函数
// 1. 值传递
void printStu1(struct Student s1)
{
cout<<"姓名："<<s1.name<<"年龄："<<s1.age<<"分数："<<s1.score<<endl;
}
// 1. 地址传递
void printStu2(struct Student *p)
{
cout<<"姓名："<<p->name<<"年龄："<<p->age<<"分数："<<p->score<<endl;
}
int main()
{
struct Student stu = {"李四",19,99};
printStu1(stu);
printStu2(&stu);
}
结构体中const使用场景
作用：用const来防止误操作
struct Student
{
//成员列表
string name;
int age;
int score;
};
//打印学生信息函数
// 将函数中的形参改为指针，可以减少内存空间 同时不会肤质新的副本出来
void printStu2(const struct Student *p)
{
// 加了const就无法改变该结构体内的信息
// p -> age = 150;//报错，表达式必须时可修改的左值
cout<<"姓名："<<p->name<<"年龄："<<p->age<<"分数："<<p->score<<endl;
}
int main()
{
struct Student stu = {"李四",19,99};
printStu2(stu);
}
结构体案例
每个老师带5个学生，一共3名老师
#include<iostream>
#include<string>
#include<ctime> // 包含time()函数的头文件
using namespace std;
struct Student
{
string name;
int age;
int score;
};
struct Teacher
{
string name;
struct Student sArry[5];
};
//给老师和学生赋值的函数
void inPutInformation(struct Teacher tArry[], int len)
{
string Name = "ABCDE";
//给老师赋值
for (int i = 0; i < len; i++)
{
tArry[i].name = "Teacher_";
// 将Name字符串中第i个字符追加到tArry[i]的name成员变量后面
tArry[i].name += Name[i];
//学生
for (int j = 0; j < 5; j++)
{
tArry[i].sArry[j].name = "Student_";
tArry[i].sArry[j].name += Name[j];
// %操作符用于取模，将rand()生成的随机数除以60取余数，使得结果范围在0到59之间
int random = rand()% 60 +40;//随机值 0-59 + 40
tArry[i].sArry[j].score = random;
}
}
}
//打印所有信息
void printInformation(struct Teacher tArry[],int len)
{
for (int i = 0; i < len; i++)
{
cout << "老师的姓名：" << tArry[i].name << endl;
for (int j = 0; j < 5; j++)
{
cout << "\t学生的姓名：" << tArry[i].sArry[j].name << "考试分数：" << tArry[i].sArry[j].score << endl;
}
}
}
int main(void)
{
// 为了生成真正的随机数序列，需要在使用rand()函数之前调用srand()函数来设置随机种子。
// time(NULL)函数返回的是当前时间的秒数，类型为time_t
// unsigned int是C++中的一种无符号整数类型，它可以表示大于等于0的整数值
srand((unsigned int)time(NULL));
struct Teacher tArry[3];
int len = sizeof(tArry) / sizeof(tArry[0]);
inPutInformation(tArry,len);
printInformation(tArry,len);
system("pause");
return 0;
}
创建5个人并按年龄排序
#include<iostream>
#include<string>
#include<ctime>
using namespace std;
struct Hero
{
string name;
int age;
string categories;
};
int main(void)
{
struct Hero heroArry[5] =
{
{"欣南",20,"火"},
{"东杉",24,"木"},
{"北淼",23,"水"},
{"坤中",18,"土"},
{"西昭",22,"金"},
};
int len = sizeof(heroArry) / sizeof(heroArry[0]);
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
Hero temp;
if (heroArry[j].age > heroArry[j + 1].age)
{
temp = heroArry[j];
heroArry[j] = heroArry[j + 1];
heroArry[j + 1] = temp;
}
}
}
for (int i = 0; i <len; i++)
{
cout << heroArry[i].name << heroArry[i].age << heroArry[i].categories << endl;
}
system("pause");
return 0;
}
通讯录
#include<iostream>
#include<string>
#include<cstdlib>
#define MAX 1000
using namespace std;
struct Person
{
string name;
int age;
string sex;
string phone;
string addr;
};
struct addreassbooks
{
// 在 addreassbooks 结构体中定义了一个名为 personarry 的数组。这个数组的元素类型是 Person 结构体，其大小为 MAX
struct Person personarry[MAX];
int m_Size;
};
void mainMenu()
{
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;
}
void addPerson(addreassbooks* abs)
{
// abs->m_Size 是指向 addreassbooks 结构体的指针 abs 的成员变量 m_Size。 m_Size 表示通讯录中当前联系人的个数，它的值会随着联系人的添加和删除而变化。
if (abs->m_Size == MAX)
{
cout << "联系人已满，无法添加" << endl;
return;
}
string name;
cout << "请输入姓名" << endl;
cin >> name;
// abs 是指向 addreassbooks 结构体的指针
// abs->m_Size 是当前通讯录中已存在联系人的个数
// abs->personarry 是 addreassbooks 结构体中的联系人数组
// abs->personarry[abs->m_Size] 表示通讯录中空闲的位置，即新联系人应该插入的位置
// .name 是联系人结构体 Person 中的姓名字段
abs->personarry[abs->m_Size].name = name;
string sex;
cout << "请输入性别" << endl;
cin >> sex;
abs->personarry[abs->m_Size].sex = sex;
int age;
cout << "请输入年龄" << endl;
cin >> age;
abs->personarry[abs->m_Size].age = age;
string phone;
cout << "请输入电话" << endl;
cin >> phone;
abs->personarry[abs->m_Size].phone = phone;
string addr;
cout << "请输入地址" << endl;
cin >> addr;
abs->personarry[abs->m_Size].addr = addr;
//更新通讯录人数
abs->m_Size++;
cout << "添加成功" << endl;
system("pause");
system("cls");
}
void printPerson(addreassbooks* abs)
{
if (abs->m_Size == 0)
{
cout << "当前记录为空" << endl;
}
else
{
for (int i = 0; i < abs->m_Size; i++)
{
cout << "姓名\t" << abs->personarry[i].name << endl;
cout << "性别\t" << abs->personarry[i].sex << endl;
cout << "年龄\t" << abs->personarry[i].age << endl;
cout << "电话\t" << abs->personarry[i].phone << endl;
cout << "地址\t" << abs->personarry[i].addr << endl;
cout << "\n";
}
}
system("pause");
system("cls");
}
int checkPerson(addreassbooks* abs, string name)
{
for (int i = 0; i < abs->m_Size; i++)
{
if (abs->personarry[i].name == name)
{
return i;
}
}
return -1;
}
void deletePerson(addreassbooks* abs)
{
string dname;
cout << "请输入你要删除的人名" << endl;
cin >> dname;
int ret = checkPerson(abs, dname);
if (ret == -1)
{
cout << "查无此人" << endl;
}
else
{
for (int i = ret; i < abs->m_Size; i++)
{
abs->personarry[i] = abs->personarry[i + 1];
}
abs->m_Size--;
cout << "删除成功" << endl;
}
system("pause");
system("cls");
}
void findPerson(addreassbooks* abs)
{
string fname;
cout << "请输入要查找的联系人姓名" << endl;
cin >> fname;
int result = checkPerson(abs, fname);
if (result == -1)
{
cout << "查无此人" << endl;
}
else
{
cout << "姓名\t" << abs->personarry[result].name << endl;
cout << "性别\t" << abs->personarry[result].sex << endl;
cout << "年龄\t" << abs->personarry[result].age << endl;
cout << "电话\t" << abs->personarry[result].phone << endl;
cout << "地址\t" << abs->personarry[result].addr << endl;
}
system("pause");
system("cls");
}
void modifyPerson(addreassbooks* abs)
{
string mname;
cout << "请输入要修改的联系人姓名" << endl;
cin >> mname;
int result = checkPerson(abs, mname);
if (result == -1)
{
cout << "查无此人" << endl;
}
else
{
string name;
cout << "请输入姓名" << endl;
cin >> name;
abs->personarry[result].name = name;
string sex;
cout << "请输入性别" << endl;
cin >> sex;
abs->personarry[result].sex = sex;
int age;
cout << "请输入年龄" << endl;
cin >> age;
abs->personarry[result].age = age;
string phone;
cout << "请输入电话" << endl;
cin >> phone;
abs->personarry[result].phone = phone;
string addr;
cout << "请输入地址" << endl;
cin >> addr;
abs->personarry[result].addr = addr;
cout << "修改成功" << endl;
}
system("pause");
system("cls");
}
void cleanPerson(addreassbooks*abs)//逻辑清空
{
abs->m_Size = 0;
cout << "通讯录清空成功！" << endl;
system("pause");
system("cls");
}
int main(void)
{
//创建通讯录结构体变量
addreassbooks abs;
//初始化通讯录中当前人员的个数
abs.m_Size = 0;
int select = 0;
while (1)
{
mainMenu();
cin >> select;
switch (select)
{
case 1://添加联系人
addPerson(&abs);
break;
case 2://显示联系人
printPerson(&abs);
break;
case 3://删除联系人
deletePerson(&abs);
break;
case 4://查找联系人
findPerson(&abs);
break;
case 5://修改联系人
modifyPerson(&abs);
break;
case 6://清空联系人
cleanPerson(&abs);
break;
case 0://退出通讯录
cout << "欢迎下次使用" << endl;
system("pause");
return 0;
default:
break;
}
}
}
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
10
0- 0
已为社区贡献3条内容
所有评论(0)