【c++】c++基础入门
目录
- C++基础入门
- C++初识
- 第一个程序
- 头尾部
- hello world
- 注释
- 单行注释
- 多行注释
- 变量
- 常量
- 关键字
- 标识符命名规则
- 数据类型
- 整型
- sizeof关键词
- 实型(浮点型)
- 字符型
- 转义字符
- 字符串型
- 布尔类型 bool
- 数据的输入
- 运算符
- 算术运算符
- 赋值运算符
- 比较运算符
- 逻辑运算符
- 程序流程结构
- 选择结构
- if语句
- 三目运算符
- switch语句
- 循环结构
- while循环语句
- do...while循环语句
- for循环语句
- 4.2.4 嵌套循环
- 4.3 跳转语句
- 4.3.1 break语句
- 4.3.2 continue语句
- 4.3.3 goto语句
- 5. 数组
- 5.1 概述
- 5.2 一维数组
- 5.2.1 一维数组定义方式
- 5.2.2 一维数组数组名
- 5.2.3 冒泡排序
- 5.3 二维数组
- 5.3.1 二维数组的定义方式
- 5.3.2 二维数组数组名
- 5.3.3 二维数组应用案例
- 6. 函数
- 6.1 概述
- 6.2 函数的定义
- 6.3 函数的调用
- 6.4 值传递
- 6.5 函数的常见样式
- 6.6 函数的声明
- 6.7 函数分文件编写
- 7. 指针
- 7.1 指针的基本概念
- 7.2 指针变量的定义和使用
- 7.3 指针所占内存空间
- 7.4 空指针和野指针
- 空指针
- 空指针
- 7.5 const修饰指针
- 7.6 指针和数组
- 7.7 指针与函数
- 7.8 指针、数组、函数
- 8. 结构体
- 8.1 结构体的基本概念
- 8.2 结构体的定义和使用
- 8.3 结构体数组
- 8.4 结构体指针
- 8.5 结构体嵌套结构体
- 8.6 结构体做函数参数
- 8.7 结构体中const使用场景
- 8.8 结构体案例
- 8.8.1 案例1
- 8.8.2 实例2
C++基础入门
学习视频
注:下文中视频密码:123456
C++初识
第一个程序
头尾部
#include <iostream>
using namespace std;int main()
{system("pause");return 0;
}
hello world
#include <iostream>
using namespace std;int main()
{cout << "hello world" << endl;system("pause");return 0;
}
注释
单行注释
- // 描述信息
- 通常放在一行代码的上方,或者—条语句的末尾,对该行代码说明
多行注释
- /* 描述信息 */
- 通常放在一段代码的上方,对该段代码做整体说明
变量
作用:给一段指定的内存空间起名,方便操作这段
内存语法:数据类型 变量名 = 初始值
;
#include <iostream>
using namespace std;int main()
{// 变量的定义// 语法:数据类型 变量名 = 初始值int a = 10;cout << "a = " << a << endl;system("pause");return 0;
}
常量
作用:用于记录程序中不可更改的数据
- #define宏常量:
#define 常量名 常量值
- 通常在文件上方定义,表示—个常量
- const修饰的变量
const 数据类型 常量名 = 常量值
- 通常在变量定义前加关键字const。修饰该变量为常量,不可修改
#include <iostream>
using namespace std;/*
常量的定义方法
1、#define 宏常量
2、const修饰的变量
*///1、#define 宏常量
#define day 7int main()
{//day = 14; //错误,day是常量,一旦修改就会报错cout << "一周总共有:" << day << "天" << endl;//2、const修饰的变量const int month = 12;//month = 24; //错误,const修饰的变量也称为常量cout << "一年总共有:" << month << "个月份" << endl;system("pause");return 0;
}
关键字
作用:关键字是C++中预先保留的单词(标识符)
- 在定义变量或者常量时候,不要用关键字
asm | do | if | return | typedef |
---|---|---|---|---|
auto | double | inline | short | typeid |
bool | dynamic_cast | int | signed | typename |
break | else | long | sizeof | union |
case | enum | mutable | static | unsigned |
catch | explicit | namespace | static_cast | using |
char | export | new | struct | virtual |
class | extern | operator | switch | void |
const | false | private | template | volatile |
const_cast | float | protected | this | wchar_t |
continue | for | public | throw | while |
default | friend | register | true | |
delete | goto | reinterpret_cast | try |
标识符命名规则
作用:C++规定给标识符(变量、常量)命名时,有一套自己的规则
- 标识符不能是关键字
- 标识符只能由字母、数字、下划线组成
- 第一个字符必须为字母或下划线
- 标识符中字母区分大小写
数据类型
C++规定在创建一个变量或者常量时,必须要指定出相应的数据类型,否则无法给变量分配内存
整型
作用:整型变量表示整数类型的数据。
数据类型 | 占用空间 | 取值范围 |
---|---|---|
short(短整型) | 2字节 | (-2^15 ~ 2^15-1) |
int(整型) | 4字节 | (-2^31 ~ 2^31-1) |
long(长整形) | Windows为4字节,Linux为4字节(32位),8字节(64位) | (-2^31 ~ 2^31-1) |
long long(长长整形) | 8字节 | (-2^63 ~ 2^63-1) |
sizeof关键词
作用:利用sizeof关键字可以统计数据类型所占内存大小
语法:sizeof(数据类型 / 变量)
整型结论:short < int <= long <=long long
实型(浮点型)
作用:浮点型变量表示小数类型的数据。
单精度float
双精度double
两者区别在于表示的有效数字范围不同。
数据类型 | 占用空间 | 有效数字范围 |
---|---|---|
float | 4字节 | 7位有效数字 |
double | 8字节 | 15~16位有效数字 |
注1:有效数字包括整数部分和小数部分。
注2:C++输出多位小数时默认会显示6位有效数字,需进行额外配置以完整显示全部有效数字。
注3:float类型表示小数时,在数字末尾显式地使用字母f表示单精度,否则编译器会默认将小数视为双精度浮点型(double),再进行类型转换(由double型转换为float型)。
int main()
{float f1 = 3.1415926535f;cout << "float 类型占用的内存大小:" << sizeof(float) << endl;cout << "float 类型占用的内存大小:" << sizeof(f1) << endl;double d1 = 3.1415926535;cout << "double 类型占用的内存大小:" << sizeof(double) << endl;cout << "double 类型占用的内存大小:" << sizeof(d1) << endl;//科学计数法表示整数float f2 = 3e2; // 3 * 10 ^ 2 cout << "f2 = " << f2 << endl;//科学计数法表示小数float f3 = 3e-2; // 3 * 0.1 ^ 2cout << "f3 = " << f3 << endl;system("pause");return 0;
}
字符型
作用:字符型变量可表示单个字符。
语法:char ch = 'a';
注1:使用单引号表示字符,且单引号内有且仅有1个字符,不可以是字符串。
注2:使用 (int) ch
查询字符对应的ASCII编码。'a’对应97,'A’对应65。
int main()
{//字符型变量创建方式char ch = 'a';cout << ch << endl;//字符型变量所占内存大小cout << "char字符型变量占用的内存大小:" << sizeof(char) << endl;cout << "char字符型变量占用的内存大小:" << sizeof(ch) << endl;//字符型变量常见错误//char ch2 = "b"; //错误:表示字符时需使用单引号//char ch2 = 'abcdef'; //错误:单引号内只能有一个字符//字符型变量对应ASCII编码(a:97; A:65)cout << (int)ch << endl;system("pause");return 0;
}
ASCII码表格:
ASCII值 | 控制字符 | ASCII值 | 字符 | ASCII值 | 字符 | ASCII值 | 字符 |
---|---|---|---|---|---|---|---|
0 | NUT | 32 | (space) | 64 | @ | 96 | 、 |
1 | SOH | 33 | ! |
65
|
A
|
97
|
a
|
2 | STX | 34 | " | 66 | B | 98 | b |
3 | ETX | 35 | # | 67 | C | 99 | c |
4 | EOT | 36 | $ | 68 | D | 100 | d |
5 | ENQ | 37 | % | 69 | E | 101 | e |
6 | ACK | 38 | & | 70 | F | 102 | f |
7 | BEL | 39 | , | 71 | G | 103 | g |
8 | BS | 40 | ( | 72 | H | 104 | h |
9 | HT | 41 | ) | 73 | I | 105 | i |
10 | LF | 42 | * | 74 | J | 106 | j |
11 | VT | 43 | + | 75 | K | 107 | k |
12 | FF | 44 | , | 76 | L | 108 | l |
13 | CR | 45 | - | 77 | M | 109 | m |
14 | SO | 46 | . | 78 | N | 110 | n |
15 | SI | 47 | / | 79 | O | 111 | o |
16 | DLE | 48 | 0 | 80 | P | 112 | p |
17 | DCI | 49 | 1 | 81 | Q | 113 | q |
18 | DC2 | 50 | 2 | 82 | R | 114 | r |
19 | DC3 | 51 | 3 | 83 | S | 115 | s |
20 | DC4 | 52 | 4 | 84 | T | 116 | t |
21 | NAK | 53 | 5 | 85 | U | 117 | u |
22 | SYN | 54 | 6 | 86 | V | 118 | v |
23 | TB | 55 | 7 | 87 | W | 119 | w |
24 | CAN | 56 | 8 | 88 | X | 120 | x |
25 | EM | 57 | 9 | 89 | Y | 121 | y |
26 | SUB | 58 | : | 90 | Z | 122 | z |
27 | ESC | 59 | ; | 91 | [ | 123 | { |
28 | FS | 60 | < | 92 | / | 124 | | |
29 | GS | 61 | = | 93 | ] | 125 | } |
30 | RS | 62 | > | 94 | ^ | 126 | ` |
31 | US | 63 | ? | 95 | _ | 127 | DEL |
ASCII 码的大致组成部分:
- 非打印控制字符:ASCII 表的 数字0-31 分配给控制字符,用于控制如打印机等外围设备。
- 打印字符:ASCII 表的 数字32-126 分配给键盘上的字符。
转义字符
作用:表示一些特殊的无法直接显示的ASCII字符。
常用的转义字符有:\n \\ \t
注1:C语言中使用转义字符
\n
换行,C++中使用endl
换行。
注2:表示水平制表符的转义符\t
占据8个字符宽度。
转义字符 | 含义 | ASCII码值(十进制) |
---|---|---|
\a | 警报 | 007 |
\b | 退格(BS) ,将当前位置移到前一列 | 008 |
\f | 换页(FF),将当前位置移到下页开头 | 012 |
\n | 换行(LF) ,将当前位置移到下一行开头 | 010 |
\r | 回车(CR) ,将当前位置移到本行开头 | 013 |
\t | 水平制表(HT) (跳到下一个TAB位置) | 009 |
\v | 垂直制表(VT) | 011 |
\\ | 代表一个反斜线字符“\” | 092 |
\’ | 代表一个单引号(撇号)字符 | 039 |
\" | 代表一个双引号字符 | 034 |
\? | 代表一个问号 | 063 |
\0 | 数字0 | 000 |
\ddd | 8进制转义字符,d范围0~7 | 3位8进制 |
\xhh | 16进制转义字符,h范围0-9,a-f,A~F | 3位16进制 |
int main()
{cout << "\\" << endl;cout << "\tHello" << endl;cout << "\n" << endl;system("pause");return 0;
}
字符串型
作用:表示一串字符
- C风格字符串:
char 变量名[] = "字符串值";
int main()
{//C风格字符串char str1[] = "hello world";cout << str1 << endl;system("pause");return 0;
}
注1:使用C风格字符串时,需使用双引号将字符串值括起来。
注2:
char 字符串名 []
- C++风格字符串:
string 变量名 = "字符串值";
#include <string>int main()
{//C++风格字符串string cppStr = "hello cpp str";cout << cppStr << endl;system("pause"); return 0;
}
注1:使用C++风格字符串时,需包含头文件
#include <string>
。
布尔类型 bool
作用:布尔数据类型表示真或假的值。
bool类型只有两个值
- true — 真(本质是1)
- false — 假(本质是0)
bool类型占1个字节大小
int main()
{bool flag = true;cout << flag << endl; // 1(真)/* C++的bool类型中,true 或 任意非0值 均代表“真” */flag = 6.66f;cout << flag << endl; // 1(真)flag = false;cout << flag << endl; // 0(假)/* C++的bool类型中,false 或 0值 代表“假” */flag = 0;cout << flag << endl; // 0(假)cout << "bool类型占用的内存大小:" << sizeof(bool) << endl;cout << "bool类型占用的内存大小:" << sizeof(flag) << endl;system("pause");return 0;
}
数据的输入
作用:从键盘获取数据
关键字:cin
语法: cin >> 变量
#include <iostream>
using namespace std;#include <string>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;//4、字符串型string str = "hello";cout << "请给字符串型变量str赋值:" << endl;cin >> str;cout << "字符串型变量str = " << str << endl;//5、布尔类型bool flag = false;cout << "请给布尔类型 flag 赋值:" << endl;cin >> flag;//bool类型 只要非0的值都代表真cout << "布尔类型 flag = " << flag << endl;system("pause");return 0;
}
运算符
算术运算符
作用:用于处理四则运算
注1:两整数相除,结果依然是整数,将小数部分去除
注2:两个数相除,除数是不可以为0的
注3:两小数可以相除,运算结果可以是小数
注4:两个数相除除数是不可以为0,所以也做不了取模运算
总结:只有整型变量可以进行取模运算
#include <iostream>
using namespace std;int main()
{//1、前置递增int a = 10;++a; //让变量+1cout << "a = " << a << endl;//2、后置递增int b = 10;b++; //让变量+1cout << "b = " << b << endl;//3、前置和后置的区别//前置运算 先让变量+1,然后进行表达式运算int a2 = 10;int b2 = ++a2 * 10;cout << "a2 = " << a2 << endl;cout << "b2 = " << b2 << endl;//后置运算 先进行表达式运算,后让变量+1int a3 = 10;int b3 = a3++ * 10;cout << "a3 = " << a3 << endl;cout << "b3 = " << b3 << endl;system("pause");return 0;
}
总结:前置递增先对变量进行++,再计算表达式,后置递增相反
赋值运算符
作用:用于将表达式的值赋给变量
比较运算符
优先级加括号,不然报错
逻辑运算符
程序流程结构
c++中支持最基本的三种流程结构:顺序结构、选择结构、循环结构
- 顺序结构:程序按顺序执行,不会发生跳转。
- 选择结构:根据条件是否满足,有选择的执行相应的功能。
- 循环结构:根据条件是否满足,循环多次执行某代码块。
选择结构
if语句
作用:执行满足条件的语句
- 单行格式if语句
- 多行格式if语句
- 多条件的if语句
- 单行格式if语句:
if(条件){ 条件满足执行的语句 }
#include<iostream>
using namespace std;int main()
{//选择结构 单行if语句//用户输入考试分数,如果分数大于600,则视为考上一本大学,在屏幕上输出//1.用户输入分数int score = 0;cout << "请输入考试分数:" << endl;cin >> score;//2.打印用户输入的分数cout << "您输入的分数为:" << score << endl;//3.判断分数是否大于600,如果大于则输出考上一本大学//注意事项,if条件后面不要加分号if (score > 600){cout << "恭喜您考上一本大学" << endl;}system("pause");return 0;
}
- 多行格式if语句:
if(条件){ 条件满足执行的语句 }else{ 条件不满足执行的语句 };
#include<iostream>
using namespace std;int main()
{//选择结构 - 多行if语句//用户输入考试分数,如果分数大于600,则视为考上一本大学,在屏幕上输出//如果没有考上一本大学,则打印未考上一本大学//1.输入考试分数int score = 0;cout << "请输入考试分数:" << endl;cin >> score;//2.提示用户输入的分数cout << "您输入的分数为:" << score << endl;//3.判断 如果大于600,打印考上一本,否则打印未考上一本if (score > 600) //大于600分执行下面大括号中的内容{cout << "恭喜您考上一本大学!" << endl;}else //不大于600分,执行else后大括号中的内容{cout << "您未考上一本大学" << endl;}system("pause");return 0;
}
- 多条件的if语句:
if(条件1){ 条件1满足执行的语句 }else if(条件2){ 条件2满足执行的语句 }...else{ 都不满足执行的语句 }
#include<iostream>
using namespace std;int main()
{// 选择结构 多条件if语句// 输入一个考试分数,如果大于600,则视为考上一本大学,在屏幕输出// 大于500,视为考上二本大学,屏幕输出// 大于400,视为考上三本大学,屏幕输出// 小于等于400分,视为未考上本科,屏幕上输出// 1.用户输入分数int score = 0;cout << "请输入考试分数:" << endl;cin >> score;// 2.打印用户输入的分数cout << "您输入的分数为:" << score << endl;// 3.判断// 如果大于600,考上一本// 如果大于500,考上二本// 如果大于400,考上三本// 前三个都没有满足,未考上本科if (score > 600){cout << "您考上一本大学" << endl;}else if (score > 500) //第二个条件判断{cout << "您考上二本大学" << endl;}else if (score >= 400) //第三个条件判断{cout << "您考上三本大学" << endl;}else{cout << "未考上本科大学,请再接再厉" << endl;}system("pause");return 0;
}
嵌套if语句:在if语句中,可以嵌套使用if语句,达到更精确的条件判断
案例需求:
- 提示用户输入一个高考考试分数,根据分数做如下判断
- 分数如果大于600分视为考上一本,大于500分考上二本,大于400考上三本,其余视为未考上本科;
- 在一本分数中,如果大于700分,考入北大,大于650分,考入清华,大于600考入人大。
#include<iostream>
using namespace std;int main()
{/*-提示用户输入一个高考考试分数,根据分数做如下判断- 分数如果大于600分视为考上一本,大于500分考上二本,大于400考上三本,其余视为未考上本科;- 在一本分数中,如果大于700分,考入北大,大于650分,考入清华,大于600考入人大。*///1.提示输入高考分数int score = 0;cout << "请输高考考试分数:" << endl;cin >> score;//2.显示高考分数cout << "您输入的分数为:" << score << endl;//3.判断// 如果大于600 一本// 大于700 北大// 大于650 清华// 其余 人大// 如果大于500 二本// 如果大于400 三本// 其余情况 未考上本科if (score >= 600){cout << "恭喜您考入一本大学" << endl;if (score >= 700){cout << "您考上北大" << endl;}else if (score >= 650){cout << "您考上清华" << endl;}else{cout << "您考上人大" << endl;}}else if (score >= 500){cout << "您考上二本大学" << endl;}else if (score >= 400){cout << "您考上三本大学" << endl;}else{cout << "您未考上本科大学" << endl;}system("pause");return 0;
}
练习案例:三只小猪称体重
有三只小猪ABC,请分别输入三只小猪的体重,并且判断哪只小猪最重?
#include<iostream>
using namespace std;int main()
{//三只小猪称体重,判断哪只最重//1、创建三只小猪的体重变量int num1 = 0;int num2 = 0;int num3 = 0;//2、让用户输入三只小猪的重量cout << "请输入小猪A的体重" << endl;cin >> num1;cout << "请输入小猪B的体重" << endl;cin >> num2;cout << "请输入小猪C的体重" << endl;cin >> num3;cout << "A小猪的体重是:" << num1 << endl;cout << "B小猪的体重是:" << num2 << endl;cout << "C小猪的体重是:" << num3 << endl;//判断哪只最重//先判断A与B的重量if (num1 > num2) //A比B重{if (num1 > num3) //A比C重{cout << "小猪A最重" << endl;}else //C比A重{cout << "小猪C最重" << endl;}}else //B比A重{if (num2 > num3) //B比C重{cout << "小猪B最重" << endl;}else //C比B重{cout << "小猪C最重" << endl;}}system("pause");return 0;
}
三目运算符
作用:通过三目运算符实现简单的判断
语法:表达式1 ? 表达式2 : 表达式3
解释:
如果表达式1值为真,执行表达式2,并返回表达式2的结果
如果表达式1值为假,执行表达式3,并返回表达式3的结果
#include<iostream>
using namespace std;int main()
{//三目运算符//创建三个变量 a b c//将a和b作比较,将变量大的值赋值给变量cint 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;system("pause");return 0;
}
switch语句
作用:执行多条件分支语句
语法:
switch(表达式)
{case 结果1: 执行语句;break;case 结果1: 执行语句;break;···default: 执行语句;break;}
#include<iostream>
using namespace std;int main()
{//switch语句//给电影进行打分//10-9 经典//8-7 非常好//6-5 一般//5以下 烂片//1.提示用户给电影进行评分cout << "请给电影进行打分" << endl;//2.用户开始进行打分int score = 0;cin >> score;cout << "您打的分数为:" << score <<endl;//3.根据用户输入的分数来提示用户最后输入的结果switch (score){case 10:cout << "您认为是经典电影" << endl;break; //退出当前分支case 9:cout << "您认为是经典电影" << endl;break;case 8:cout << "您认为电影非常好" << endl;break;case 7:cout << "您认为电影非常好" << endl;break;case 6:cout << "您认为电影一般" << endl;break;case 5:cout << "您认为电影一般" << endl;break;default:cout << "您认为这个电影是烂片" << endl;break;}//if and switch 区别?//switch缺点:判断的时候只能是整型或者是字符型,不可以是一个区间//switch优点:结构清晰,执行效率高system("pause");return 0;
}
循环结构
while循环语句
作用:满足循环条件,执行循环语句
语法:while(循环条件){ 循环语句 }
解释:只要循环条件的结果为真,就执行循环语句
#include <iostream>
using namespace std;int main()
{//while循环//在屏幕中打印0-9这10个数字/*int num = 0;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;num++;cout << num << endl;*/int num = 0;//while()中填入循环条件//注意事项:在写循环一定要避免死循环出现while (num < 10){cout << num << endl;num++;}system("pause");return 0;
}
注意事项:在执行循环语句时候,程序必须提供跳出循环的出口,否则出现死循环
while循环练习案例:猜数字
案例描述:系统随机生成一个1到100以内的数字,玩家进行猜测,如果猜错,提示玩家数字过大或者数字过小,如果猜对恭喜玩家胜利,并且退出游戏。
#include <iostream>
using namespace std;
//time系统时间头文件包含
#include <ctime>int main()
{//添加随机数种子 作用利用当前系统时间生成随机数,防止每次随机数都一样srand((unsigned int)time(NULL));//1、系统生成随机数int num = rand() % 100 + 1; //rand()%100 + 1 生成 0 + 1 - 99 + 1 随机数//cout << num << endl;//2、玩家进行猜测int val = 0;while (1){cin >> val;//3、判断玩家的猜测//猜错 提示猜的结果 过大或者过小 重新返回第2步if (val > num){cout << "猜测过大" << endl;}else if (val < num){cout << "猜测过小" << endl;}else{cout << "恭喜您猜对了" << endl;//猜对 退出游戏break; //break在循环中,可以利用该关键字来退出当前循环}}system("pause");return 0;
}
do…while循环语句
作用:满足判断条件,执行循环语句
语法:do{ 循环语句 }while(循环条件);
注意:与while的区别是do…while会先执行一次循环语句,再去判断循环条件
#include <iostream>
using namespace std;int main()
{//do...while语句//在屏幕中输出0-9这10个数字int num = 0;do{cout << num << endl;num++;} while (num < 10);/*while (num < 10){cout << num << endl;num++;}*///do...while与while的区别是do...while会先执行一次循环语句 ,再去判断循环条件system("pause");return 0;
}
练习案例:水仙花数
案例描述:水仙花数是一个3位数,他的每个位上的数字的3次幂之和等于它本身。
例如:13+53+33=1531^3+5^3+3^3=15313+53+33=153
请利用do…while语句,求出所有3位数中的水仙花数
思路:
1、将所有的三位数进行输出(100-999)
2、在所有三位数中找到水仙花数
水仙花数 153
获取个位 153 % 10 = 3 对数字取模于10 可以获取到个位
获取十位 153 /10 = 15 15 % 10 = 5 先整除于10,得两位数,再取模于10,得到十位
获取百位 153 / 100 = 1 直接整除于100,获得百位
判断 个位3+十位3+百位3=本身{个位}^3+{十位}^3+{百位}^3=本身个位3+十位3+百位3=本身
#include <iostream>
using namespace std;int main()
{//1、先打印所有三位数字int num = 100;do{//2、从所有三位数字中找到水仙花数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);system("pause");return 0;
}
for循环语句
作用:满足循环条件,执行循环语句
语法:for(起始表达式;条件表达式;末尾循环体){ 循环语句; }
#include <iostream>
using namespace std;int main()
{//for循环//从数字0 打印到 数字9/*for (int i = 0; i < 10; i++ ){cout << i << endl;}*/int i = 0;for (; ; ){if (i >= 10){break;}cout << i << endl;i++;}system("pause");return 0;
}
注意:for循环中的表达式,要用分号进行分隔
总结:while,do…while,for都是开发中常用的循环语句,for循环结构比较清晰,比较常用
联系案例:敲桌子
案例描述:从1开始数到数字100,如果数字个位含有7,或者十位含有7,或者是7的倍数,我们打印敲桌子,其余数字直接打印输出。
1、先输出1到100 这些数字
2、从这100个数字中找到特殊数字,改为“敲桌子”
特殊数字
7的倍数 (7 14 21 28 …) % 7 = 0
个位有7 (7 17 27 37 …) % 10 = 7
十位有7 (70 71 72 73 …) / 10 =7
#include <iostream>
using namespace std;int main()
{for (int i = 1; i <= 100; i++ ){if (i % 7 == 0 || i % 10 == 7 || i / 10 == 7){cout << "敲桌子" << endl;}else{cout << i << endl;}}system("pause");return 0;
}
4.2.4 嵌套循环
作用:在循环体中再去嵌套一层循环,解决一些实际的问题
例如我们想在屏幕中打印如下图片,就需要利用嵌套循环
#include <iostream>
using namespace std;int main()
{//利用嵌套循环实现星图//打印一行星图//外层执行一次,内层执行一周//外层循环for (int i = 0; i < 10; i++){//内层循环for (int j = 0; j < 10; j++){cout << "* ";}cout << endl;}system("pause");return 0;
}
练习案例:乘法口诀表
案例描述:利用嵌套循环,实现九九乘法表
#include <iostream>
using namespace std;int main()
{//乘法口诀表//打印行数for (int i = 1; i <= 9; i++){//cout << i << endl;for (int j = 1; j <= i; j++){cout << j << "*" << i << "=" << j*i << " ";}cout << endl;}system("pause");return 0;
}
4.3 跳转语句
4.3.1 break语句
作用:用于跳出选择结构或者循环语句
break使用的时机:
- 出现在switch条件语句中,作用是终止case并且跳出switch
- 出现在循环语句中,作用是跳出当前的循环语句
- 出现在嵌套循环中,跳出最近的内层循环语句
#include <iostream>
using namespace std;int main()
{//break的使用时机1、出现在switch语句中//cout << "请选择副本难度" << endl;//cout << "1、普通" << endl;//cout << "2、中等" << endl;//cout << "3、困难" << endl;//int select = 0;//创建选择结果的变量//cin >> select;//等待用户输入//switch (select)//{//case 1:// cout << "您选择的是普通难度" << endl;// break;//退出switch语句//case 2:// cout << "您选择的是中等难度" << endl;// break;//case 3:// cout << "您选择的是困难难度" << endl;// break;//default:// break;//}2、出现在循环语句中//for (int i = 0; i < 10; i++)//{// //如果i等于5,退出循环,不再打印// if (i == 5)// {// break;//退出循环// }// cout << i << endl;//}//3、出现在嵌套循环语句中for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (j == 5){break;//退出内层循环}cout << "* " ;}cout << endl;}system("pause");return 0;
}
4.3.2 continue语句
作用:在循环语句中,跳过本次的循环中余下尚未执行的语句,继续执行下一次循环
#include <iostream>
using namespace std;int main()
{//continue语句for (int i = 0; i <= 100; i++){//如果是奇数输出,偶数不输出if (i % 2 == 0)//0 2 4 6 8 10{ continue;//可以筛选条件,执行到此就不在执行,执行下一次循环,如果是break会退出循环。}cout << i << endl;}system("pause");return 0;
}
4.3.3 goto语句
作用:可以无条件的跳转语句
语法:goto 标记;
解释:如果标记的名称存在,执行到goto语句时,会跳转到标记的位置。
1 xxxxx
2 xxxxx
goto FLAG;
3 xxxxx
4 xxxxx
FLAG:
5 xxxxx
会跳过三四到标记执行后面语句
#include <iostream>
using namespace std;int main()
{//goto语句cout << "1、xxxx" << endl;cout << "2、xxxx" << endl;goto FLAG;cout << "3、xxxx" << endl;cout << "4、xxxx" << endl;FLAG:cout << "5、xxxx" << endl;system("pause");return 0;
}
注意:在程序中不建议使用goto语句,以免造成程序混乱
5. 数组
5.1 概述
所谓数组,就是一个集合,里面存放了相同类型的数据元素。
特点1:数组中的每个数据元素都是相同的数据类型
特点2:数组是由连续的内存位置组成的。
5.2 一维数组
5.2.1 一维数组定义方式
一维数组的三种定义方法:
数据类型 数组名[ 数组长度 ];
数据类型 数组名[ 数组长度 ] = { 值1, 值2 ...};
数据类型 数组名[ ] = { 值1, 值2, ...};
#include <iostream>
using namespace std;int main()
{//数组/*1. 数据类型 数组名[ 数组长度 ];2. 数据类型 数组名[ 数组长度 ] = { 值1, 值2 ...};3. 数据类型 数组名[ ] = { 值1, 值2, ...};*///1. 数据类型 数组名[ 数组长度 ];int arr[5];//给数组中的元素进行赋值arr[0] = 10;arr[1] = 20;arr[2] = 30;arr[3] = 40;arr[4] = 50;//访问数据元素cout << arr[0] << endl;cout << arr[1] << endl;cout << arr[2] << endl;cout << arr[3] << endl;cout << arr[4] << endl;//2. 数据类型 数组名[数组长度] = { 值1, 值2 ... };//如果在初始化数据时候,没有全部填写完,会用0来填补剩余数据int arr2[5] = { 10, 20, 30, 40, 50 };/*cout << arr2[0] << endl;cout << arr2[1] << endl;cout << arr2[2] << endl;cout << arr2[3] << endl;cout << arr2[4] << endl;*///利用循环 输出数组中的元素for (int i = 0; i < 5; i++){cout << arr2[i] << endl;}//3. 数据类型 数组名[] = { 值1, 值2, ... };//定义数组的时候,必须有初始长度int arr3[] = { 90, 80, 70, 60, 50, 40, 30, 20, 10 };for (int i = 0; i < 9; i++){cout << arr3[i] << endl;}system("pause");return 0;
}
.
5.2.2 一维数组数组名
一维数组的名称的用途:
可以统计整个数组在内存中的长度
可以获取数组在内存中的首地址
#include <iostream>
using namespace std;int 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 << "数组首地址为:" << arr << endl;cout << "数组首地址(转十进制)为:" << (int) arr << endl;//arr[0]是第一个元素,想看地址前面加一个&cout << "数组中第一个元素地址为:" << &arr[0] << endl;cout << "数组中第一个元素地址(转十进制)为:" << (int) &arr[0] << endl;cout << "数组中第二个元素地址(转十进制)为:" << (int)&arr[1] << endl;// 数组名是常量,不可以进行赋值操作//arr = 100;system("pause");return 0;
}
练习案例1:五只小猪称体重
案例描述:
在一个数组中记录了五只小猪的体重,如int arr[5] = { 300, 350, 200, 400, 250}
;找出并打印最重的小猪的体重。
#include <iostream>
using namespace std;int main()
{//1、创建5只小猪体重的数组int arr[5] = { 300, 350, 200, 400, 250 };//2、从数组中找到最大值int max = 0;//先认定一个最大值为0for (int i = 0; i < 5; i++){//cout << arr[i] << endl;//如果访问的数组中的元素比我认定的最大值还有大,更新最大值|if (arr[i] > max){max = arr[i];}}//3、打印最大值cout << "最重的小猪体重为:" << max << endl;system("pause");return 0;
}
练习案例2:数组元素逆置
案例描述:请声明一个5个元素的数组,并且将元素逆置。
(如原数组元素为:1,3,2,5,4; 逆置后的输出结果:4,5,2,3,1);
5.2.3 冒泡排序
作用:最常用的排序算法,对数组内的元素进行排序
- 比较相邻的元素,如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素做相同的工作,执行完毕后,找到第一个最大值。
- 重复以上的步骤,每一次比较次数-1,直到不需要比较。
排序总轮数 = 元素个数 - 1;
每轮对比次数 = 元素个数 - 排序轮数 - 1;
#include <iostream>
using namespace std;int main()
{//利用冒泡排序实现升序序列int arr[] = { 4, 2, 8, 0, 5, 7, 1, 3, 9 };cout << "排序前:" << endl;for (int i = 0; i < 9; i++){cout << arr[i] << " ";}cout << endl;//开始冒泡排序//总共排序轮数为 元素个数 - 1for (int i = 0; i < 9 - 1; i++){//内层循环对比 次数 = 元素个数 - 当前轮数 - 1for (int j = 0; j < 9 - 1; j++){//如果第一个数字,比第二个数字大,交换两个数字if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}//排序后结果cout << "排序后:" << endl;for (int i = 0; i < 9; i++){cout << arr[i] << " ";}cout << endl;system("pause");return 0;
}
5.3 二维数组
二维数组就是在一维数组上,多加一个维度。
5.3.1 二维数组的定义方式
二维数组有四种定义方式:
数据类型 数组名[ 行数 ][ 列数 ];
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1, 数据2 } , {数据3, 数据4 } };
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};
数据类型 数组名[ ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};
建议:以上4种定义方式,利用第二种更加直观,提高代码的可读性
#include <iostream>
using namespace std;int main()
{//二维数组定义方式/*1. 数据类型 数组名[ 行数 ][ 列数 ];2. 数据类型 数组名[ 行数 ][ 列数 ] = { {数据1, 数据2 } , {数据3, 数据4 } };3. 数据类型 数组名[ 行数 ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};4. 数据类型 数组名[ ][ 列数 ] = { 数据1, 数据2, 数据3, 数据4};*///1. 数据类型 数组名[行数][列数];int arr[2][3];arr[0][0] = 1;arr[0][1] = 2;arr[0][2] = 3;arr[1][0] = 4;arr[1][1] = 5;arr[1][2] = 6;//外层循环打印行数,内层循环打印列数for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr[i][j] << " ";}cout << endl;}//2. 数据类型 数组名[行数][列数] = { {数据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;}//3. 数据类型 数组名[行数][列数] = { 数据1, 数据2, 数据3, 数据4 };int arr3[2][3] = { 1, 2, 3, 4, 5, 6 };for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr3[i][j] << " ";}cout << endl;}//4. 数据类型 数组名[][列数] = { 数据1, 数据2, 数据3, 数据4 };int arr4[][3] = { 1, 2, 3, 4, 5, 6 };for (int i = 0; i < 2; i++){for (int j = 0; j < 3; j++){cout << arr4[i][j] << " ";}cout << endl;}system("pause");return 0;
}
总结:在定义二维数组时,如果初始化了数据,可以省略行数
5.3.2 二维数组数组名
- 查看二维数组所占的内存空间
- 获取二维数组的首地址
#include<iostream>
using namespace std;int main()
{//二维数组的名称用途//1.可以查看占用的内存空间大小int arr[2][3] ={{1,2,3},{4,5,6}};double arr2[2][3] ={{1,2,3},{4,5,6}};cout << "二维数组(int)占用的内存空间为:" << sizeof(arr) << endl;cout << "二维数组(double)占用的内存空间为:" << sizeof(arr2) << 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;//2.可以查看二维数组的首地址cout << "二维数组的首地址为" << (int)arr << endl;cout << "二维数组第一行的首地址为:" << (int)arr[0] << endl;cout << "二维数组第二行的首地址为:" << (int)arr[1] << endl;cout << "二维数组第一个元素的首地址为:" << (int)&arr[0][0] << endl;cout << "二维数组第二个元素的首地址为:" << (int)&arr[0][1] << endl;system("pause");return 0;
}
5.3.3 二维数组应用案例
考试成绩统计:
案例描述:有三名同学(张三,李四,王五),在一次考试中的成绩分别如下表,请分别输出三位同学的总成绩
语文 | 数学 | 英语 | |
---|---|---|---|
张三 | 100 | 100 | 100 |
李四 | 90 | 50 | 100 |
王五 | 60 | 70 | 80 |
1、创建二维数组:3行3列
2、统计考试成绩,让每行的3列相加,统计总和
#include<iostream>
using namespace std;
#include<string>int main()
{//二维数组案例-考试成绩统计//1、创建二维数组int scores[3][3] ={{100,100,100},{90,50,100},{60,70,80}};string names[3] = { "张三","李四","王五" };//2、统计每一人的总和分数for (int i = 0; i < 3; i++){int sum = 0;//统计分数总和变量for (int j = 0; j < 3; j++){sum += scores[i][j];cout << scores[i][j] << "\t";}cout << names[i] << "的总分为" << sum << endl;}system("pause");return 0;
}
6. 函数
6.1 概述
作用:将一段经常使用的代码封装起来,减少重复代码
一个较大的程序,一般分为若干个程序块,每一个模块实现特定的功能。
6.2 函数的定义
函数的定义一般主要有5个步骤:
- 返回值类型:一个函数可以返回一个值。在函数定义中
- 函数名:给函数起个名
- 参数列表:使用该函数时,传入的数据
- 函数体语句:花括号内的代码,函数内需要执行的语句
- return表达式:和返回值类型挂钩,函数执行完后,返回相应的数据
语法:
返回值类型 函数名 (参数列表)
{函数体语句return表达式
}
示例:定义一个加法函数,实现两个数相加
实现一个加法运算,功能是传入两个整型数据,计算数据相加的结果,并且返回
1、返回值类型
int
2、函数名
add
3、参数列表
(int num1, int num2)
4、函数体语句
int sum = num1 + num2;
5、return表达式
return sum;
int add(int num1, int num2)
{int sum = num1 + num2;return sum;
}
6.3 函数的调用
#include<iostream>
using namespace std;//定义加法函数
//函数定义的时候,num1和num2并没有真实数据
//他只是一个形式上的参数,简称为形参
int add(int num1, int num2)
{int sum = num1 + num2;return sum;
}int main()
{//main函数中调用add函数int a = 10;int b = 20;//函数调用语法:函数名称 (参数)//a和b称为 实际参数, 简称实参//当调用函数的时候,实参会把值传递给形参int c = add(a, b);cout << "c = " << c << endl;a = 100;b = 500;c = add(a, b);cout << "c = " << c << endl;system("pause");return 0;
}
6.4 值传递
- 所谓值传递,就是函数调用时实参将数值传入给形参
- 值传递时,如果形参发生改变,并不会影响实参
#include<iostream>
using namespace std;//值传递
//定义函数,实现两个数字进行交换函数//如果函数不需要返回值,声明的时候可以写voidvoid swap(int num1, int num2)
{cout << "交换前" << endl;cout << "num1 = " << num1 << endl;cout << "num2 = " << num2 << endl;int temp = num1;num1 = num2;num2 = temp;cout << "交换前" << endl;cout << "num1 = " << num1 << endl;cout << "num2 = " << num2 << endl;//return; 返回值不需要的时候,可以不写return
}int main()
{int a = 10;int b = 20;cout << "a = " << a << endl;cout << "b = " << b << endl;//当我们做值传递的时候,函数的形参发生改变,并不会影响实参swap(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;system("pause");return 0;
}
值传递学习
总结:值传递时,形参是修饰不了实参的
6.5 函数的常见样式
- 无参无返
- 有参无返
- 无参有返
- 有参有返
#include<iostream>
using namespace std;//函数常见样式
//1. 无参无返
void test01()
{cout << "this is test01" << endl;
}//2. 有参无返
void test02(int a)
{cout << "this is test02 a = " << a << endl;
}//3. 无参有返
int test03()
{cout << "this is test03 " << endl;return 1000;
}//4. 有参有返
int test04(int a)
{cout << "this is test042 a = " << a << endl;return a;
}int main()
{//无参无返函数调用test01();//有参无返函数调用test02(100);//无参有返函数调用int num1 = test03();cout << "num1 = " << num1 << endl;//有参有返函数调用int num2 = test04(10000);cout << "num2 = " << num2 << endl;system("pause");return 0;
}
6.6 函数的声明
作用:告诉编译器函数名称以及如何调用函数。函数的实际主体可以单独定义。
- 函数的声明可以多次,但是函数的定义只能有一次。
#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;
}//定义
int max(int a, int b)
{return a > b ? a : b;
}
6.7 函数分文件编写
作用:让代码结构更加清晰
函数分文件编写有四个步骤:
- 创建后缀名为.h的头文件
- 创建后缀名为.cpp的源文件
- 在头文件中写函数的声明
- 在源文件中写函数的定义
#include<iostream>
using namespace std;
#include "swap.h"//函数的分文件编写
//实现两个数字进行交换的函数函数的声明
//void swap(int a, int b);
//函数的定义
//void swap(int a, int b)
//{
// int temp = a;
// a = b;
// b = temp;
//
// cout << "a = " << a << endl;
// cout << "b = " << b << endl;
//}//1. 创建后缀名为.h的头文件
//2. 创建后缀名为.cpp的源文件
//3. 在头文件中写函数的声明
//4. 在源文件中写函数的定义int main()
{int a = 10;int b = 20;swap(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;system("pause");return 0;
}
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;
}
7. 指针
7.1 指针的基本概念
指针的作用:可以通过指针间接访问内存
- 内存编号是从0开始记录的,一般用十六进制数字表示
- 可以利用指针变量保存地址
7.2 指针变量的定义和使用
指针变量定义语法: 数据类型 *变量名;
指针变量的定义与使用
#include<iostream>
using namespace std;int main()
{//1、定义一个指针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;system("pause");return 0;
}
7.3 指针所占内存空间
提问:指针也是种数据类型,那么这种数据类型占用多少内存空间?
#include<iostream>
using namespace std;int main()
{// 指针所占的内存空间int a = 10;//int * p;//p = &a;int * p = &a;cout << "sizeof (int *) = " << sizeof(p) << endl;cout << "sizeof (int *) = " << sizeof(int *) << endl;cout << "sizeof (int *) = " << sizeof(float*) << endl;cout << "sizeof (int *) = " << sizeof(double*) << endl;cout << "sizeof (int *) = " << sizeof(char*) << endl;cout << "sizeof (int *) = " << sizeof(bool*) << endl;//在32位操作系统下,指针占4个字节,在64位操作系统下,指针占8个字节。system("pause");return 0;
}
7.4 空指针和野指针
空指针
空指针:指针变量指向内存中编号为0的空间
用途:初始化指针变量
注意:空指针指向的内存是不可以访问的
示例1:空指针
#include<iostream>
using namespace std;int main()
{//空指针//1.空指针用于给指针变量进行初始化int * p = NULL;//2.空指针是不可以进行访问的//0-255之间的内存编号是系统占用的,因此不可以访问//*p = 100;system("pause");return 0;
}
空指针
空指针:指针指向非法的内存空间。
#include<iostream>
using namespace std;int main()
{//野指针//在程序中,尽量避免出现野指针int * p = (int *)0x1100;//cout << *p << endl;system("pause");return 0;
}
总结:空指针和野指针都不是我们申请的空间,因此不要访问。
7.5 const修饰指针
const修饰指针有三种情况:
- const修饰指针 —常量指针
- const修饰常量 —指针常量
- const即修饰指针,又修饰常量
const修饰指针
#include<iostream>
using namespace std;int main()
{//1.const修饰指针 常量指针int a = 10;int b = 10;const int * p = &a;//指针指向的值不可以改,指针指向可以改//*p = 20;//错误,指针指向的值不可以改p = &b;//正确,指针指向可以改//2.const修饰常量 指针常量//指针的指向不可以改,指针指向的值可以改int * const p2 = &a;*p2 = 100;//正确,指针的指向不可以改//p2 = &b;//错误,指针指向的值可以改//3.const修饰指针和常量const int* const p3 = &a;//指针的指向 和指针指向的值 不可以改//*p = 100;//错误//p = &b;//错误system("pause");return 0;
}
技巧:看const右侧紧跟着的是指针还是常量,是指针就是常量指针,是常量就是指针常量
7.6 指针和数组
作用:利用指针访问数组中的元素
值传递学习
#include<iostream>
using namespace std;int main()
{//指针和数组//利用指针访问数组中的元素int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };cout << "第一个元素为:" << arr[0] << endl;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 << arr[i] << endl;cout << *p2 << endl;p2++;}system("pause");return 0;
}
7.7 指针与函数
作用:利用指针作为函数的参数,可以修改实参的值
#include<iostream>
using namespace std;//实现两个数字进行交换
void swap01(int a, int b)
{int temp = a;a = b;b = temp;cout << "swap01 a = " << a << endl;cout << "swap01 b = " << b << endl;
}void swap02(int *p1, int *p2) {int temp = *p1;*p1 = *p2;*p2 = temp;
}
int main() {//指针和函数//1.值传递//不会改变实参的值int a = 10;int b = 20;cout << "a = " << a << endl;cout << "b = " << b << endl;swap01(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;cout << "---------------------------------" << endl;//2.地址传递//如果是地址传递,可以修饰实参a = 23;b = 78;cout << "a = " << a << endl;cout << "b = " << b << endl;swap02(&a, &b);cout << "a = " << a << endl;cout << "b = " << b << endl;system("pause");return 0;
}
指针与函数
总结:如果不想修改实参,就用值传递,如果想修改实参,就用地址传递
7.8 指针、数组、函数
需求:封装一个函数,利用冒泡排序,实现对整型数组的升序排序
例如数组 int arr[10] = {4,3,6,9,1,2,10,8,7,5};
#include<iostream>
using namespace std;//冒泡升序排序函数 参数1 数组的首地址 参数2 数组长度
void bubbleSort(int * arr, int len)
{for (int i = 0; i < len - 1; i++){for (int j = 0; j < len - i - 1; j++){//如果arr[j] > arr[j + 1] 交换数字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] << endl;}
}int main()
{//1.创建数组int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };//数组长度int len = sizeof(arr) / sizeof(arr[0]);//2.创建函数实现冒泡排序bubbleSort(arr, len);//3.打印排序后的数组printArray(arr, len);system("pause");return 0;
}
8. 结构体
8.1 结构体的基本概念
结构体属于用户自定义的数据类型,允许用户存储不同的数据类型。
8.2 结构体的定义和使用
语法:struct 结构体名 { 结构体成员列表 };
通过结构体创建变量的方式有三种:
struct 结构体名 变量名
struct 结构体名 变量名 = { 成员1值, 成员2值…};
- 定义结构体时顺便创建变量
#include <iostream>
using namespace std;
#include <string>//1、创建学生数据类型 : 学生包括(姓名,年龄,分数)
struct Student
{//成员列表//姓名string name;//年龄int age;//分数int score;}s3;//顺便创建一个结构体变量//2、通过学生类型创建具体学生int main()
{//2.1 struct Student s1//struct 关键字可以省略Student s1;//给s1属性赋值,通过 . 访问结构体变量中的属性s1.name = "张三";s1.age = 18;s1.score = 95;cout << "姓名:" << s1.name << " 年龄:" << s1.age << " 分数:" << s1.score << endl;//2.2 struct Student s2 = { ... }struct Student s2 = {"李四", 19, 80};cout << "姓名:" << s2.name << " 年龄:" << s2.age << " 分数:" << s2.score << endl;//2.3 在定义结构体时顺便创建结构体变量s3.name = "王五";s3.age = 20;s3.score = 60;cout << "姓名:" << s3.name << " 年龄:" << s3.age << " 分数:" << s3.score << endl;system("pause");return 0;
}
总结1:定义结构体时的关键字是struct,不可省略
总结2:创建结构体变量时,关键字struct可以省略
总结3:结构体变量利用操作符" . "访问成员
8.3 结构体数组
作用:将自定义的结构体放入数组中方便维护
语法:struct 结构体名 数组名[元素个数] = { {}, {}, {},... {} };
#include <iostream>
using namespace std;
#include <string>//结构体数组
//1、定义结构体
struct Student
{//姓名string name;//年龄int age;//分数int score;};int main()
{//2、创建结构体数组struct Student stuArray[3] ={{"张三", 18, 95},{"李四", 28, 99},{"王五", 38, 66}};//3、给结构体数组中的元素赋值stuArray[2].name = "赵六";stuArray[2].age = 80;stuArray[2].score = 60;//4、遍历结构体数组for (int i = 0; i < 3; i++){cout << "姓名:" << stuArray[i].name << " 年龄:" << stuArray[i].age << " 分数:" << stuArray[i].score << endl;}system("pause");return 0;
}
8.4 结构体指针
作用:通过指针访问结构体中的成员
- 利用操作符
->
可以通过结构体指针访问结构体属性
#include<iostream>
using namespace std;
#include<string>//结构体指针//定义一个学生的结构体
struct student
{string name;//姓名int age;//年龄int score;//分数};int main()
{//1.创建学生的结构体变量struct student s = { "张三",18,100 };//2.通过指针直线结构体变量struct student * p = &s;//3.通过指针访问结构体变量中的数据//通过结构体指针 访问结构体属性,需要利用' -> 'cout << "姓名:" << p->name << " 年龄:" << p->age << " 分数:" << p->score << endl;system("pause");return 0;
}
8.5 结构体嵌套结构体
作用:结构体的成员可以是另一个结构体
例如:每个老师辅导一个学员,一个老师的结构体中,记录一个学生的结构体
#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 = 10000;t.name = "老王";t.age = 50;t.stu.name = "小王";t.stu.age = 20;t.stu.score = 60;cout << "老师姓名:" << t.name << " 老师编号:" << t.id << " 老师年龄:" << t.age << " 老师辅导的学生姓名:" << t.stu.name << " 学生年龄: " << t.stu.age<< " 学生的考试分数:" << t.stu.score << endl;system("pause");return 0;
}
结构体嵌套结构体
8.6 结构体做函数参数
作用:将结构体作为参数向函数中传递
传递方式有两种:
- 值传递
- 地址传递
#include<iostream>
using namespace std;
#include<string>//定义学生的结构体
struct student
{//姓名string name;//年龄int age;//分数int score;
};//打印学生信息函数//1.值传递
void printStudent1(struct student s)
{s.age = 100;cout << "子函数中 姓名:" << s.name << " 年龄:" << s.age << " 分数:" << s.score << endl;
}//2.地址传递
void printStudent2(struct student * p)
{p->age = 200;cout << "子函数中 姓名:" << p->name << " 年龄:" << p->age << " 分数:" << p->score << endl;
}
int main()
{//结构体做函数参数//将学生传入一个参数中,打印学生身上的所有信息//创建结构体变量struct student s;s.name = "张三";s.age = 20;s.score = 85;cout << "main函数中打印 姓名:" << s.name << " 年龄:" << s.age << " 分数:" << s.score << endl;printStudent1(s);cout << "main函数中打印 姓名:" << s.name << " 年龄:" << s.age << " 分数:" << s.score << endl;printStudent2(&s);cout << "main函数中打印 姓名:" << s.name << " 年龄:" << s.age << " 分数:" << s.score << endl;system("pause");return 0;
}
总结:如果不想修改主函数中的数据,用值传递,反之用地址传递
8.7 结构体中const使用场景
作用:用const来防止误操作
#include<iostream>
using namespace std;
#include<string>//const使用场景struct student
{//定义学生的结构体string name;//姓名int age;//年龄int score;//分数
};值传递:会将实参中的数据拷贝出一份传递给形参,不会出现任何错误
//void printStudents01(student s)
//{
// //非常占用内存
// s.age = 150;
// cout << " 姓名:" << s.name << " 年龄:" << s.age << " 分数:" << s.score << endl;
//}将函数中的形参改为指针,可以减少内存空间,而且不会复制新的副本出来
//void printStudents02(student *s)
//{
// s->age = 150;
// cout << " 姓名:" << s->name << " 年龄:" << s->age << " 分数:" << s->score << endl;
//}void printStudents03(const student *s)
{//s->age = 123;//加入const之后,一旦有修改的操作就会报错,可以防止误操作cout << " 姓名:" << s->name << " 年龄:" << s->age << " 分数:" << s->score << endl;
}
int main()
{//1.创建结构体变量struct student s = { "张三", 16, 75 };//2.通过函数打印结构体变量信息//printStudents01(s);//printStudents02(&s);//cout << "main中张三的年龄为:" << s.age << endl;printStudents03(&s);system("pause");return 0;
}
8.8 结构体案例
8.8.1 案例1
案例描述:
学校正在做毕设项目,每名老师带领5个学生,总共有3名老师,需求如下
设计学生和老师的结构体,其中在老师的结构体中,有老师的姓名和一个存放5名学生的数组作为成员
学生的成员有姓名、考试分数、创建数组存放3名老师,通过函数给每个老师及所带的学生赋值
最终打印出老师数据以及老师所带的学生的数据
结构体案例
#include<iostream>
using namespace std;
#include<string>
#include<ctime>//定义学生的结构体
struct Student
{//姓名string sName;//分数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[j];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 << "老师的姓名:" << tArray[i].tName << endl;for (int j = 0; j < 5; j++){cout << "\t学生的姓名:" << tArray[i].sArray[j].sName <<" 考试分数:" << tArray[i].sArray[j].score << endl;}}
}
int main()
{//添加随机数种子srand((unsigned int)time(NULL));//1.创建三名老师的数组struct Teacher tArray[3];//2.通过函数给3名老师的信息赋值,并给老师带的学生信息赋值int len = sizeof(tArray) / sizeof(tArray[0]);allocateSpace(tArray, len);//3.打印所有老师以及所带的学生的信息printInfo(tArray, len);system("pause");return 0;
}
8.8.2 实例2
案例描述:
设计一个英雄的结构体,包括成员姓名,年龄,性别;创建结构体数组,数组中存放5名英雄。
通过冒泡排序的算法,将数组中的英雄按照年龄进行升序排序,最终打印排序后的结果。
五名英雄信息如下:
{"刘备",23,"男"},{"关羽",22,"女"},{"张飞",20,"男"},{"赵云",21,"男"},{"貂蝉",19,"女"},
#include<iostream>
#include<string>
using namespace std;//1.设计英雄结构体
//英雄结构体
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 - i - 1; j++){//如果 j 下标的元素年龄 大于 j+1 下标的元素的年龄,交换两个元素if (heroArray[j].age > heroArray[j + 1].age){struct Hero temp = heroArray[j];heroArray[j] = heroArray[j + 1];heroArray[j + 1] = temp;}}}
}//打印排序后的数组的信息
void printHero(struct Hero heroArray[], int len)
{for (int i = 0; i < len; i++){cout << "\t姓名:" << heroArray[i].name<< " 年龄:" << heroArray[i].age << " 性别:" << heroArray[i].sex << endl;}
}
int main()
{//2.创建数组存放5名英雄struct Hero heroArray[5] ={{"刘备",23,"男"},{"关羽",22,"女"},{"张飞",20,"男"},{"赵云",21,"男"},{"貂蝉",19,"女"},};int len = sizeof(heroArray) / sizeof(heroArray[0]);cout << "排序前打印:" << endl;for (int i = 0; i < len; i++){cout << "\t姓名:" << heroArray[i].name<< " 年龄:" << heroArray[i].age << " 性别:" << heroArray[i].sex << endl;}//3.对数组进行排序,按照年龄进行升序排序bubbleSort(heroArray, len);cout << "排序后打印:" << endl;//4.将排序后的结果进行打印输出printHero(heroArray, len);system("pause");return 0;
}
先更新到这里,还没继续学习更新。
【c++】c++基础入门相关推荐
- 用python循环语句求素数_Python基础入门_3条件语句和迭代循环
Python 基础入门前两篇: Python 基础入门--简介和环境配置 Python基础入门_2基础语法和变量类型 这是第三篇内容,主要简单介绍条件语句和迭代循环语句,内容也比较简单,目录如下: 条 ...
- MAYA 2022基础入门学习教程
流派:电子学习| MP4 |视频:h264,1280×720 |音频:AAC,48.0 KHz 语言:英语+中英文字幕(根据原英文字幕机译更准确)|大小解压后:3.41 GB |时长:4.5小时 包含 ...
- Blender 3.0基础入门学习教程 Introduction to Blender 3.0
成为Blender通才,通过这个基于项目的循序渐进课程学习所有主题的基础知识. 你会学到什么 教程获取:Blender 3.0基础入门学习教程 Introduction to Blender 3.0- ...
- 三维地形制作软件 World Machine 基础入门学习教程
<World Machine课程>涵盖了你需要的一切,让你有一个坚实的基础来构建自己的高质量的电影或视频游戏地形. 你会学到什么 为渲染或游戏开发创建高分辨率.高细节的地形. 基于Worl ...
- SketchUp Pro 2021基础入门学习视频教程
SketchUp Pro 2021基础入门学习视频教程 1280X720 MP4 |视频:h264,1280×720 |音频:AAC,44.1 KHz,2 Ch 流派:电子学习|语言:英语+中文字幕( ...
- Maya基础入门学习教程
Maya基础入门学习教程 视频:.MKV, 1280x720, 共57节课 时长 4小时25分钟,3GB 语言:英语+中文字幕(根据原英文字幕机译更准确)+原英文字幕 指导老师:Shane Whitt ...
- Maya2022基础入门学习教程
Maya2022基础入门学习教程 Maya 2022 Essential Training Maya2022基础入门学习教程 Maya 2022 Essential Training MP4 |视频: ...
- Blender基础入门学习教程 Learning Blender from Scratch
Blender基础入门学习教程 Learning Blender from Scratch 流派:电子学习| MP4 |视频:h264,1280×720 |音频:aac,48000 Hz 语言:英语+ ...
- json vue 对象转数组_vue 基础入门(一)修改
vue基础入门(一) 1. 什么是vue Vue.js(读音 /vjuː/, 类似于 view) 是一套构建用户界面的渐进式框架. Vue 只关注视图层, 采用自底向上增量开发的设计. Vue 的目标 ...
- python 二进制流转图片_Python零基础入门到精通-5.1节:Python程序的执行过程
教程引言: 系统地讲解计算机基础知识,Python的基础知识, 高级知识,web开发框架,爬虫开发,数据结构与算法,nginx, 系统架构.一步步地帮助你从入门到就业. 5.1.1 在命令行中执行Py ...
最新文章
- pyQt 每日一练习 -- 登录框
- 关于耳机的国标和美标的区分
- java堆外内存6_Java堆外内存排查小结
- SAP MM 巴西采购订单中的NCM Code
- GDCM:检查二个dicom文件的BigEndian错误的测试程序
- 2019寒假第三次作业
- 前端解析返回的对象时json显示$ref问题的解决
- 汇编语言-014(编写过程的应用、伪指令LEA、ENTER、LEAVE、LOCAL、递归函数、INVOKE、ADDR、PROC伪指令声明过程)
- 【小程序】【Tips】等待服务器的反馈的定时、间隔运行的正确方法
- Bootstrap3 Affix插件
- 源码分析Dubbo前置篇-寻找注册中心、服务提供者、服务消费者功能入口
- 搞懂webdriver的底层原理,才敢说自己懂自动化!
- jsp 九大内置对象详解以及示例
- win10 下mysql环境变量配置
- python之论文降重工具
- 将计算机与局域网互连 需要_,计算机与局域网连接需要的硬件是什么
- laravel安装laravel-s
- 2021年保育员(中级)考试及保育员(中级)考试资料
- 在外企必会的英文单词
- 分块矩阵求行列式的一道题
热门文章
- 瑞尔森大学计算机科学研究生,瑞尔森大学计算机科学硕士申请.pdf
- 数据防泄漏对于数据安全的重要性
- R语言使用oneway.test函数执行单因素方差分析(One-Way ANOVA)、使用aov函数执行单因素方差分析(aov函数默认组间方差相同)
- html表格如何创建搜索,6.如何创建HTML表格
- X11-forwarding笔记
- 安卓市场的“安全评估报告”攻略
- 计算机网络安全开题报告怎么写,网络安全开题报告范文精选
- SNN、RNN、CNN
- e4a java_易安卓e4a编译生成R.java文件失败的解决办法
- 2022年免费企业邮箱大全,用免费邮箱发邮件安全吗?