管理网站英文,如何建设网站首页,泰安那家网好,云主机如何建网站前言#xff1a;
笔记基于C黑马程序员网课视频#xff1a;黑马程序员匠心之作|C教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili 在此发布笔记#xff0c;只是为方便学习#xff0c;不做其他用途#xff0c;原作者为黑马程序员。 1. C基础 1.1 用Visual Studio写C程… 前言
笔记基于C黑马程序员网课视频黑马程序员匠心之作|C教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili 在此发布笔记只是为方便学习不做其他用途原作者为黑马程序员。 1. C基础 1.1 用Visual Studio写C程序输出Hello World 1.1.1 下载并配置Visual Studio环境
1.官网www.microsoft.com 2.下载Visual Studio安装包 安装Visual Studio 1.工作负荷选C桌面开发 2. 单个组件默认 电脑是Window11系统要勾选Window11系统 3.选择安装位置 4.第一次安装可以改安装位置否则要改注册表编辑器的设置 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\Setup 1.1.2 用Visual Studio写C程序 代码
//在屏幕中输出 Hello World#includeiostream
using namespace std;int main() {cout Hello World endl; //屏幕显示“Hello World”system(pause); //按任意键继续退出程序return 0;
}/*
Hello World
请按任意键继续. . .
*/
1. main函数
① main函数是一个程序的入口
② 每个程序都必须有这么一个函数并且有且只有一个。
2. 打印
① cout XXXX endl; 会使得屏幕打印双引号里面的字符串。
② system(pause); 会使得屏幕的打印界面暂停到该语句这里按任意键后才会继续运行。 1.2 注释、变量、常量、标识符、关键字
1.2.1 注释
① 在代码中的加一些说明和解释这些说明和解释就叫注释。
② 注释能方便自己和其他程序员阅读代码。
③ C的注释有两种格式
1.单行注释 // 描述信息
通常放在一行代码的上方或者一条语句的末尾对该行代码说明。
2.多行注释 /* 描述信息 */
编译器在编译代码时会忽略注释的内容即不会执行。 1.2.2 变量
① 变量的作用就是就是给一段指定的内存空间起名方便操作这段内存。
② 语法数据类型 变量名 初始值
③ 变量存在的意义方便我们管理内存空间。
④ 每一段内存都有一个地址编号。
⑤ C规定在创建一个常量或变量时必须要指出相应的数据类型否则无法给变量分配内存。
#include iostream
using namespace std;int main()
{//变量创建的语法数据类型 变量名 变量初始值int a 10; cout a a endl; // 输出语句 cout 提示语 变量 endl; system(pause);return 0;}/*
a 10
请按任意键继续. . .
*/ 1.2.3 常量
① 常量用于记录程序中不可更改的数据。
② C定义常量两种方式
1.define 宏常量#define 常量名 常量值
通常在文件上方定义表示一个常量。
2.const修饰的变量const 数据类型 常量名 常量值
通常在变量定义前加关键字const修饰该变量为常量不可修改。 #define 常量名 常量值
#include iostream
using namespace std;#define Day 7 int main()
{/*Day 14; //错误Day是常量一旦修改就会报错cout 一周总共有 Day 天 endl;*/cout 一周总共有 Day 天 endl;// 输出语句cout 提示语 变量 endl; system(pause);return 0;}/*
一周总共有7天
请按任意键继续. . .
*/ const 数据类型 常量名 常量值
#include iostream
using namespace std;int main()
{/*const int month 12;month 24; //错误const修饰的变量也称为常量*/int month 12;month 24; //正确这样可以修改变量的值cout 一年总共有 month 个月 endl;system(pause);return 0;}/*
一年总共有24个月
请按任意键继续. . .
*/ 1.2.4 关键字
① 关键字是C中预先保留的单词(标识符)。
② 在定义变量或者常量的时候不要用关键字。 关键字表 1. int关键字
#include iostream
using namespace std;int main()
{// int int 10; // 错误第二个int是关键字不可以作为变量的名称system(pause);return 0;}/*
请按任意键继续. . .
*/ 2. sizeof关键字
① sizeof关键字可以统计数据类型所占内存大小。
② sizeof关键字书写语法sizeof ( 数据类型 / 变量 )
#include iostream
using namespace std;int main()
{cout short 类型所占内存空间为 sizeof(short) endl;system(pause);return 0;}/*
short 类型所占内存空间为2
请按任意键继续. . .
*/ 1.2.5 标识符
① 标识符就是 C 给变量、常量的命名。
② 标识符有一套自己的命名规则
标识符不能使关键字。标识符只能由字母、数字、下划线组成。第一个字符不能为数字。标识符中字母区分大小写。
③ 建议给标识符命名时争取做到见名知意方便自己和他人的阅读。
#include iostream
using namespace std;int main()
{//1、标识符不可以是关键字//int int 10; //报错//2、标识符由字母、数字、下划线构成int abc 10;int _abc 20;int _123abc 40;//3、标识符第一个字符只能是字母或下划线//int 123abc 50; //报错//4、标识符区分大小写int aaa 100;//cout AAA endl; //报错AAA和aaa不是同一个名称//建议给变量起名的时候最好能够做到见名知意int num1 10;int num2 20;int sum num1 num2; //建议用num1、num2、sum表示加法而不是用a、b、c来表示cout sum endl;system(pause);return 0;}/*
30
请按任意键继续. . .
*/ 2. C的数据类型
2.1.1 整形
① 作用整型变量表示的是整数类型的数据。
② C中能够表示整形的类型有以下几种方式区别在于所占内存空间不同。
③ 数据类型 占用空间 取值范围
short(短整型) 2字节 -2^15-2^15-1int整型 4字节 -2^31-2^31-1long(长整型 Windows为4字节Linux为4字节(32位)8字节(64位) -2^31-2^31-1long long(长长整型) 8字节 -2^63-2^63-1 #include iostream
using namespace std;int main()
{//1、短整型(-32768~32767)short num1 10;short num5 32768; //溢出了打印出来是-23768short num6 32770; //溢出了打印出来是-32766//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;cout num5 num5 endl;cout num6 num6 endl;system(pause);return 0;}/*
num1 10
num2 10
num3 10
num4 10
num5 -32768
num6 -32766
请按任意键继续. . .
*/ 2.1.2 实型(浮点型)
① 作用用于表示小数。
② 浮点型变量分为下面两种两个的区别在于表示有效数字范围不同。
单精度float双精度double
③ 数据类型 占用字节 有效数字范围
float 4字节 7位有效数字double 8字节 15-16位有效数字
2.1.2.1 单精度、双精度
#include iostream
using namespace std;int main()
{//1、单精度 float//2、双精度 double//默认情况下无论单精度还是双精度都只会显示6位有效数字float f1 3.1415926; //默认为双精度前面加float相当于把双精度转换为单精度float f2 3.1415926f; //后面加一个f直接创建的是单精度cout f1 f1 endl;double d1 3.1415926;cout d1 d1 endl;cout float 占用内存空间为 sizeof(float) endl;cout double 占用内层空间为 sizeof(double) endl;system(pause);return 0;}/*
f1 3.14159
d1 3.14159
float 占用内存空间为4
double 占用内层空间为8
请按任意键继续. . .
*/
2.1.2.2 科学计数法
#include iostream
using namespace std;int main()
{//科学计数法float f3 3e2; // 3 * (10 ^ 2)cout f3 f3 endl;float f4 3e-2; // 3 * (0.1 ^ 2)cout f4 f4 endl;system(pause);return 0;
}/*
f3 300
f4 0.03
请按任意键继续. . .
*/
2.1.3 字符型
① 字符型变量用于显示单个字符。
② 语法char ch a;
③ 在显示字符型变量时用单引号字符括起来不要用双引号。
④ 单引号内只能有一个字符不可以是字符串。
⑤ C和C中字符型变量只占用1个字节。
⑥ 字符型变量并不是把字符本身放到内存中存储而是将对应的ASCII编码放入到存储单元。
⑦ ASCII码大致由以下两部分组成
ASCII非打印控制字符ASCII表上的数字0-31分配给了控制字符用于控制像打印机等一些外围设备。ASCII打印字符数字21-126分配给了能在键盘上找到的字符当查看或打印文档时就会出现。
#include iostream
using namespace std;int main()
{//1、字符型变量创建方式char ch a;cout ch endl;//2、字符型变量所占内存大小cout char字符型变量所占内存 sizeof(char) endl;//3、字符型变量常见错误char ch2 b; //创建字符型变量时候要用单引号//char ch3 b; //错误创建字符型变量时候不能用双引号//char ch4 abcdef; //错误创建字符型变量时候单引号内只能有一个字符//4、字符型变量对应ASCII编码cout (int)ch endl; // (int)ch 为字符a的ASCIII码值system(pause);return 0;}/*
a
char字符型变量所占内存1
97
请按任意键继续. . .
*/ 2.1.4 字符串型
① 用于表示一串字符。
② 字符串型有两种风格
③ C风格字符串char 变量名[] 字符串值
④ C风格字符串string 变量名 字符串值 #include iostream
using namespace std;
#include string //用C风格字符串时候要包含这个头文件int main()
{//1、C风格字符串//char 字符 这是一个字符//char 字符[] 这是一个字符串//表示字符串时等号后面要用双引号char str[] hello world;cout str endl;//2、C风格字符串string str2 hello world;cout str2 endl;system(pause);return 0;}/*
hello world
hello world
请按任意键继续. . .
*/ 2.1.5 布尔类型 bool
① 布尔数据类型代表真或假的值。
② bool类型只有两个值
true -- 真 (本质是1)false -- 假(本质是0)
③ bool类型占1个字节大小
#include iostream
using namespace std;int main()
{//1、创建bool数据类型bool flag1 true; //true代表真cout flag1 endl;bool flag2 false; //flag 代表假cout flag2 endl;//本质上 1代表真 0代表假//2、查看bool类型所占空间cout bool所占内存空间 sizeof(flag1) endl;cout bool所占内存空间 sizeof(flag2) endl;system(pause);return 0;}/*
1
0
bool所占内存空间1
bool所占内存空间1
请按任意键继续. . .
*/ 2.1.6 转义字符
① 用于表示一些不能显示出来的ASCII字符。
② 我们常用的转义字符有\n、\、\t。 #include iostream
using namespace std;int main()
{//换行符 \ncout hello world\n;//反斜杠 \\ 要输出反斜杠\时要在前面加上一个反斜杠cout \\ endl;//水平制表符\t 可以整齐的输出数据cout aaaa\thellowworld endl;cout aa\thellowworld endl;cout aaaaaa\thellowworld endl;system(pause);return 0;}/*
hello world
\
aaaa hellowworld
aa hellowworld
aaaaaa hellowworld
请按任意键继续. . .
*/
2.1.7 数据输入
① 数据的输入作用用于从键盘获取数据。
② 数据的输入关键字cin
③ 数据饿输入语法cin 变量
#include iostream
using namespace std;
#include string //包含string的头文件
int main()
{//1、创建bool数据类型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 ; //仅仅声明了没有初始化cout 请给字符型变量 ch 赋值 endl;cin ch;cout 字符型变量 ch ch endl;//4、字符型string str hello;cout 请给字符串 str 赋值 endl;cin str;cout 字符型变量 str str endl;//4、布尔型bool flag false;cout 请给布尔类型 flag 赋值 endl;cin flag; //布尔类型 只要是非0的值都代表真cout 布尔类型 flag flag endl;system(pause);return 0;}/*
请给整型变量 a 赋值
23
整型变量a 23
请给浮点型变量 f 赋值
23.4
浮点型变量 f 23.4
请给字符型变量 ch 赋值
w
字符型变量 ch w
请给字符串 str 赋值
asfg
字符型变量 str asfg
请给布尔类型 flag 赋值
4562
布尔类型 flag 1
请按任意键继续. . .
*/ 3. C的运算符
① 运算符作用用于执行代码的运算。
② 运算符类型主要有四种
算术运算符用于处理四则运算。赋值运算符用于将表达式的值赋给变量比较运算符用于表达式的比较并返回一个真值或假值。逻辑运算法用于表达式的值返回真值或假值。
3.1 算术运算符
3.1.1 加减乘除运算
#include iostream
using namespace std;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.51; //如果d1为0.5运算结果为整数2double d2 0.25;cout d1 / d2 endl; //运算结果也可以是小数system(pause);return 0;}/*
13
7
30
3
0
2.04
请按任意键继续. . .
*/ 3.1.2 取模运算
#include iostream
using namespace std;int main()
{//取摸运算本质 就是求余数int a1 10;int b1 3;cout a1 % b1 endl;/*两个数相除除数不可以为0所以也做不了取模运算int a2 10;int b2 0;cout a2 % b2 endl; //*//*两个小数是不可以做取模运算的double d1 3.14;double d2 1.1;cout d1 % d2 endl;*/system(pause);return 0;}/*
1
请按任意键继续. . .
*/
3.1.3 递增递减运算
#include iostream
using namespace std;int main()
{//1、前置递增int a 10;a;cout a a endl;//2、后置递增int b 15;b;cout 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;}/*
a11
b16
a2 11
b2 110
a3 11
b3 100
请按任意键继续. . .
*/ 3.2 赋值运算符
#include iostream
using namespace std;int main()
{// 赋值int a 10;a 100;cout a a endl;// 加等于int b 10;b 10;b 2;cout b b endl;// - 减等于int c 10;c 10;c - 2;cout c c endl;// * 乘等于int d 10;d 10;d * 2;cout d d endl;// / 除等于int e 10;e 10;e / 2;cout e e endl;// % 模等于int f 10;f 10;f % 2;cout f f endl;system(pause);return 0;}/*
a 100
b 12
c 8
d 20
e 5
f 0
请按任意键继续. . .
*/ 3.3 比较运算符
① 作用用于表达式的比较并返回一个真值或假值。
#include iostream
using namespace std;int main()
{//比较运算符// int a 10;int b 20;cout (a b) endl;// !cout (a ! b) endl;// cout (a b) endl;// cout (a b) endl;// cout (a b) endl;// cout (a b) endl;system(pause);return 0;}/*
0
1
0
1
0
1
请按任意键继续. . .
*/ 3.4 逻辑运算符
① 作用用于根据表达式的值返回真值或假值。
!a 表示非如果a为假则!a为真如果a为真则!a为假。ab 表示与如果a和b都为真则结果为真否则为假。a||b 表示或如果a和b有一个为真则结果为真二者都为假时结果为假。
#include iostream
using namespace std;int main()
{//逻辑运算符// !int a 10;int b 30;cout (!a) endl; //在C中除了0都为真cout (!!a) endl;// a 10;b 30;cout (a b) endl;a 0;b 10;cout (a b) endl;// ||a 10;b 30;cout (a || b) endl;a 0;b 10;cout (a || b) endl;a 0;b 0;cout (a || b) endl;system(pause);return 0;}/*
0
1
1
0
1
1
0
请按任意键继续. . .
*/ 4. C的程序流程结构
① C/C支持最基本的三种程序运行结构顺序结构、选择结构、循环结构
顺序结构程序按顺序执行不发生跳转选择结构依据条件是否满足有选择的执行相应功能循环结构依据条件是否满足循环多次执行某段代码
4.1 选择结构
4.1.1 单行 if 语句
① 单行if语句格式if(条件){条件满足执行的语句}
#include iostream
using namespace std;int main()
{// 选择结构 单行if语句// 用户输入分数如果分数大于600视为考上一本大学在屏幕上输出//1、用户输入分数int score 0;cout 请输入一个分数 endl; //在C中除了0都为真cin score;//2、打印用户输入的分数cout 您输入的分数为 score endl;//3、判断分数是否大于600如果大于那么输出//注意事项if条件后面不要加分号。加了分号条件不管满足还是不满足后面的都会运行if (score 600){cout 恭喜您考上了一本大学 endl;}system(pause);return 0;}/*
请输入一个分数
611
您输入的分数为 611
恭喜您考上了一本大学
请按任意键继续. . .
*/ 4.1.2 单行 else 语句
① 单行else语句格式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;}/*
请输入一个考试分数
490
您输入的分数为490
未考上一本大学
请按任意键继续. . .
*/ 4.1.3 多条件的 if 语句
① 多条件的if语句格式if(条件1){条件1满足执行的语句}else if(条件){条件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考上三本// 如果小于等于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;}/*
请输入一个考试分数
430
您输入的分数为430
恭喜您考上了三本大学
请按任意键继续. . .
*/ 4.1.4 嵌套 if 语句
① 嵌套if语句在if语句中可以嵌套使用if语句达到更精确的条件判断。
#include iostream
using namespace std;int main()
{// 选择结构 嵌套if语句//1、提示高考分数int score 0;cout 请输入一个考试分数 endl;cin score;//2、提示用户输入的分数cout 您输入的分数为 score endl;//3、判断 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;}/*
请输入一个考试分数
670
您输入的分数为670
恭喜您考上了一本大学
您能考上了清华大学
请按任意键继续. . .
*/ 4.1.5 三目运算符
① 作用通过三目运算符实现简单的判断。
② 语法表达式1 ? 表达式2 : 表达式3
如果表达式1的值为真执行表达式2并返回表达式2的结果。如果表达式1的值为假执行表达式3并返回表达式3的结果。
③ 三目运算符可以用在显示语句中cout c c 1 ? 男 : 女 endl。
#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;}/*
c 20
a 10
b 100
请按任意键继续. . .
*/ 4.1.6 switch 语句
① switch语句用于执行多条件分支语句。
② switch语句中表达式类型只能是整型或者字符型。
③ case里如果没有break那么程序会一直向下执行。
④ 与if语句比对于多条件判断时switch的结构清晰执行效率高缺点是switch不可以判断区间。
#include iostream
using namespace std;int main()
{//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;default: //前面都不满足就会执行default语句cout 您认为电影是烂片 endl;break;}//if 和 switch 区别//switch 缺点判断的时候只能是整型或者字符型不可以是一个区间。//switch 优点结构清晰执行效率高。system(pause);return 0;}/*
请给电影进行评分
8
您打的分数为8
您认为电影非常好
请按任意键继续. . .
*/ 4.1.7 三只小猪称体重
题目现有三只小猪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;//3、判断哪只最重//先判断A和B重量if (num1 num2) //A比B重{if (num1 num3) //A比C重{cout 小猪A最重 endl;}else{cout 小猪C最重 endl;}}else //B比A重{if (num2 num3) //B比C重{cout 小猪B最重 endl;}else //C比B重{cout 小猪C最重 endl;}}system(pause);return 0;}/*
请输入小猪A的体重
100
请输入小猪B的体重
230
请输入小猪C的体重
300
小猪A的体重为100
小猪B的体重为230
小猪C的体重为300
小猪C最重
请按任意键继续. . .
*/ 4.2 循环结构
4.2.1 while 语句
① 作用满足循环条件时执行循环语句。
② 语法while(循环条件) {循环语句}。
③ 解释只要循环条件的结果为真就执行循环语句。
#include iostream
using namespace std;int main()
{//while循环//在屏幕中打印 0~9 这10个数字int num 0;//while()中填入循环条件//在写循环的时候一定要避免死循环的出现while (num 10) //如果循环条件写1为表示死循环一直循环下去{cout num endl;num;}// 在执行循环语句时候程序必须提供跳出循环的出口否则出现死循环。system(pause);return 0;}/*
0
1
2
3
4
5
6
7
8
9
请按任意键继续. . .
*/ 4.2.2 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);//do...while和while循环区别在于 do...while会先执行一次循环语句system(pause);return 0;
}/*
0
1
2
3
4
5
6
7
8
9
请按任意键继续. . .
*/ 4.2.3 for 语句
① for循环满足循环条件执行循环语句。
② for(起始表达式(①)条件表达式②末尾表达式③) { 循环语句④ }
先执行①初始化再执行②进行判断再执行④进行一次循环再执行③执行一次末尾表达式
③ for循环中的表达式要用分号进行分隔。
④ while、for...while、for都是开发中常用的循环语句for循环结构比较清晰比较常用。
#include iostream
using namespace std;int main()
{//for循环//从数字0 打印到 数字9for (int i 0; i 10; i){cout i endl;}/*第二种方式int i 0for (; i 10; i){cout i endl;}*//*第三种方式int i 0for (; ; i){if(i 10){break;}cout i endl;}*//*第四种方式int i 0for (; ; ){if(i 10){break;}cout i endl;i;}*/system(pause);return 0;}/*
0
1
2
3
4
5
6
7
8
9
请按任意键继续. . .
*/ 4.2.4 for 嵌套
① 在循环体中再嵌套一层循环可以解决一些实际问题例如我们想在屏幕中打印十行十列的星图就需要利用嵌套循环。
#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;}/*
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********
请按任意键继续. . .
*/ 4.2.5 猜数字
① 案例描述系统随机生成一个1到100之间的数字玩家进行猜测如果猜错提示玩家数字过大或过小如果猜对恭喜玩家胜利并且退出游戏。
#include iostream
using namespace std;
#includectime //time系统时间头文件int main()
{//添加随机数种子作用利用当前系统时间生成随机数防止每次随机数都一样srand((unsigned int)time(NULL));//1、系统生成随机数int num rand() % 100 1; //rand()%100 生成 01 ~ 991 随机数//cout num endl; //不显示生成的随机数是多少//2、玩家进行猜测int val 0; //玩家输入的数据while (1){cin val;//3、判断玩家的判断if (val num){cout 猜测过大 endl;}else if (val num){cout 猜测过小 endl;}else{cout 猜测您猜对了 endl;break; //break在循环中可以利用该关键字来退出当前循环}}system(pause);return 0;
}/*
32
猜测过小
60
猜测过大
54
猜测过大
40
猜测过大
38
猜测过大
35
猜测过大
33
猜测您猜对了
请按任意键继续. . .
*/ 4.2.6 水仙花数
案例描述水仙花数是指一个3位数它的每个位上的数字的3次幂之和等于它本身
例如1^3 5^3 3^3 153
题目请利用 do...while语句求出所有3位数中的水仙花数
#include iostream
using namespace std;int main()
{int num 100;do{//2、从所有三位数中找到水仙花数int a; //个位int b; //十位int c; //百位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;
}/*
153
370
371
407
请按任意键继续. . .
*/ 4.2.7 敲桌子逢7过
案例分析从1开始数到数字100如果数字个位含有7或者数字十位含有7或者该数字是7的倍数我们打印敲桌子其余数字直接打印输出。
#include iostream
using namespace std;int main()
{//敲桌子案例for (int i 1; i 100; i){//从100个数字中找到特殊数字打印“敲桌子”//如果是7的倍数、个位有7、或者十位有7打印“敲桌子”if (i % 7 0 || i % 10 7 || i/10 7) {cout 敲桌子 endl;}else //如果不是特殊数字才打印数字{cout i endl;}}system(pause);return 0;
}/*
1
2
3
4
5
6
敲桌子
8
9
10
11
12
13
敲桌子
15
16
敲桌子
18
19
20
敲桌子
22
23
24
25
26
敲桌子
敲桌子
29
30
31
32
33
34
敲桌子
36
敲桌子
38
39
40
41
敲桌子
43
44
45
46
敲桌子
48
敲桌子
50
51
52
53
54
55
敲桌子
敲桌子
58
59
60
61
62
敲桌子
64
65
66
敲桌子
68
69
敲桌子
敲桌子
敲桌子
敲桌子
敲桌子
敲桌子
敲桌子
敲桌子
敲桌子
敲桌子
80
81
82
83
敲桌子
85
86
敲桌子
88
89
90
敲桌子
92
93
94
95
96
敲桌子
敲桌子
99
100
请按任意键继续. . .
*/ 4.2.8 乘法口诀
案例描述利用嵌套循环实现九九乘法表。
#include iostream
using namespace std;int main()
{//乘法口诀表for (int i 1; i 9; i){for (int j 1; j i; j){cout j * i j * i ;}cout endl;}system(pause);return 0;
}/*
1*11
1*22 2*24
1*33 2*36 3*39
1*44 2*48 3*412 4*416
1*55 2*510 3*515 4*520 5*525
1*66 2*612 3*618 4*624 5*630 6*636
1*77 2*714 3*721 4*728 5*735 6*742 7*749
1*88 2*816 3*824 4*832 5*840 6*848 7*856 8*864
1*99 2*918 3*927 4*936 5*945 6*954 7*963 8*972 9*981
请按任意键继续. . .
*/ 4.3 跳转语句
4.3.1 break 语句
① 用于跳出选择结构或者循环结构。
② break使用时机
出现在switch条件语句中作用是终止case并跳出switch。出现在循环语句中作用是跳出当前的循环语句。出现在嵌套循环中跳出最近的内层循环语句。
③ break如果使用在switch-case中并且case前面有一大段代码就会报错把前面一大堆代码用括号括起来{}编译器认为是一段代码就不会报错了。
#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;}//2、出现在循环语句中for (int i0; 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;
}/*
请选择副本难度
1、普通
2、中等
3、困难
2
您选择的是中等难度
0
1
2
3
4
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
∗∗∗∗∗
请按任意键继续. . .
*/ 4.3.2 continue 语句
① 在循环语句中跳过本次循环中余下尚未执行的语句继续执行下一次循环。
#include iostream
using namespace std;int main()
{//continue的使用时机for (int i 0; i 100; i){// 如果是奇数就输出如果是偶数就不输出if (i % 2 0) {continue; //continue可以筛选条件执行到此就不再向下执行了直接执行下一次循环}cout i endl;}system(pause);return 0;
}/*
1
3
5
7
9
11
13
15
17
19
21
23
25
27
29
31
33
35
37
39
41
43
45
47
49
51
53
55
57
59
61
63
65
67
69
71
73
75
77
79
81
83
85
87
89
91
93
95
97
99
请按任意键继续. . .
*/ 4.3.3 goto 语句
① 可以无条件跳转语句。
② 语法
goto 标记
标记
③ 在程序中不建议使用goto语句以免造成程序流程混乱。
#include iostream
using namespace std;int main()
{cout 1 endl;goto FLAG; //这里是分号cout 2 endl;cout 3 endl;cout 4 endl;FLAG: //这里是冒号cout 5 endl;cout 6 endl;system(pause);return 0;
}/*
1
5
6
请按任意键继续. . .
*/ 5. C的数组
5.1 数组特点
① 所谓数组就是一个集合里面存放了相同类型的数据元素。
特点1数组中每个元素都是相同的数据类型。特点2数组是由连续的内存位置组成的。
5.2 一维数组
5.2.1 定义方式
① 一维数组定义
数组类型 数组名 [ 数组长度 ]数组类型 数组名 [ 数组长度 ] { 值1值2.... }数组类型 数组名 [ ] { 值1值2..... }
② 数组名的命名规范与变量名命名规范一致不要和变量重名。
③ 数组中下标是从0开始索引。
#include iostream
using namespace std;int main()
{//1、数组类型 数组名 [ 数组长度 ]int arr[5];//数组元素的下标是从0开始索引的//给数组中的元素进行赋值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 };/*方式一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 }; //以后自定义变量不要 int arr3 100这样避免以后调用arr3到底是调用变量还是数组产生模糊。for (int i 0; i 9; i){cout arr3[i] endl;}system(pause);return 0;
}/*
10
20
30
40
50
10
20
30
0
0
90
80
70
60
50
40
30
20
10
请按任意键继续. . .
*/ 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 数组首地址为 (int)arr endl;cout 数组中第一个元素地址为 (int)arr[0] endl; //int使得将十六位地址通过int转换为10位地址表示取址符号取一个元素的首地址cout 数组中第二个元素地址为 (int)arr[1] endl; //第二个元素和第一个元素差四个字节//数组名是常量值为数组首地址不可以进行赋值操作//arr 100; 不可以这样赋值修改system(pause);return 0;}/*
整个数组占用内存空间为40
每个元素占用内存空间为4
数组中元素的个数为10
数组首地址为12582108
数组中第一个元素地址为12582108
数组中第二个元素地址为12582112
请按任意键继续. . .
*/ 5.2.3 五只小猪称体重
案例描述在一个数组中记录了五只小猪的体重如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;}/*
400
请按任意键继续. . .
*/ 5.2.4 数组元素逆置
案例描述请声明一个5个元素的数组并且将元素逆置。(如原数组元素为1,3,2,5,4逆置后输出的结果为4,5,2,3,1)。
#include iostream
using namespace std;int main()
{//实现数组元素逆置//1、创建数组int arr[5] { 1,3,2,5,4 };cout 数组逆置前 endl;for (int i 0; i 5; i){cout arr[i] endl;}//2、实现逆置//2.1 记录起始下标位置//2.2 记录结束下标位置//2.3 起始下标与结束下标的元素互换//2.4 起始位置 结束位置--//2.5 循环执行2.1操作直到起始位置 结束位置int start 0; //起始下标int end sizeof(arr) / sizeof(arr[0]) - 1; //结束下标先计算除法 while (start end){int temp arr[start];arr[start] arr[end];arr[end] temp;//下标更新start;end--;}//3、打印逆置后的数组cout 数组逆置后 endl;for (int i 0; i 5; i){cout arr[i] endl;}system(pause);return 0;
}/*
数组逆置前
1
3
2
5
4
数组逆置后
4
5
2
3
1
请按任意键继续. . .
*/ 5.2.5 冒泡排序
① 冒泡排序作用最常用的排序算法对数组内元素进行排序。
比较相邻的元素如果第一个比第二个大就交换他们两个。对每一对相邻元素做同样的go牛牛公主执行完毕后找到第一个最大值。重复以上的步骤每次比较次数-1.直到不需要比较。
② 示例将数组(4,2,8,0,5,7,1,3,9)进行排序。
#include iostream
using namespace std;int main()
{int arr[9] { 4,2,8,0,5,7,1,3,9 };cout 排序前 endl;for (int i 0; i 9; i){cout arr[i] ;}cout endl;//开始冒泡排序for (int i 0; i 9 - 1; i){//内层循环对比 次数元素个数当前轮数-1for (int j 0; j 9 - 1 - i; j) //最后一位数已经是最大数了不需要排序了{//如果第一个数字比第二个数字大交换两个数字if (arr[j] arr[j 1]){int temp arr[j];arr[j] arr[j1];arr[j 1] temp;}}}//排序后结果cout 排序后 endl;for (int i 0; i 9; i){cout arr[i] ;}cout endl;system(pause);return 0;
}/*
排序前
4 2 8 0 5 7 1 3 9
排序后
0 1 2 3 4 5 7 8 9
请按任意键继续. . .
*/ 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、数据类型 数组名 [ 行数 ][ 列数 ];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] endl;}}//2、数据类型 数组名 [ 行数 ][ 列数 ] { { 数据1数据2} , { 数据3数据4 } }int arr2[2][3] {{1,2,3},{4,5,6}};for (int i 0; i2;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 arr2[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 arr2[i][j] ;}cout endl;}system(pause);return 0;}/*
1
2
3
4
5
6
1 2 3
4 5 6
1 2 3
4 5 6
1 2 3
4 5 6
请按任意键继续. . .
*/ 5.3.2 数组名
① 查看二维数组所占内存空间。
② 获取二维数组首地址。
#include iostream
using namespace std;int main()
{//二维数组名称用途//1、可以查看占用内存空间大小int arr[2][3] {{1,2,3},{4,5,6}};cout 二维数组占用内存空间为 sizeof(arr) endl;cout 二维数组第一行占用内存为 sizeof(arr[0]) endl;cout 二维数组第一个元素占用内存为 sizeof(arr[0][0]) endl;cout 二维数组行数为 sizeof(arr)/sizeof(arr[0]) endl;cout 二维数组列数为 sizeof(arr[0])/sizeof(arr[0][0]) endl;//2、可以查看二维数组的首地址cout 二维数组首地址为 (int)arr endl;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; //每个元素地址相差4个字节system(pause);return 0;}/*
二维数组占用内存空间为 24
二维数组第一行占用内存为12
二维数组第一个元素占用内存为4
二维数组行数为2
二维数组列数为3
二维数组首地址为3733652
二维数组第一行首地址为3733652
二维数组第一行首地址为3733652
二维数组第二行首地址为3733664
二维数组第一个元素首地址为3733652
二维数组第二个元素首地址为3733656
请按任意键继续. . .
*/ 5.3.3 考试成绩
案例描述有三名同学(张三李四王五)在一次考试中的成绩分别如下表请分别输出三名同学的成绩。
姓名语文数学英语张三100100100李四9050100王五607080
#include iostream
using namespace std;int main()
{//二维数组案例-考试成绩统计//1、创建二维数组int scores[3][3] {{100,100,100},{90,50,100},{60,70,80}};//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] ;}cout 第 i 1 个人的总分为 sum endl;}system(pause);return 0;
}/*
第1个人的总分为300
第2个人的总分为240
第3个人的总分为210
请按任意键继续. . .
*/ 6. C的函数
6.1 函数概述
① 函数作用将一段经常使用的代码封装起来减少重复代码。
② 一个较大的程序一般分为若干个程序块每个模块实现特定的功能。
6.2 函数定义
① 函数的定义主要有5个部分
返回值类型一个函数可以返回一个值。函数名给函数起个名称。参数列表使用该函数时传入的数据。函数体语句花括号内的代码函数内需要执行的语句。return表达式和返回值类型挂钩函数执行完后返回相应的数据。
② 语法格式如下所示
返回值类型 函数名 (参数列表)
{函数体语句return 表达式
}#include iostream
using namespace std;//函数的定义
//语法返回值类型 函数名 (参数列表) { 函数体语句 return表达式 }//加法函数实现两个整型相加并且将相加的结果进行返回
int add(int num1, int num2)
{int sum num1 num2;return sum;
}int main()
{system(pause); //按任意键继续return 0;} 6.3 函数调用
① 功能使用定义好的函数
② 语法函数名(参数)
③ 函数定义里小括号内称为形参函数调用时传入的参数称为实参
#include iostream
using namespace std;//函数的定义
//语法:
//返回值类型 函数名 (参数列表) { 函数体语句 return表达式 }//定义加法函数
//函数定义的时候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;system(pause); //按任意键继续return 0;}/*
c 30
请按任意键继续. . .
*/ 6.4 函数值传递
① 所谓值传递就是函数调用时实参将数值传入给形参。
② 值传递时如果形参发生改变并不影响实参。
③ 在下面代码例子中实参传进去时新参会产生新的内存空间赋值对num1、num2的操作并不会改变实参a、b的值。 #include iostream
using namespace std;//值传递
//定义函数实现两个数字进行交换函数//如果函数不需要返回值声明的时候可以写void
void 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; //前面写了void所以不需要返回值。返回值不需要的时候也可以不写return。
}int main()
{//main函数中调用add函数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;}/*
a 10
b 20
交换前
num1 10
num2 20
交换后
num1 20
num2 10
a 10
b 20
*/ 6.5 函数常见样式
① 常见的函数样式有四种
无参无返有参无返无参有返有参有返
#include iostream
using namespace std;//函数常见样式
//1、无参无返
void test01()
{cout this is test01 endl;
}//2、有参无返
void test02(int a)
{cout this is test 02 a a endl;
}//3、无参有返
int test03()
{cout this is test 03 endl;return 1000;
}//4、有参有返
int test04(int a )
{cout this is test 04 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;}/*
this is test01
this is test 02 a 100
this is test 03
num1 1000
this is test 04 a 10000
num2 10000
*/ 6.6 函数声明
① 作用告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
② 函数的声明可以多次但是函数的定义只能有一次。
#include iostream
using namespace std;//函数的声明
//比较函数实现两个整型数字进行比较返回较大的值。//提前告诉编译器函数的存在可以利用函数的声明
//函数的声明
//声明可以写多次但是定义只能有一次
int max(int a, int b);
int max(int a, int b);
int max(int a, int b);int main()
{int a 10;int b 20;cout max(a, b) endl;system(pause); //按任意键继续return 0;}//函数定义在main函数之后必须要在main函数之前写函数的声明
int max(int a, int b)
{return a b ? a : b;
}/*
20
按任意键继续...
*/ 6.7 函数分文件编写
① 作用让代码结构更加清晰。
② 函数分文件编写一般有4个步骤
创建后缀名为.h的头文件。创建后缀名为.cpp的源文件。在头文件中写函数的声明。在源文件中写函数的定义。 6.7.1 swap.h头文件
创建swap.h头文件 //这个是swap.h头文件
#include iostream
using namespace std;//函数的声明
void swap(int a, int b); 6.7.2 swap.cpp源文件
//这个是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;
} 6.7.3 主文件
//主文件调用函数分文件
#include iostream
using namespace std;
#include swap.h //包含要调用的函数的头文件双引号表示我们自己写的头文件int main()
{int a 10;int b 20;cout max(a, b) endl;system(pause); //按任意键继续return 0;
}/*
20
*/ 7. C的指针
7.1 指针概念
① 指针的作用可以通过指针间接访问内存。
内存编号是从0开始记录的一般用十六进制数字表示。可以利用指针变量保存地址。
7.2 指针变量定义和使用
① 指针变量定义语法数据类型 * 变量名
#include iostream
using namespace std;int main()
{//1、定义指针int a 10;//指针定义的语法数据类型 * 指针变量int * p; //创建p为指针变量//让指针记录变量a的地址p a; // 为取址符号cout a的地址为 a endl;cout 指针p为 p endl; // 指针p存储的值 和变量a的地址是一样的//2、使用指针//可以通过解引用的方式来找到指针指向的内存//指针前加 * 代表解引用找到指针指向的内存中的数据*p 1000; //通过*p访问内存并修改内存的值cout a a endl;cout *p *p endl;system(pause); //按任意键继续return 0;}/*
a的地址为00FBFC78
指针p为00FBFC78
a 1000
*p1000
请按任意键继续. . .
*/ 7.3 指针所占内存空间
① 在32位操作系统下不管什么类型的指针都占4个字节的内存。
② 在64位操作系统下不管什么类型的指针都占8个字节的内存但是实际开发环境一般都是32位操作系统下。
#include iostream
using namespace std;int main()
{//指针所占内存空间int a 10;/*int * p; //p变量是 int * 数据类p a;等价于int * p a;*/int * p a; cout sizeof(int * ) sizeof(p) endl;cout sizeof(int * ) sizeof(int(*)) endl; cout sizeof(float * ) sizeof(float(*)) endl;cout sizeof(double * ) sizeof(double(*)) endl;cout sizeof(char * ) sizeof(char(*)) endl;system(pause); //按任意键继续return 0;}/*
sizeof(int * ) 4
sizeof(int * ) 4
sizeof(float * ) 4
sizeof(double * ) 4
sizeof(char * ) 4
请按任意键继续. . .
*/ 7.4 空指针
① 指针变量指向内存中编号为0的空间。
② 用途初始化指针变量。
③ 空指针指向的内存是不可以访问的。
#include iostream
using namespace std;int main()
{//空指针//1、空指针用于给指针变量进行初始化int* p NULL;//2、空指针是不可以进行访问的//0~255之间的内存编号是系统占用的因此不可以访问。*p 100; //对空指针解引用然后操作它这样是报错的system(pause); //按任意键继续return 0;} 7.5 野指针
① 野指针指针变量指向非法的内存空间。
② 野指针和空指针都不是我们申请的空间所以不要访问。
③ 例如创建了一个整型变量a是申请了一个整型变量的空间由于是申请的空间所以可以通过指针访问它。
#include iostream
using namespace std;int main()
{//野指针int* p (int*)0x1100; // 0x1100是一个十六进制数int*使得十六进制数强行转换为地址。// 拿指针随便指向并没有申请这个内存的访问权限的内存。cout *p endl; // 报错地址并没有申请你还要去访问它就会报错system(pause); return 0;} 7.6 const修饰指针 ① 看const紧跟着的是指针就是常量指针是常量就是指针常量。
② 如果const后面跟的是指针(*)就不能做 *p20 操作即不能修改指针指向的值。
③ 如果const 后面跟的常量(p)就不能做 p b 操作即不能修改指针的指向。
const在 * 前修饰整个指针指向的地址值不可以修改
const在 * 后修饰特定的指针名字指向不可以修改 #include iostream
using namespace std;int main()
{int a 10;int b 10;//1、const修饰指针 常量指针const int * p a; // const(常量) *(指针) → 常量指针 // *p 20; 错误常量指针 → 指针指向的值不可以改指针的指向可以改p b; // 正确//2、const修饰指针 指针常量int * const p2 a; // *(指针) const(常量) → 指针常量*p2 100; //正确的p2 b; //错误指针的指向不可以改指针指向的 值可以改//3、const修饰指针和常量const int * const p3 a;*p3 100; //错误p3 b; //错误system(pause); return 0;
} 7.7 指针和数组
① 利用指针访问数组中元素。
#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;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;
}/*
第一个元素为1
利用指针访问第一个元素1
利用指针访问第二个元素2
利用指针遍历数组
1
2
3
4
5
6
7
8
9
10
请按任意键继续. . .
*/ 7.8 指针和函数
① 利用指针作函数的参数可以修改实参的值。
② 地址传递可以改变实参的数据值传递不可以改变实参的值。
③ 如果不想修改实参就用值传递如果想修改实参就用地址传递。
④ 代码例子中temp的值会传递给 *p2 地址中的值所以a、b实参的值改变了。 #include iostream
using namespace std;void swap(int* p1, int* p2)
{int temp *p1;*p1 *p2;*p2 temp;
}int main()
{//指针和函数int a 10;int b 20;swap(a, b);//如果是地址传递可以修改实参原来 a 10b 20地址传递后 a 20b 10.cout a a endl;cout b b endl;//如果是值传递不可以修改实参原来 a 10b 20值传递后 a 10b 20.system(pause);return 0;}/*
a 20
b 10
请按任意键继续. . .
*/ 7.9 指针配合数组和函数案例
案例描述封装一个函数利用冒泡排序实现对整型数字的升序排列。
例如 int arr[10] {4,3,6,9,1,2,10,8,7,5}
#include iostream
using namespace std;//冒泡排序函数
void bubbleSort(int * arr, int len)
{for (int i 0; i len - 1; i){for (int j 0; j len - i - 1; j){//如果jj1的值交换数字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,1,2,9,10,8,7,5 };//数组长度int len sizeof(arr) / sizeof(arr[0]);//2、创建函数实现冒泡排序bubbleSort(arr, len);//3、打印排序后的数组printArray(arr, len);system(pause);return 0;}/*
1
2
3
4
5
6
7
8
9
10
请按任意键继续. . .
*/ 8. C的结构体
8.1 结构体定义和使用
① 结构体属于用户自定义的数据类型允许用户存储不同的数据类型。
② 语法struct 结构体名 { 结构体成员列表 }
③ 通过结构体创建变量的方式有三种
struct 结构体名 变量名struct 结构体名 变量名 { 成员1值成员2值 }定义结构体时顺便创建变量
④ 结构体变量利用点.访问成员
#include iostream
using namespace std;
#include string
//自定义数据类型一些类型的集合组成一个类型
//语法 struct 类型名称 { 成员列表 }
//结构体定义的时候struct关键字不能省略
//1、创建学生数据类型学生包括(姓名年龄分数)
struct Student
{//成员列表//姓名string name;//年龄int age;//分数int score;
}s3; //2.3 创建结构体的时候顺便创建个结构体变量int main()
{//2.1 struct Student s1 s1类似结构体的实例值类似变量赋值int a 10 → 属性 变量 变量值//结构体创建的时候struct 关键字可以省略上面结构体定义的时候 struct 可以省略struct Student s1;//给s1属性赋值通过点.访问结构体变量中的属性s1.name 张三;s1.age 18;s1.score 100;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;
}/*
姓名张三年龄:18分数100
姓名李四年龄:19分数80
姓名王五年龄:20分数60
请按任意键继续. . .
*/ 8.2 结构体数组
① 作用将自定义的结构体放入到数组中方便维护。
② 语法struct 结构体名 数组名[元素个数] { { , , ... , },{ , , ... , }, ... ,{ , , ... , } }
#include iostream
using namespace std;
#include string
//自定义数据类型一些类型的集合组成一个类型
struct Student
{//成员列表//姓名string name;//年龄int age;//分数int score;
};int main()
{//2、创建结构体数组struct Student stuArray[3] {{张三,18,100},{李四,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;
}/*
姓名张三年龄18分数100
姓名李四年龄28分数99
姓名赵六年龄80分数60
请按任意键继续. . .
*/ 8.3 结构体指针
① 作用通过指针访问结构体中的成员。
② 利用操作符 · 可以通过结构体指针访问结构体属性。
#include iostream
using namespace std;
#include string//结构体指针//定义学生结构体
struct Student
{string name; //姓名int age; //年龄int score; //分数
};int main()
{// 1、创建学生结构体变量这里的 struct 可以省略struct Student s { 张三,18,100 };//2、通过指针指向结构体变量struct Student* p s; //对s取地址 tudent * p 类似 int * p这里的 struct 可以省略//3、通过指针访问结构体变量中的数据//通过结构体指针 访问结构体中的属性需要利用-cout 姓名 p-name 年龄 p-age 分数 p-score endl;system(pause);return 0;}/*
姓名张三年龄18分数100
请按任意键继续. . .
*/ 8.4 结构体嵌套结构体
① 结构体中的成员可以是另一个结构体。
#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;}/*
老师姓名老王 老师编号10000 老师年龄50 老师辅导的学生姓名小王 学生年龄20 学生考试分数60
请按任意键继续. . .
*/ 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; //学生结构体
};//打印学生信息的函数
//1、值传递
void printStudent1(struct student s)
{cout 子函数 值传递前 姓名 s.name 年龄 s.age 分数 s.score endl;s.age 100;
}//2、地址传递
void printStudent2(struct student* p)
{cout 子函数 地址传递前 姓名 p-name 年龄 p-age 分数 p-score endl;p-score 90;
}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 子函数 值传递后 姓名 s.name 年龄 s.age 分数 s.score endl;printStudent2(s);cout 子函数 地址传递后 姓名 s.name 年龄 s.age 分数 s.score endl;cout main函数 传递后 姓名 s.name 年龄 s.age 分数 s.score endl;system(pause);return 0;}/*
main函数 传递前 姓名张三年龄20分数85
子函数 值传递前 姓名张三年龄20分数85
子函数 值传递后 姓名张三年龄20分数85
子函数 地址传递前 姓名张三年龄20分数85
子函数 地址传递后 姓名张三年龄20分数90
main函数 传递后 姓名张三年龄20分数90
请按任意键继续. . .
*/ 8.6 结构体中const使用
① 作用const来防止误操作。
#include iostream
using namespace std;
#include string//const 的使用场景struct student
{//姓名string name;//年龄int age;//分数int score;
};//将函数中形参设置为指针用地址传递而不是值传递可以减少内存空间而且不会复制新的副本
//值传递需要复制新的副本如果有成千上万个学生调用结构体会复制成千上个副本
void printStudents(const student* s)
{s-age 150; //报错因为假如const之后一旦有修改的操作就会报错可以防止我们的误操作。cout 姓名 s-name 年龄 s-age 分数 s-score endl;
}int main()
{//创建结构体变量struct student s { 张三,15,70 };//通过函数打印结构体变量信息printStudents(s);cout main中张三年龄为 s.age endl;system(pause);return 0;} 8.7 结构体案例(一)
案例描述学校正在做毕设项目每名老师带领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) //接收数组的两种方式一用指针二用数组名 struct Teacher tArray[]
{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 ~ 100tArray[i].sArray[j].score random; //}}
}//打印所有信息
void printInfo(struct Teacher tArray[], int len)
{for (int i 0;ilen;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、创建3名老师的数组struct Teacher tArray[3];//2、通过函数给3名老师的信息赋值并给老师带的学生信息赋值int len sizeof(tArray) / sizeof(tArray[0]);allocateSpace(tArray, len);//3、打印所有老师及所带的学生信息printInfo(tArray, len);system(pause);return 0;}/*
老师姓名Teacher_A学生姓名Student_A 考试分数57学生姓名Student_B 考试分数84学生姓名Student_C 考试分数85学生姓名Student_D 考试分数43学生姓名Student_E 考试分数62
老师姓名Teacher_B学生姓名Student_A 考试分数88学生姓名Student_B 考试分数44学生姓名Student_C 考试分数68学生姓名Student_D 考试分数100学生姓名Student_E 考试分数67
老师姓名Teacher_C学生姓名Student_A 考试分数88学生姓名Student_B 考试分数73学生姓名Student_C 考试分数71学生姓名Student_D 考试分数48学生姓名Student_E 考试分数55
请按任意键继续. . .
*/ 8.8 结构体案例(二)
案例描述设计一个英雄的结构体包括成员姓名年龄性别创建结构体数组数组中存放5名英雄。通过冒泡排序算法将数组中英雄按照年龄进行升序排序最终打印排序后的结果。
五名英雄信息如下
{刘备,23,男}{关羽,22,男}{张飞,20,男}{赵云,21,女}{貂蝉,19,女}
#include iostream
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下标的年龄大于j1下标的元素的年龄交换两个元素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 姓名 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 姓名 heroArray[i].name 年龄 heroArray[i].age 性别 heroArray[i].sex endl;}//3、对数组进行排序按照年龄进行升序排序bubbleSort(heroArray, len);//4、将排序后结果打印输出cout 排序后的打印结果 endl;printHero(heroArray,len);system(pause);return 0;}/*
排序前的打印结果
姓名刘备 年龄23 性别男
姓名关羽 年龄22 性别男
姓名张飞 年龄20 性别男
姓名赵云 年龄21 性别女
姓名貂蝉 年龄19 性别女
排序后的打印结果
姓名貂蝉 年龄19 性别女
姓名张飞 年龄20 性别男
姓名赵云 年龄21 性别女
姓名关羽 年龄22 性别男
姓名刘备 年龄23 性别男
请按任意键继续. . .
*/ 9. 通讯录管理系统
#includeiostream
using namespace std;
#includestring//string头文件
#define MAX 1000//联系人结构体
struct Person
{//姓名string m_Name;//性别 1 男 2 女int m_Sex;//年龄int m_Age;//电话string m_Phone;//住址string m_Addr;
};
//通讯录结构体
struct Addressbooks
{//通讯录中保存的联系人数组struct Person personArray[MAX];//通讯录中当前记录联系人个数int m_Size;};//1、添加联系人
void addPerson(Addressbooks* abs)
{//判断通讯录是否已满如果满了就不再添加if (abs-m_Size MAX){cout 通讯录已满无法添加 endl;return;}else{//添加联系人//姓名string name;cout 请输入姓名endl;cin name;abs-personArray[abs-m_Size].m_Name name;//性别cout 请输入性别 endl;cout 1 --- 男 endl;cout 2 --- 女 endl;int sex 0;while (true){//输入正确退出循环//输入错误重新输入cin sex;if (sex 1 || sex 2){abs-personArray[abs-m_Size].m_Sex sex;break;}cout 输入有误请重新输入 endl;}//年龄cout 请输入年龄 endl;int age 0;cin age;abs-personArray[abs-m_Size].m_Age age;//电话cout 请输入电话 endl;string phone;cin phone;abs-personArray[abs-m_Size].m_Phone phone;//住址cout 请输入住址 endl;string address;cin address;abs-personArray[abs-m_Size].m_Addr address;//更新通讯录人数abs-m_Size;cout 添加成功 endl;system(pause);//按任意键继续system(cls);//清屏}
}//2、显示所有联系人
void showPerson(Addressbooks* abs)
{////if (abs-m_Size 0){cout 当前记录为空 endl;}else{for (int i 0;i abs-m_Size;i){cout 姓名 abs-personArray[i].m_Name \t;cout 性别 (abs-personArray[i].m_Sex 1 ?男:女) \t;cout 年龄 abs-personArray[i].m_Age \t;cout 电话 abs-personArray[i].m_Phone \t;cout 住址 abs-personArray[i].m_Addr endl;}}system(pause);//按任意键继续system(cls);//清屏
}//3、删除指定联系人
//检测联系人是否存在如果存在返回联系人所在数组中的具体位置不存在返回-1
//参数1 通讯录 参数2 对比姓名
int isExist(Addressbooks* abs, string name)
{for (int i 0;i abs-m_Size;i){//找到用户输入的名字if (abs-personArray[i].m_Name name){return i; //找到了返回这个人在数组中的下标编号}}return -1;//没找到返回-1
}
void deletePerson(Addressbooks* abs)
{cout 请输入您要删除的联系人 endl;string name;cin name;//ret -1 未查到ret -1 查到了int ret isExist(abs, name);if (ret ! -1){//查到此人要进行删除操作for (int i ret;i abs-m_Size;i){//数据前移abs-personArray[i] abs-personArray[i 1];}abs-m_Size--;//更新通讯录中的人员数cout 删除成功 endl;}else{cout 查无此人 endl;}system(pause);system(cls);
}//4、查找指定联系人
void findPerson(Addressbooks* abs)
{cout 请输入您要查找的联系人 endl;string name;cin name;//判断指定联系人是否存在通讯录中int ret isExist(abs, name);if (ret ! -1)//找到联系人{cout 姓名 abs-personArray[ret].m_Name \t;cout 性别 abs-personArray[ret].m_Sex \t;cout 年龄 abs-personArray[ret].m_Age \t;cout 电话 abs-personArray[ret].m_Phone \t;cout 住址 abs-personArray[ret].m_Addr endl;}else//未找到联系人{cout 查无此人 endl;}system(pause);system(cls);
}//5、修改指定联系人信息
void modifyPerson(Addressbooks* abs)
{cout 请输入您要修改的联系人 endl;string name;cin name;int ret isExist(abs, name);if (ret ! -1){//姓名string name;cout 请输入名字 endl;cin name;abs-personArray[ret].m_Name name;//性别cout 请输入性别 endl;cout 1 --- 男 endl;cout 2 --- 女 endl;int sex 0;while (true){cin sex;if (sex 1 || sex 2){//输入正确退出循环输入abs-personArray[ret].m_Sex sex;break;}cout 输入有误请重新输入 endl;}//年龄cout 请输入年龄 endl;int age 0;cin age;abs-personArray[ret].m_Age age;//电话cout 请输入电话 endl;string phone;cin phone;abs-personArray[ret].m_Phone phone;//住址cout 请输入住址 endl;string address;cin address;abs-personArray[ret].m_Addr address;cout 修改成功 endl;}else{cout 查无此人 endl;}system(pause);system(cls);
}//6、清空所以联系人
void cleanPerson(Addressbooks* abs)
{abs-m_Size 0;cout 通讯录已清空 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 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:findPerson(abs);break;case 5:modifyPerson(abs);break;case 6:cleanPerson(abs);break;case 0:cout 欢迎下次使用 endl;system(pause);return 0;break;}}system(pause);return 0;
} 10. 内存分区模型
C程序在执行时将内存大方向划分为4个区域
代码区存放函数体的二进制代码由操作系统进行管理的全局区存放全局变量和静态变量以及常量栈区由编译器自动分配释放, 存放函数的参数值,局部变量等堆区由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收
内存四区意义
不同区域存放的数据赋予不同的生命周期, 给我们更大的灵活编程 10.1 程序运行前
在程序编译后生成了exe可执行程序未执行该程序前分为两个区域
代码区
存放 CPU 执行的机器指令
代码区是共享的共享的目的是对于频繁被执行的程序只需要在内存中有一份代码即可
代码区是只读的使其只读的原因是防止程序意外地修改了它的指令
全局区
全局变量和静态变量存放在此.
全局区还包含了常量区, 字符串常量和其他常量也存放在此.
该区域的数据在程序结束后由操作系统释放.
示例
#include iostream
using namespace std;//全局变量
int g_a 10;
int g_b 10;//全局常量
const int c_g_a 10;
const int c_g_b 10;int main() {//局部变量int a 10;int b 10;//打印地址cout 局部变量a地址为 (int)a endl;cout 局部变量b地址为 (int)b endl;cout 全局变量g_a地址为 (int)g_a endl;cout 全局变量g_b地址为 (int)g_b endl;//静态变量static int s_a 10;static int s_b 10;cout 静态变量s_a地址为 (int)s_a endl;cout 静态变量s_b地址为 (int)s_b endl;cout 字符串常量地址为 (int)hello world endl;cout 字符串常量地址为 (int)hello world1 endl;cout 全局常量c_g_a地址为 (int)c_g_a endl;cout 全局常量c_g_b地址为 (int)c_g_b endl;const int c_l_a 10;const int c_l_b 10;cout 局部常量c_l_a地址为 (int)c_l_a endl;cout 局部常量c_l_b地址为 (int)c_l_b endl;system(pause);return 0;
}/*
局部变量a地址为 6945460
局部变量b地址为 6945448
全局变量g_a地址为 7323648
全局变量g_b地址为 7323652
静态变量s_a地址为 7323656
静态变量s_b地址为 7323660
字符串常量地址为 7314420
字符串常量地址为 7314436
全局常量c_g_a地址为 7314224
全局常量c_g_b地址为 7314228
局部常量c_l_a地址为 6945436
局部常量c_l_b地址为 6945424
请按任意键继续. . .
*/
总结
C中在程序运行前分为全局区和代码区代码区特点是共享和只读全局区中存放全局变量、静态变量、常量常量区中存放 const修饰的全局常量 和 字符串常量 10.2 程序运行后
栈区
由编译器自动分配释放, 存放函数的参数值,局部变量等
注意事项不要返回局部变量的地址栈区开辟的数据由编译器自动释放
代码
#include iostream
using namespace std;int* func()
{int a 10;return a;
}int main() {int* p func();cout *p endl;cout *p endl;system(pause);return 0;
}/*
10
1478068336
请按任意键继续. . .
*/ 堆区
由程序员分配释放,若程序员不释放,程序结束时由操作系统回收
在C中主要利用new在堆区开辟内存
代码
#include iostream
using namespace std;int* func()
{int* a new int(10);return a;
}int main() {int *p func();cout *p endl;cout *p endl;system(pause);return 0;
}总结
堆区数据由程序员管理开辟和释放
堆区数据利用new关键字进行开辟内存 10.3 new操作符
C中利用new操作符在堆区开辟数据
堆区开辟的数据由程序员手动开辟手动释放释放利用操作符 delete
语法new 数据类型
利用new创建的数据会返回该数据对应的类型的指针
示例1 基本语法
#include iostream
using namespace std;
//1、new的基本语法
int* func()
{//在堆区创建整型//new返回的是 该数据类型的指针int* a new int(10);return a;
}int main() {int* p func();cout *p endl;cout *p endl;cout *p endl;cout *p endl;//堆区的数据 由程序员管理开辟、释放//利用delete释放堆区数据delete p;//cout *p endl; //报错释放的空间不可访问system(pause);return 0;
}/*
10
10
10
10
请按任意键继续. . .
*/ 示例2开辟数组
#include iostream
using namespace std;//堆区开辟数组
int main() {int* arr new int[10];for (int i 0; i 10; i){arr[i] i 100;}for (int i 0; i 10; i){cout arr[i] endl;}//释放数组 delete 后加 []delete[] arr;system(pause);return 0;
} 代码
#include iostream
using namespace std;
//1、new的基本语法
int* func()
{//在堆区创建整型//new返回的是 该数据类型的指针int* a new int(10);return a;
}//2、在堆区利用new开辟数组
void test02()
{//在堆区创建10个元素的整型数据的数组int* arr new int[10];for (int i 0; i 10; i){arr[i] i 100;//给10个元素赋值100~109}for (int i 0; i 10; i){cout arr[i] endl;}//释放数组 delete 后加 []delete[] arr;}int main() {int* p func();cout *p endl;cout *p endl;cout *p endl;//堆区的数据 由程序员管理开辟、释放//利用delete释放堆区数据delete p;//cout *p endl; //报错释放的空间不可访问//int* p func(); 错误“p” : 重定义多次初始化test02();test02();system(pause);return 0;
}/*
10
10
10
100
101
102
103
104
105
106
107
108
109
100
101
102
103
104
105
106
107
108
109
请按任意键继续. . .
*/
11. 引用
11.1 引用的基本使用
作用 给变量起别名
语法 数据类型 别名 原名
示例
#include iostream
using namespace std;int main() {int a 10;int b a;cout a a endl;cout b b endl;b 100;cout a a endl;cout b b endl;system(pause);return 0;
}11.2 引用注意事项
引用必须初始化引用在初始化后不可以改变
示例
#include iostream
using namespace std;int main() {int a 10;int b 20;//int c; //错误引用必须初始化int c a; //一旦初始化后就不可以更改c b; //这是赋值操作不是更改引用cout a a endl;cout b b endl;cout c c endl;system(pause);return 0;
}11.3 引用做函数参数
作用函数传参时可以利用引用的技术让形参修饰实参
优点可以简化指针修改实参
示例
#include iostream
using namespace std;//1. 值传递
void mySwap01(int a, int b) {int temp a;a b;b temp;
}//2. 地址传递
void mySwap02(int* a, int* b) {int temp *a;*a *b;*b temp;
}//3. 引用传递
void mySwap03(int a, int b) {int temp a;a b;b temp;
}int main() {int a 10;int b 20;mySwap01(a, b);cout a: a b: b endl;mySwap02(a, b);cout a: a b: b endl;mySwap03(a, b);cout a: a b: b endl;system(pause);return 0;
} 总结通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单 11.4 引用做函数返回值
作用引用是可以作为函数的返回值存在的
注意不要返回局部变量引用
用法函数调用作为左值
示例
#include iostream
using namespace std;//返回局部变量引用
int test01() {int a 10; //局部变量return a;
}//返回静态变量引用
int test02() {static int a 20;return a;
}int main() {//不能返回局部变量的引用int ref test01();cout ref ref endl;cout ref ref endl;//如果函数做左值那么必须返回引用int ref2 test02();cout ref2 ref2 endl;cout ref2 ref2 endl;test02() 1000;cout ref2 ref2 endl;cout ref2 ref2 endl;system(pause);return 0;
}11.5 引用的本质
本质引用的本质在c内部实现是一个指针常量.
讲解示例
#include iostream
using namespace std;//发现是引用转换为 int* const ref a;
void func(int ref){ref 100; // ref是引用转换为*ref 100
}
int main(){int a 10;//自动转换为 int* const ref a; 指针常量是指针指向不可改也说明为什么引用不可更改int ref a; ref 20; //内部发现ref是引用自动帮我们转换为: *ref 20;cout a: a endl;cout ref: ref endl;func(a);return 0;
}结论C推荐用引用技术因为语法方便引用本质是指针常量但是所有的指针操作编译器都帮我们做了
11.6 常量引用
作用常量引用主要用来修饰形参防止误操作
在函数形参列表中可以加const修饰形参防止形参改变实参
示例
#include iostream
using namespace std;//引用使用的场景通常用来修饰形参
void showValue(const int v) {//v 10;cout v endl;
}int main() {//int ref 10; 引用本身需要一个合法的内存空间因此这行错误//加入const就可以了编译器优化代码int temp 10; const int ref temp;const int ref 10;//ref 100; //加入const后不可以修改变量cout ref endl;//函数中利用常量引用防止误操作修改实参int a 10;showValue(a);system(pause);return 0;
}12. 函数提高
12.1 函数默认参数
在C中函数的形参列表中的形参是可以有默认值的。
语法返回值类型 函数名 参数 默认值{}
示例
#includeiostream
using namespace std;//1. 如果某个位置参数有默认值那么从这个位置往后从左向右必须都要有默认值
int func1(int a, int b 10, int c 10) {return a b c;
}//2. 如果函数声明有默认值函数实现的时候就不能有默认参数
int func2(int a 10, int b 10);
int func2(int a, int b) {return a b;
}//3. 如果函数实现有默认值函数声明的时候就不能有默认参数
int func3(int a, int b);
int func3(int a 10, int b 10) {return a b;
}int main() {//cout ret func1() endl;错误cout ret func1(20) endl;cout ret func1(20, 20) endl;cout ret func1(20,20,20) endl;cout ret func2() endl;cout ret func3() endl;system(pause);return 0;
}/*
ret 40
ret 50
ret 60
ret 20
ret 20
请按任意键继续. . .
*/
12.2 函数占位参数
C中函数的形参列表里可以有占位参数用来做占位调用函数时必须填补该位置
语法 返回值类型 函数名 (数据类型){}
在现阶段函数的占位参数存在意义不大但是后面的课程中会用到该技术
示例
#includeiostream
using namespace std;void func1(int a) {cout this is func1 endl;
}
//函数占位参数
void func2(int a, int) {cout this is func2 endl;
}
//占位参数也可以有默认参数
void func3(int a, int 10) {cout this is func3 endl;
}int main() {func1(10);func2(10, 10); //占位参数必须填补//func2();错误//func2(10);错误func3(10);func3(10,20);system(pause);return 0;
}/*
this is func1
this is func2
this is func3
this is func3
请按任意键继续. . .
*/
12.3 函数重载
12.3.1 函数重载概述
作用函数名可以相同提高复用性
函数重载满足条件
同一个作用域下函数名称相同函数参数类型不同 或者 个数不同 或者 顺序不同
注意: 函数的返回值不可以作为函数重载的条件
示例
#includeiostream
using namespace std;//函数重载需要函数都在同一个作用域下
void func()
{cout func 的调用 endl;
}
void func(int a)
{cout func (int a) 的调用 endl;
}
void func(double a)
{cout func (double a)的调用 endl;
}
void func(int a, double b)
{cout func (int a ,double b) 的调用 endl;
}
void func(double a, int b)
{cout func (double a ,int b)的调用 endl;
}
/*
函数返回值不可以作为函数重载条件
int func(double a, int b)
{cout func (double a ,int b)的调用 endl;
}
*/int main() {func();func(10);func(3.14);func(10, 3.14);func(3.14, 10);system(pause);return 0;
}/*
func 的调用
func (int a) 的调用
func (double a)的调用
func (int a ,double b) 的调用
func (double a ,int b)的调用
请按任意键继续. . .
*/
12.3.2 函数重载注意事项
引用作为重载条件函数重载碰到函数默认参数
示例
#includeiostream
using namespace std;//函数重载注意事项
//1、引用作为重载条件
void func(int a)
{cout func (int a) 调用 endl;
}void func(const int a)
{cout func (const int a) 调用 endl;
}//2、函数重载碰到函数默认参数
void func2(int a, int b 10)
{cout func2(int a, int b 10) 调用 endl;
}void func2(int a)
{cout func2(int a) 调用 endl;
}int main() {int a 10;func(a); //调用无constfunc(10);//调用有const//func2(10); //碰到默认参数产生歧义需要避免system(pause);return 0;
}/*
func (int a) 调用
func (const int a) 调用
请按任意键继续. . .
*/
文章转载自： http://www.morning.stmkm.cn.gov.cn.stmkm.cn http://www.morning.hwzzq.cn.gov.cn.hwzzq.cn http://www.morning.ngqdp.cn.gov.cn.ngqdp.cn http://www.morning.rwcw.cn.gov.cn.rwcw.cn http://www.morning.cnqff.cn.gov.cn.cnqff.cn http://www.morning.tjndb.cn.gov.cn.tjndb.cn http://www.morning.wfhnz.cn.gov.cn.wfhnz.cn http://www.morning.cwnqd.cn.gov.cn.cwnqd.cn http://www.morning.qsdnt.cn.gov.cn.qsdnt.cn http://www.morning.rbrhj.cn.gov.cn.rbrhj.cn http://www.morning.bxrqf.cn.gov.cn.bxrqf.cn http://www.morning.rnzwh.cn.gov.cn.rnzwh.cn http://www.morning.ftsmg.com.gov.cn.ftsmg.com http://www.morning.dmzqd.cn.gov.cn.dmzqd.cn http://www.morning.qbgff.cn.gov.cn.qbgff.cn http://www.morning.ptlwt.cn.gov.cn.ptlwt.cn http://www.morning.yszrk.cn.gov.cn.yszrk.cn http://www.morning.nqxdg.cn.gov.cn.nqxdg.cn http://www.morning.jltmb.cn.gov.cn.jltmb.cn http://www.morning.hdlhh.cn.gov.cn.hdlhh.cn http://www.morning.lkkgq.cn.gov.cn.lkkgq.cn http://www.morning.bbmx.cn.gov.cn.bbmx.cn http://www.morning.fkmrj.cn.gov.cn.fkmrj.cn http://www.morning.kjmcq.cn.gov.cn.kjmcq.cn http://www.morning.tbzcl.cn.gov.cn.tbzcl.cn http://www.morning.syqtt.cn.gov.cn.syqtt.cn http://www.morning.nkjxn.cn.gov.cn.nkjxn.cn http://www.morning.yfwygl.cn.gov.cn.yfwygl.cn http://www.morning.ymyhg.cn.gov.cn.ymyhg.cn http://www.morning.yqsr.cn.gov.cn.yqsr.cn http://www.morning.splcc.cn.gov.cn.splcc.cn http://www.morning.sqskm.cn.gov.cn.sqskm.cn http://www.morning.nhlnh.cn.gov.cn.nhlnh.cn http://www.morning.cyjjp.cn.gov.cn.cyjjp.cn http://www.morning.huxinzuche.cn.gov.cn.huxinzuche.cn http://www.morning.bkqdg.cn.gov.cn.bkqdg.cn http://www.morning.rsjf.cn.gov.cn.rsjf.cn http://www.morning.bmncq.cn.gov.cn.bmncq.cn http://www.morning.krywy.cn.gov.cn.krywy.cn http://www.morning.jypqx.cn.gov.cn.jypqx.cn http://www.morning.xgkxy.cn.gov.cn.xgkxy.cn http://www.morning.dmnqh.cn.gov.cn.dmnqh.cn http://www.morning.cfybl.cn.gov.cn.cfybl.cn http://www.morning.qgjwx.cn.gov.cn.qgjwx.cn http://www.morning.lmjtp.cn.gov.cn.lmjtp.cn http://www.morning.dfndz.cn.gov.cn.dfndz.cn http://www.morning.bftr.cn.gov.cn.bftr.cn http://www.morning.pqcrz.cn.gov.cn.pqcrz.cn http://www.morning.mtzyr.cn.gov.cn.mtzyr.cn http://www.morning.kqpxb.cn.gov.cn.kqpxb.cn http://www.morning.sgbsr.cn.gov.cn.sgbsr.cn http://www.morning.kpcdc.cn.gov.cn.kpcdc.cn http://www.morning.yrkdq.cn.gov.cn.yrkdq.cn http://www.morning.lmfmd.cn.gov.cn.lmfmd.cn http://www.morning.kjgrg.cn.gov.cn.kjgrg.cn http://www.morning.pghry.cn.gov.cn.pghry.cn http://www.morning.skdhm.cn.gov.cn.skdhm.cn http://www.morning.dgwrz.cn.gov.cn.dgwrz.cn http://www.morning.ldqrd.cn.gov.cn.ldqrd.cn http://www.morning.kfsfm.cn.gov.cn.kfsfm.cn http://www.morning.mjctt.cn.gov.cn.mjctt.cn http://www.morning.nsjpz.cn.gov.cn.nsjpz.cn http://www.morning.wrbx.cn.gov.cn.wrbx.cn http://www.morning.xbdd.cn.gov.cn.xbdd.cn http://www.morning.kcwkt.cn.gov.cn.kcwkt.cn http://www.morning.kcfnp.cn.gov.cn.kcfnp.cn http://www.morning.fqcdh.cn.gov.cn.fqcdh.cn http://www.morning.qwnqt.cn.gov.cn.qwnqt.cn http://www.morning.gbhsz.cn.gov.cn.gbhsz.cn http://www.morning.ndxmn.cn.gov.cn.ndxmn.cn http://www.morning.xcjwm.cn.gov.cn.xcjwm.cn http://www.morning.hkng.cn.gov.cn.hkng.cn http://www.morning.hxpsp.cn.gov.cn.hxpsp.cn http://www.morning.mmxnb.cn.gov.cn.mmxnb.cn http://www.morning.bpmtq.cn.gov.cn.bpmtq.cn http://www.morning.qrlkt.cn.gov.cn.qrlkt.cn http://www.morning.swkzr.cn.gov.cn.swkzr.cn http://www.morning.zxdhp.cn.gov.cn.zxdhp.cn http://www.morning.grzpc.cn.gov.cn.grzpc.cn http://www.morning.rkqqf.cn.gov.cn.rkqqf.cn
