if 判断语句
int fenVshu = 100;
if(fenVshu==100)
{
cout << "恭喜考上第一名";
}
— 只有达成判断语句条件才能显示,不满足就会跳过
多行if语句
多行if语句的语法else关键字的使用
if(条件)
{
条件满足执行的语句
}else{
条件不满足时候的语句
int fenVshu = 100;
if(fenVshu > =){
cout << "恭喜你考上第一名" << endl;
}else{
cout << "恭喜你考上第三名" << endl;
}
— 条件为假的时候就执行else语句块中的语句
多条件语句else if
#include <iostream>
using namespace std;
int main (void)
{
int a;
cin >> a ;
if( a > 0 ){
cout << 0 << endl;
}else if ( a < 0) {
cout << a << endl;
}
}
#include<iostream>
using namespace std;
int main (void){
int a ;
cin >> a ;
if (a > 5){
if (a > 7){
cout << "输入的数大于7" << endl;
}
else cout << "输入的数大于5小于7" << endl;
}
else cout << "输入的数小于5" << endl;
}
v
#include <iostream>
using namespace std;
int main (void){
int n = 5;
while(n--){
cout << "执行了几次" << endl ;
}
return 0;
}
switch选择语句
— switch的语法
switch(表达式)
{
case 结果1:执行语句;break;
case 结果2:执行语句;break;
case 结果3:执行语句;break;
default:执行语句;break;
— switch的用法
int daVfen = 0;
cin >> daVfen;
switch(daVfen)
{
case 10:
cout << "极品" << endl;
break;
case 9:
cout << "佳作" << endl;
break;
case 7:
cout << "普通" << endl;
break;
case 5:
cout << "一般" << endl;
break;
default:
cout << "烂片" << endl;
break;
}
— break是跳出的意思
— switch如果没有加break;那么就会那个值的下面的所有的值都会打印出来
比如case 10那么从case 10一直到default之间的所有语句块都会被输出来
— default是以外的值
— switch括号中的是变量而不是表达式
—case的值只能是数值而不是条件表达式
循环结构
@ while循环语句
— while的语法
while(循环条件)
{
循环语句
}
#include <iostream>
using namespace std;
int main (void){
while(true){
cout << "我是语句" << endl ;
}
return 0;
}
— while的使用
int a= 0;
while(a < 10)
{
cout << a << endl;
a++;
}
—while循环语句里如果条件是1那么就是真就会进入无限循环
0即为假直接跳出
— do……wihle语句
— do……wihle语法
do{
循环语句
}while(条件语句)
斐波那契数列
— do……wihle循环会限制性一次循环语句块当中的代码,再来判断条件语句
— 循环语句的变量是在外面声明的
— do……while循环的使用
int a=0;
do
{
cout<<a<<endl;
}while(a<10);
@ for循环语句
— for循环的语法
for(定义一个变量;条件表达式;变量的前++或后++)
{
循环语句;
}
— for循环的使用
int a=0;
do
{
cout<<a<<endl;
}while(a<10);
定义变量之后判断a是否等于10如果不等于10就输出代码块中的代码,然后是a++
以此直到a=10为止否则会一直循环
跳转语句
break语句
— break是终止跳出的选择语句和选择语句还有嵌套循环语句中
@ continue语句
— continue是跳过某一个条件的语句
— continue的使用
for(int a=0;a<100;a++)
{
if(a == 51)
{
continue;
}
cout<<a<<endl;
//这里循环到a的值刚好是51就不会执行cout<<a<<endl;这个语句
//直接跳过继续a++然后输出语句块当中的代码
}
数组
数组就是一个集合,里面存放了相同的类型的数据元素
— 数组里面的所有数据元素都是相同类型
— 素组是由连续的内存位置组成的
— 素组下标索引是从0开始的
— 可以通过下标可以用来访问素组中的元素
@ 数组的定义
数据类型 数组名[数组长度];
数据类型 数组名[数组长度] = {值1,值2 ...};
数据类型 数组名[]={值1,值2...};
第一种
int shuVzu1[5];
cout<<shuVzu[0]<<endl;
cout<<shuVzu[1]<<endl;
cout<<shuVzu[2]<<endl;
cout<<shuVzu[3]<<endl;
cout<<shuVzu[4]<<endl;
第二种
int shuVzu2[5]={11,22,33,44,55};
cout<<shuVzu2[0]<<endl;
cout<<shuVzu2[1]<<endl;
cout<<shuVzu2[2]<<endl;
cout<<shuVzu2[3]<<endl;
cout<<shuVzu2[4]<<endl;
第三种
int shuVzu3[]={11,22,33,44,55,66,77,88,99};
cout<<shuVzu3[0]<<endl;
cout<<shuVzu3[1]<<endl;
cout<<shuVzu3[2]<<endl;
cout<<shuVzu3[3]<<endl;
cout<<shuVzu3[4]<<endl;
cout<<shuVzu3[5]<<endl;
cout<<shuVzu3[6]<<endl;
cout<<shuVzu3[7]<<endl;
cout<<shuVzu3[8]<<endl;
@ 获取数组的总体长度函数sizeof
— 如果一个类型是四个直接那么如果有十个变量在数组里面就是十个四字节
— sizeof的使用
for(int a=0;a<100;a++)
{
if(a == 51)
{
continue;
}
cout<<a<<endl;
//这里循环到a的值刚好是51就不会执行cout<<a<<endl;这个语句
//直接跳过继续a++然后输出语句块当中的代码
}
— 如果想知道数组中的某一个变量那么就在方括号里输入它的坐标位置
— 输出得出数组的个数
cout<<sizeof(shuVzu)/sizeof(shuVzu[0])<<endl;
@ 获取数组的首地址
— 用法
cout<<shuVzu<<endl;
— 输出的地址都是十六进制的如果要转成十进制的需要加一个被括号扩起来的(int)
cout<<(int)shuVzu<<endl;
— 获取数组中某个变量的地址值
如果需要获得数组中某个变量的地址就要在前面加一个&符号
cout<<&shuVzu[0]<<endl;
— 数组的地址是一个常量不可以修改
二维数组
— 二维数组就像是蛋托,蛋托的一排就普通数组,蛋托的一列就是二维数组
— 数组的四种定义方式
数据类型数组名[ 行数][列数];
int a[2][3]
数据类型数组名[行数][列数]={{数据1,数据2},{数据3,数摑4}};
int b[2][3]=
{
{1,2,3},
{4,5,6}
};
数据类型数组名[ 行数][列数] = {数据1,数据2,数据3,数据4};
int c[2][3]={1,2,3,4,5,6};
数据类型数组名[ ][ 列数] = {数据1,数据2,数据3,数据4};
int d[][3]={1,2,3,4,5,6};
//系统会默认列数分配
— 二位数组的赋值
a[1][0]=1;
a[1][1]=2;
a[1][2]=3;
a[2][0]=4;
a[2][1]=5;
a[2][2]=6;
函数
@ 函数的作用
— 将一些可以重复利用的代码封装起来,减少代码量
— 大型程序由若干个程序块来实现特定功能
@ 函数的定义
返回值类型 函数名 参数列表
函数体语句
return 表达式
— 函数定义的语法
int hanVshuVdingVyi(int a,int b)
{
int c = a+b/2;
return c;
}
— return是返回语句,谁调用就返回给谁
— 括号里是形参
是用来接收调用该函数时传递的参数
@ 函数的调用
int jiaVfaVhanVshu(int X,int Y )
{
int xiangVjia= x+y ;
return xiangVjia;
}
int main()
{
int a=10;
int b=20;
int c=jiaVfaVhanVshu(a,b);
}
指针
@ 指针的作用
— 指针可以间接访问内存
— 内存里都是有地址编号的从0开始记录
— 用十六进制数字来表示编号
— 可以用指针来记录编号
— 创建int内存的时候就相当于在内存里找了一个4个空间的大小
假设这个int a里存入了10的变量
如果想要操作这个内存空间可以用变量a来操纵
— 为什么有变量的存在
因为在内存中都有它的内存地址编号
比如0x00FF//这是随便写的
就像这样如果每创建一个数据值都去记住一个地址编号
这样就很难记忆所以就有了变量
— 如果知道知道地址值的编号是多少也可以拿到数据
可以再创建一个变量来存放地址
当然这个变量就是指针变量
简单的说指针就是地址
@ 定义指针
数据类型 * 指针变量;
int a=100;
int *p;
— 让指针与建立关系记录地址
p = &a ;
cout<<p<<endl;
— 在定义指针的时候直接可以建立关系
int * p=&a;
@ 使用指针
指针可以通过解引用的方式来找到指针指向的内存
— 解引用
在指针前面加一个*号
p
找到指针指向的内存
— 解引用理解
如果cout输出p那么就是a的内存地址
如果cout输出的是p那么输出的就是变量a的值
@ 指针占的内存
— 在32位下
在32位下所有指针都占用4个字节
— 在64位下
在64位下占用8个字节
— 查看指针占用多少直接
cout<<sizeof(int *)<<endl;
cout<<sizeof(p)<<endl;
@ 空指针
— 指针指向空间为0的地址空间
— 用来初始化指针
— 空指针是没有权限访问的
— 空指针的初始化
一般情况下空指针的赋值是NULL;
NULL在程序中代0
— 空指针不可解引用等访问
int *p = NULL;
*p=1;
这个是错误的代码
解引用就相当于控制变量
但是0这个区域地址编号是不允许被任何人操作的
— 0~255之间的所有地址编号都是由系统控制使用的
@ 野指针
野指针就像是孩子非常野缺乏管教
比如偷拿妈妈的化妆品化妆
偷父母的钱去花等等
再比如开门走错楼栋了,怎么用自己家的要是死活也打不自己家的门(别人家的)
指针指向的地址越界了只想了一个非法的内存空间
— 指向了一个没有被申请到的空间
int *a=0x07FF;
没有得到申请的空间指针是不能操作它的
@ const修饰指针
— const修饰指针三种情况
const修饰指针————常量指针
const修饰指针————指针常量
const及修饰指针,又修饰常量
@@ 常量指针的特点
int a=10;
int b=10;
int *p=&a;
指针的指向可以修改只有指向的值不可以修改
p指向了a还可以再次指向b但是不可以修改他们里面的值
p=&b;
这是对的
假设p已经指向了b
*p=20;
通过*号解引用进行指向变量的操作是不可以的
@@ 指针常量
指针指向的内存地址不可以改,指针指向的变量的值可以改
int a=1;
int b=2;
int * const p=&a
*p=3;//正确
p=&b;//错误
@@ 又修饰指针又修饰常量
指向内存地址和指向的内存变量都不可以修改否则都是错误的
int a=100;
int b=200;
const int const *p=&a;
*p=101;错误
p=&b;错误
@指针和数值
— 作用
用来访问数组中的每个元素
int shuVzu[10]={1,2,3,4,5,6,7,8,9,10};
int *p=shuVzu;
cout<<*p<<endl;
1
2
3
*p解引用指向的shuVzu的首地址的变量
只要++p指针就会往右移动四个字节指向数组中的第二个变量
@ 指针和函数
就是吧变量取地址传进函数形参里面去
void diVzhiVchuanVdi(int *x,int *y)
{
int beiVzi=*x;
*x=*2;
*y=beiVzi;
}
int main()
{
int a=10;
int b=20;
diVzhiVchuanVdi(&a,&b);
return 0;
}
在传递的时候一定要加上取地址符&
beiVzi这个变量使用取地址获取了指针X指向的变量;
x与y都使用了号解引用的来通过x与y个指向地址的变量来进行一个被赋值和一个被取值
y使用号来解引用指向内存地址指向的变量直接通过beiVzi这个变量进行赋值
结构体
— 结构体属于用户自定义的数据类型
— 允许用户存储不同的数据类型
— 自定义数据类型,一些类型集合组成的一个类型
@ 结构体定义和使用
— 语法
struct 结构体名字 变量名
{
结构体成员列表
};
— 结构体的最后一定要加上一个;分号
— 结构体的使用
struct xueVsheng
{
string xingVming;
int nianVling;
char xingVbie;
};
— 创建结构体变量
第一种创建初始化
xueVsheng a;
a.xingVming="小刘";
a.nianVling="18";
a.xingVbie='男';
第二种创建初始化
xueVsheng b={"张三",18,'男'};
第三种创建初始化
在结构体分号与右半边的大括号之间的夹缝中创建一个自定义变量
struct xueVsheng2
{
string xingVming;
int nianVling;
char xingVbie;
}c;
c.xingVming="老王";
c.nianVling=27;
c.xingVbie='男';
— 结构体语句输出
cout<<"姓名"<<c.xingVming<<"年龄"c.nianVling<<"性别"<<c.xingVbie<<endl;
@ 结构体指针
— 可以挺过指针访问结构体中的成员
— 利用->操作符可以通过结构体指针访问结构体属性
struct xueVsheng
{
string xingVming;
int nianVling;
char xingVbie;
};
int main()
{
xueVsheng a={"小红",17,'女'};
xueVsheng *p=&a;
cout<<"姓名"<<p->xingVming<"年龄"<<p->nianVling<<"性别"<<p->xingVbie<<endl;
return 0;
}
@ 结构体嵌套结构体
— 结构体中的成员可以是另一个结构体
— 可以使用别的结构体成为这个结构体的成员
— 要嵌套哪个结构体就要在这个结构体的上面定义好那个结构体
struct xueVsheng
{
string xingVming;
int nianVling;
char xingVbie;
int fenVshu;
};
struct banVzhuVren
{
string laoVshi;
int nianVling;
char xingVbie;
struct xueVsheng fuVdao ;
};
int main()
{
abanVzhuVren a;
a.laoVshi="张美老师";
a.nianVling=23;
a.xingVbie='女';
a.fuVdao.xingVming="刘子墨";
a.fuVdao.nianvling="13";
a.fuVdao.xingVbie='男';
a.fuVdao.fenVshu=98;
}
@ 结构体的函数参数
— 将结构体作为参数向函数中传递
— 传入的方式有两种
— 值传递
值传递不会导致实参改变
void jgths(struct xueVsheng x)
{
x.nianVling=19;
cout<<x.xueVsheng<<x.nianVling<<x.xingVbie<<ednl;
}
struct xueVsheng
{
string xingVming;
int nianVling;
char xingVbie;
};
int main()
{
xueVsheng a;
a.xingVming="张三";
a.nianVling=15;
a.xingVbie='男';
jgths(a);
}
x与main函数里的a是两个不同的内存地址
— 地址传递
如果形参发生改变实参也会发生相应的改变
void jgths(struct xueVsheng *p)
{
cout<<p->xingVming<<p->nianVling<<p->xingVbie<<endl;
}
struct xueVsheng
{
string xingVming;
int nianVling;
char xingVbie;
};
int main()
{
xueVsheng a;
a.xingVming="张三";
a.nianVling=15;
a.xingVbie='男';
jgths(&a);
}
jgths的这个类里的p与main函数的a通过指针连接着的所以p改a也会改变数值
@ 结构体的const应用场景
— 用const来防止误操作
void jgths(const xueVsheng *p)
{
//p->nianVling=20;//这就是错误的
cout<<p->xingVming<<p->nianVling<<p->xingVbie<<endl;
}
struct xueVsheng
{
string xingVming;
int nianVling;
char xingVbie;
};
int main()
{
xueVsheng a;
a.xingVming="张三";
a.nianVling=15;
a.xingVbie='男';
jgths(a);
}
— 使用指针结构体形参会改变实参
— 如果加上const xueVsheng x就不能再修改了只能输出打印
— 这样做的方法就是为了减少创建内存的占用量
— 因为指针占用的内存字节少