自学笔记
第一章--C语言数据类型与语句
前言
C语言特点
第一个c语言程序
#include<stdio.h>
// main:主函数，任意一个C程序中必须有且只能有一个主函数，是程序的入口函数
int main() //这个我的第一个c语言程序
{
//使用printf函数输出括号里面的字符串
//printf是输出打印的函数
printf("hello world!\n");
return 0;
}
1.#include<stdio.h>头文件包含,一定要有
2.每一个c语言的程序有且只有一个main函数，这是整个程序的开始位置
3.C语言中()、" "、’ '、都必须成对出现,必须是英文符号
4.C语言中语句要以分号结束。
5.//为注释。
关键字
数据类型相关的关键字
用于定义变量或者类型类型变量名:
语法结构： 类型 变量名；
类型： char、short、int 、long 、float、double、struct、union、enum、 signed、 unsigned、void
拓展： 变量名属于标识符，标识符（变晕名、函数名、重命名和取别名)有命名规则
标识符的命名规则﹔
标识符只能以数字、字母和下划线命名，首字母不能是数字，不能与关键字相同
1、char字符型，用char定义的变量是字符型变量，占1个字节
有符号：-2^7 – 2^7-1
无符号：0-- 2^8-1
char ch='a'; // =为赋值号
char ch1= '1' ; //正确
char ch2 ='1234'; //错误的，不能定义字符串
2、short短整型,使用short定义的变量是短整型变量，占2个字节
有符号：-2^15 – 2^15-1
无符号：0 – 2^16-1
short int a=11; //-32768----32767
3、int 整型，用int定义的变量是整型变量，在32位系统下占4个字节。
有符号：-2^31 – 2^31-1
无符号：0 – 2^32-1
int a=44; //
4、long长整型，用1ong定义的变量是长整型的，在32位系统下占4个字节，在64位系统下占8个字节
long int a=66;
5、float 单浮点型（实数），用float定义的变量是单浮点型的实数，占4个字节
float b=3.8f;
6、double双浮点型(实数)，用double定义的变量是双浮点型的实数，占8个字节
double b=3.8;
7、struct** 是与结构体类型相关的关键字，可以用它来定义结构体类型。
8、union这个关键字是与共用体(联合体）相关的关键字。
9、enum与枚举类型相关的关键字
10、 signed有符号(正负)的意思，在定义char 、整型(short . int、long)数据的时候用signed修饰，代表咱们定义的数据是有符号的，可以保存正数，也可以保存负数
signed int a=10;
signed int b=-6;
**注意:**默认情况下 signed 可省略即
int a=-10;//默认a就是有符号类型的数据
**11、unsigned无符号的意思，**在定义char 、整型(short 、 int、long)数据的时候用unsigned修饰，代表咱们定义的数据是无符号类型的数据，只能保存正数和0。
12、void空类型的关键字
char、int 、float都可以定义变量
void不能定义变量，没有void类型的变量，void是用来修饰函数的参数或者返回值，代表函数没有参数或没有返回值
例:
void fun(void)
{
} //代表fun函数没有返回值，fun函数没有参数
例子
#include <stdio.h>
//测试基本类型所占字节大小
int main()
{
char a;
short b;
int c;
long d;
float e;
double f;
//sizeof:是一个运算符，可以获取数据类型所占内存大小
printf("%d\n",sizeof(a));
printf("%d\n",sizeof(b));
printf("%d\n",sizeof(c));
printf("%d\n",sizeof(d));
printf("%d\n",sizeof(e));
printf("%d\n",sizeof(f));
return 0;
}
测试结果：
注意： 运行时会出现如下图错误：
我在实验时，也遇到了没关系，看到有博主的解决方法如下：博主地址详细如下
有个long int data;
我输出的时候printf(“data is %d”, data);出现下面警告
解决办法（后面会有详细介绍）
md，m为指定的输出字段的宽度。如果数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。
%ld(%mld 也可)，输出长整型数据。
最后 printf(“data is %ld\n”, data)解决。
%md，m为指定的输出字段的宽度。如果数据的位数小于m，则左端补以空格，若大于m，则按实际位数输出。
%ld(%mld 也可)，输出长整型数据。
u格式符，用来输出unsigned型数据， 无符号数，以十进制数形式输出。格式：%u，%mu,%lu都可。
基本类型
[char、short int 、int、long int（int 可以省略）、float、double]
#include <stdio.h>
//基本数据类型的学习与使用
//char short int long float double
int main(int argc,char *argv[])
{
//定义一个char的变量并赋值,输出字符使用%c
char a='w';
printf("a=%c\n",a);
//定义一个short的变量并赋值,输出字符使用%d
short b=100;
printf("b=%d\n",b);
//定义一个int的变量并赋值,输出字符使用%d
int c=9999;
printf("c=%d\n",c);
//定义一个long的变量并赋值,输出字符使用%ld
long d=23567889;
printf("d=%ld\n",d);
//定义一个float的变量并赋值,输出字符使用%f,默认报人小数点后6位
float e=3.1415926;
printf("e=%f\n",e);
//定义一个double的变量并赋值,输出字符使用%lf，默认报人小数点后6位
double f=26483.374889595;
printf("f=%lf\n",f);
return 0;
}
构造类型
概念:由若干个相同或不同类型数据构成的集合，这种数据类型被称为构造类型，例:
int a[10];
数组、结构体、共用体、枚举
扩展:常量和变量
常量:在程序运行过程中，其值不可以改变的量
常量的分类：
整型 100，125，-100，0
实型 3.14 , 0.125f，-3.789
字符型 ‘a’,‘b’，‘2’
字符串 “a”,“ab”，“1232”
ASCIl码表:对于计算机而言，只能识别二进制数，也就是数字，对于非数值型数据，如果要使用，就需要将其用一个数值型数据进行标识，就称之为ASClI码表
#include <stdio.h>
int main(int argc,char *argv[])
{
//注意在使用字符类型数据时，%c输出就是输出字符，%d就是输出ASCII码
char ch1='w';
printf("ch1=%c %d\n",ch1,ch1);
char ch2=97;
printf("ch2=%c %d\n",ch2,ch2);
return 0;
}
变量----------其值可以改变的量被称为变量定义变量的方式,也要遵循标识符的要求:
存储类型 数据类型 变量名=变量或者常量;
整形数据
整型常量:(按进制分）:
十进制:以正常数字1-9开头，如457，789
八进制:以数字0开头，如0123
十六进制:以ox开头，如0x1e
整型变量:
有/无符号短整型(un/signed) short(int) 2个字节
有/无符号基本整型(un/signed) int 4个字节
有/无符号长整型(un/signed) long (int) 4个字节(32位处理器) ，8个字节(64位处理器)
实型数据(浮点型)
实型常量
实型常量也称为实数或者浮点数
十进制形式:由数字和小数点组成:0.0、0.12、5.0
指数形式:123e3代表123*10的三次方 123e-3
不以f结尾的常量是double 类型
以f结尾的常量(如3.14f)是float类型
实型变量
单精度(float)和双精度(double)3.1415926753456
float型:占4字节，7位有效数字，指数-37到38
3333.33333
double型:占8字节，16位有效数字,指数-307到308
字符数据
字符常量:
直接常量:用单引号括起来，如: ‘a’、‘b’、‘0’等.
转义字符:以反斜杠“\”开头，后跟一个或几个字符、如’\n’, ‘\t’等,分别代表换行、横向跳格.’\‘表示的是\，‘%%’，’'
字符变量:
用char定义，每个字符变量被分配一个字节的内存空间字符值以ASCII码的形式存放在变量的内存单元中;
注: char a;
a= ‘x’;
a变量中存放的是字符x的ASCII:120即a=120跟a='x’在本质上是一致的.
字符串常量
是由双引号括起来的字符序列，如“CHINA”、”哈哈哈”、“program”、“$12.5”等都是合法的字符串常量.
字符串常量与字符常量的不同
‘a’为字符常量，"a”为字符串常量
每个字符串的结尾，编译器会自动的添加一个结束标志位’\0’，即“a”包含两个字符‘a’和’\0’
格式化输出字符:
%d 十进制有符号整数
%ld 十进制long有符号整数
%u 十进制无符号整数
%o 以八进制表示的整数
%x 以十六进制表示的整数
%f float型浮点数
%lf double型浮点数
%e 指数形式的浮点数
%c 单个字符
%s 字符串
%p 指针的值
特殊应用:
%3d：要求宽度为3位，如果不足3位，前面空格补齐;如果足够3位，此语句无效
%03d：要求宽度为3位，如果不足3位，前面0补齐;如果足够3位，此语句无效
%-3d：要求宽度为3位，如果不足3位，后面空格补齐;如果足够3位，此语句无效
%.2f：小数点后只保留⒉位
例子
#include <stdio.h>
int main(int argc,char *argv[])
{
//注意在使用字符类型数据时，%c输出就是输出字符，%d就是输出ASCII码
char ch1='w';
printf("ch1=%c %d\n",ch1,ch1);
char ch2=97;
printf("ch2=%c %d\n",ch2,ch2);
//输出整数
int a = 100;
//输出十进制，用%d
printf("a=%d\n",a);
//输出八进制，用%o
printf("a=%o\n",a);
//用%#o可以输出八进制的前导符
printf("a=%#o\n",a);
//输出十六进制，用%o
printf("a=%x\n",a);
//用%#o可以输出十六进制的前导符
printf("a=%#x\n",a);
//输出浮点型函数,float食用%f,doouble使用%lf
//默认为小数点保留6位，并且可以四舍五入，如果不够六位自动补0
float b=3.1415926;
double c=2345.2355;
printf("b=%f\n",b);
printf("c=%lf\n",c);
//输出字符
char d='y';
printf ("d=%c %d\n",d,d);
//输出字符串,使用%s
//没有专门的变量保存字符串，一般使用数组来保存
char e[]="hello world";
printf("e=%s\n",e);
//输出地址
int f=999;
printf("&f=%p\n",&f);
printf("**********************************");
int m=456;
printf("%d%d\n",m,m);
//要求宽度为5位，如果不足5位，前面空格补齐;如果足够5位，此语句无效
printf("%5d%5d\n",m,m);
//要求宽度为5位，如果不足5位，前面0补齐;如果足够5位，此语句无效
printf("%05d%05d\n",m,m);
//要求宽度为5位，如果不足5位，后面空格补齐;如果足够5位，此语句无效
printf("%-5d%-5d\n",m,m);
float n=3.678;
printf("n=%f\n",n);
//%.02f 小数点后只保留2位
printf("n=%.2f\n",n);
return 0;
}
存储相关关键字
【register、static、const、auto、 extem】
1、register是寄存器的意思，用register修饰的变量是寄存器变量，（优点：运行速率快）即:在编译的时候告诉编译器这个变量是寄存器变量，尽量将其存储空间分配在寄存器中。
注意:
(1)定义的变量不一定真的存放在寄存器中，寄存器空间不够使用 。
(2)cpu取数据的时候去寄存器中拿数据比去内存中拿数据要快
(3)因为寄存器比较宝贵，所以不能定义寄存器数组
(4)register 只能修饰字符型及整型的，不能修饰浮点型
(5)因为register修饰的变量可能存放在寄存器中不存放在内存中，所以不能对寄存器变量取地址。因为只有存放在内存中的数据才有地址
register char ch;
register short int b;
register int c;
register float d;//错误的
register int a;
int *p;
p=&a;//错误的·a可能没有地址
2、static是静态的意思
static可以修饰全局变量、局部变量、函数
使用static修饰的变量，此变量保存在内存的静态区空间中
3、const
const是常量的意思
用const修饰的变量是只读的，不能修改它的值
const int a=101;//在定义a的时候用const修饰并赋初值为101从此以后，就不能再给a赋值了
a=111;//错误的
const可以修饰指针，这个在以后课程中重点讲解
4、auto int a;和 int a是等价的，auto关键字现在基本不用
5、extern是外部的意思，一般用于函数和全局变量的声明，这个在后面的课程中，会用到
控制语句相关的关键字
【if … else… 、break、continue、for 、 while、 do、switch … case … default 、goto】
条件控制语句:
if语句: if … else…
**switch语句: ** switch … case… default
循环控制语句:
for 、while 、do 、goto
辅助控制语句:
break 、continue
其他关键字
【sizeof、typedef、 volatile】
1、sizeof
使用来测变量、数组的占用存储空间的大小(字节数)
int a=10;
int num;
num=sizeof(a);
printf（"num=%d",num）
2、typedef重命名相关的关键字,作用是给一个已有的类型，重新起个类型名，并没有创造一个新的类型,以前大家看程序的时候见过类似的变量定义方法
typedef起别名的方法(大家知道，在c语言中没有INT16 这些关键字):
(1)用想起名的类型定义一个变量
short int a;
(2)用新的类型名替代变量名
short int INT16;
(3)在最前面加typedef
typedef short int INT16,
(4)就可以用新的类型名定义变量了
INT16 b;和 short int b;//是一个效果
3 volatile易改变的意思,用volatile定义的变量，是易改变的，即告诉cpu每次用volatile变量的时候，重新去内存中取保证用的是最新的值,而不是寄存器中的备份。volatile关键字现在较少适用
volatile int a=10;
类型转换
数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题.转换的方法有两种:
自动转换:
遵循一定的规则,由编译系统自动完成.
强制类型转换:
把表达式的运算结果强制转换成所需的数据类型
自动转换的原则:
1、占用内存字节数少(值域小)的类型，向占用内存字节数多(值域大)的类型转换,以保证精度不降低.
2、转换方向:
1)当表达式中出现了char、short int 、int类型中的一种或者多种，没有其他类型了
参加运算的成员全部变成int类型的参加运算，结果也是int类型的
2)当表达式中出现了带小数点的实数,参加运算的成员全部变成double类型的参加运算,结果也是double型。
3)当表达式中有有符号数也有无符号数，参加运算的成员变成无符号数参加运算结果也是无符号数(表达式中无实数)
4)在赋值语句中等号右边的类型自动转换为等号左边的类型
5)注意自动类型转换都是在运算过程中进行临时变换,不影响自动类型转换的变量的值和其类型
强制转换:通过类型转换运算来实现
(类型说明符)(表达式)
功能:
把表达式的运算结果强制转换成类型说明符所表示的类型
#include <stdio.h>
int main(int argc,char *argv[])
{
//***************强制类型转换之自动转换*****
//参加运算的成员全部变成int类型的参加运算，结果也是int类型的
printf ( "%d\n" ,5/2);
printf("************************************************\n");
//当表达式中出现了带小数点的实数，参加运算的成员全部变成double类型
//参加运算，结果也是double型
printf ("%lf\n",5.0/2);
printf("************************************************\n");
//当表达式中有有符号数也有无符号数，参加运算的成员变成无符号数参
//加运算结果也是无符号数.(表达式中无实数)
int a=-8;
unsigned int b=7;
if(a+b > 0)
{
printf ( "a+b>0\n");
}
else
{
printf ( "a+b<=0\n");
}
printf("************************************************\n");
//在赋值语句中等号右边的类型自动转换为等号左边的类型
int m;
float n=5.8f; //5.8后面加f代表5.8是float类型，不加的话，认为是double类
m = n;
//注意自动类型转换都是在运算过程中进行临时变换
//并不影响自动类型转换的变量的值和其类型
printf( "m = %d\n" ,m);
printf("************************************************\n");
//*************强制类型转换之强制转换***
int x = 10;
int y =4;
float w;
w = x / y;
printf ( "w = %f\n" , w) ;
printf("*****************\n");
w =(float)(x / y);
printf ( "w = %f\n" , w) ;
printf("*****************\n");
//应该先强转，再运算
w =(float) x /(float)y;
printf ( "w = %f\n" , w) ;
return 0;
}
运算符的概念以及分类
用运算符将运算对象(也称操作数）连接起来的、符合C语法规则的式子，称为C算术表达式运算对象包括常量、变量、函数等
例如:a *b / c- 1.5 + ‘a’
运算符的分类:
1、双目运算符:即参加运算的操作数有两个
例:+
a+b
2、单目运算符:参加运算的操作数只有一个
++自增运算符,变量值+1
–自减运算符
int a=10;
a++;
3、三目运算符:即参加运算的操作数有3个
()? ( ) : ()
算术运算符
（+、-、*、/、%、+=、-=、/=、%=）
#include <stdio.h>
//算术运算符的使用
int main(int argc,char *argv[])
{
int a=40;
int b=6;
printf("%d + %d = %d\n",a,b,a+b);
printf("%d - %d = %d\n",a,b,a-b);
printf("%d * %d = %d\n",a,b,a*b);
printf("%d / %d = %d\n",a,b,a/b);
//printf如果要输出%，则需要使用%%
printf("%d %% %d = %d\n",a,b,a%b);
float m=10.55;
float n=2.4;
printf("%.4f + %.4f = %.4f\n",m,n,m+n);
printf("%.4f - %.4f = %.4f\n",m,n,m-n);
printf("%.4f * %.4f = %.4f\n",m,n,m*n);
printf("%.4f / %.4f = %.4f\n",m,n,m/n);
//(取余只能用于整数)printf("%.4f %% %.4f = %.4f\n",m,n,m % n);
return 0;
}
关系运算符
（>、<、==、>=、<=、！=（不等于、一般用于判断条件是否满足或者循环语句）
注意∶关系运算符中
==用于判断左右两边是否相等，不能使用=，=用于赋值，将右值赋给左i
#include <stdio.h>
//算术运算符的使用
int main(int argc,char *argv[])
{
//关系运算符连接的表达式的最终结果只有两个，真和假
//一般返回的结果使用int保存，如果为假则为e，为真则为非0
//非0即为真
int a=10>5;
int b=10<5;
printf("a=%d ,b=%d\n",a,b);
return 0;
}
逻辑运算符
1、&&逻辑与
两个条件都为真，则结果为真
if(a>b) && (a<c))
if(b<a<c)//这种表达方式是错误的
2、||逻辑或
两个条件至少有一个为真，则结果为真
`if((a>b)||(a<c))`
3、!逻辑非
if(!(a>b))
{
}
例子
#include <stdio.h>
//算术运算符的使用
int main(int argc,char *argv[])
{
int a=20;
//逻辑与两边的表达式都为真，整体才为真，否则为假
int ret=a>10&&a<1;
printf("ret=%d\n",ret);
//逻辑或与两边的表达式只有一个为真，整体才为真，否则全为假则假
ret=a>10||a<19;
printf("ret=%d\n",ret);
//逻辑与的短路原则:如果第一个表达式的结果为假，则后面所有的表达式都不会执行
int b=100;
ret =(a<19)&&(b+=10);
printf("b=%d\n",b);
ret =(a>19)&&(b+=10);
printf("b=%d\n",b);
//逻辑或的短路原则:如果第一个表达式的结果为真，则后面所有的表达式都不会执行
ret =(a>19)||(b+=10);
printf("b=%d\n",b);
return 0;
}
位运算符
总结右移:
1、逻辑右移高位补0，低位溢出
注:无论是有符号数还是无符号数都是高位补0，低位溢出
2、算数右移高位补符号位，低位溢出(有符号数
注:对无符号数来说，高位补0，低位溢出
对有符号数来说，高位补符号位，低位溢出
#include <stdio.h>
//算术运算符的使用
int main(int argc,char *argv[])
{
printf("%d\n",-1>>3);
return 0;
}//输出结果为-1为算术右移
条件运算符号
（）？（）：（）
如果?前边的表达式成立，整个表达式的值，是?和:之间的表达式的结果，否则是:之后的表达式的结果
#include <stdio.h>
//算术运算符的使用
int main(int argc,char *argv[])
{
int a=10,b=20;
int c;
c=(a>b) ?(a+=10):(b+=1);
printf("c=%d\n",c);
printf("a=%d,b=%d\n",a,b);
return 0;
}
(… ,… ,…)
使用逗号隔开的表达式从左向右依次执行，最后的表达式的值是整个运算的结果
例如∶A=(B,C, D)
先运行表达式B，再运行表达式C，最后运行表达式D，最终变量A的值为表达式D的值
#include <stdio.h>
//算术运算符的使用
int main(int argc,char *argv[])
{
int a=10,b=20;
int c;
//l如果要使用逗号运算符，必须要加括号，如果不加，则会歧义
c=(a+=10,b+=10,a+=b);
printf("c=%d\n",c);
printf("a=%d,b=%d,c=%d\n",a,b,c);
return 0;
}
1)将++或者–放在变量的后面
2)将++或者–放在变量的前面
#include <stdio.h>
int main(int argc,char *argv[])
{
//将++或--放在变量的后面
int a=100;
int b1;
//先使用再自增或自减
b1=a++;
printf("a=%d,b1=%d\n",a,b1);
//将++或--放在变量的前面
int b2;
//先自增或自减再使用
b2=++a;
printf("a=%d,b2=%d\n",a,b2);
return 0;
}
运算符优先级表
if语句
选择控制语句相关的关键字
1、if语句形式;
if(条件表达式)
{
//复合语句，若干条语句的集合
语句1;
语句2;
}
如果条件成立执行大括号里的所有语句，不成立的话大括号里的语句不执行
2)
if(条件表达式)
{
语句块1
}
else
{
语句块2
}
if…else语句的作用是，如果if的条件成立，执行if后面内的语句，否则执行else后的语句
if(条件表达式)
{
语句块1；
}
else if(条件表达式)
{
语句块2；
}
else if(条件表达式)
{
语句块3；
}
else
{
语句块n；
}
#include <stdio.h>
int main(int argc,char *argv[])
{
int n=100;
//形式1：只有if
//首先判断if后面括号里面的表达式是否为真，
//如果为真，则执行大括号里面的语句
//如果为假则不执行
// if (n>=50)
// {
// printf("%d>=50\n",n);
// }
// 形式2：if...else...
// 首先判断if后面括号里面的表达式是否为真,则执行if后大括号里面的语句
// 如果为假，则执行else后面大括号里面的语句
// 注意if和else之间只能有一条语句，或者有一个复合语句，否则编译会出错
//错误:if和 else之间只能有一条语句,如果有多条语句的话加大括号
// if (n>=50)
// {
// printf("%d>=50\n",n);
// }
// else
// {
// printf("%d<50\n",n);
// }
//形式3 if... else if...else ....
if(n>50)
{
printf("%d>50\n",n);
}
else if(n==50)
{
printf("%d=50\n",n);
}
else
{
printf("%d<50\n",n);
}
return 0;
}
switch语句
switch（表达式) //表达式只能是字符型或整型的(short int 、int 、long int)
{
case常量表达式1:
语句1;
break;
case常量表达式2:
语句2;
break;
default:
语句3;
break;
}
运行顺序︰将常量表达式的值语句switch后面的表达式的值对比，如果表达式的值刚好等于case后面的某一个值，就会立即去执行case后的语句，如果都不是，则会执行default后面的语句
注意: break的使用
注意事项:
( 1 ) switch后面的表达式不能是浮点型，只能是整形的
( 2）如果case后面的常呈表达式与switch的表达式的值都不同，则执行default后面的语句
( 3 )每一个case执行结束后理论上必须跟一个break，作用就是跳出整个switch语句
( 4 ) case后面如果语句很多，不需要加大括号
#include <stdio.h>
int main(int argc,char *argv[])
{
int num=3;
switch (num)
{
case:
printf("111111\n");
//如果不加break，当要执行当前case语句时，执行完毕后悔接着下一个
//case后的语句执行，直到遇到break为止，否则会一直执行|
break;
case 2:
printf("2222222\n");
break;
case 3:
printf("3333333\n");
break;
default:
printf("hahhahahha\n");
break;
}
return 0;
}
for循环
for(表达式1;表达式2;表达式3)
{
//复合语句，循环体
语句块
}
执行顺序:
先执行表达式1，然后执行表达式2，如果表达式2成立，则执行语句块当语句块执行完毕之后，接着执行表达式3，然后再执行表达式2，如果表达式2成立，则继续执行语句块，以此类推，直到表达式2不成立，循环结束
#include <stdio.h>
//for循环1-100的累加和
int main(int argc,char *argv[])
{
int i = 1;
int sum=0;
for (i=1;i<=100;i++)
{
sum+=i;
}
printf("1+2+3+...+100=%d\n",sum);
return 0;
}
while循环
1)形式1:
while(条件表达式)
{
//循环体，复合语句
语句块
}
执行顺序:
首先判断while后面的条件表达式，如果表达式成立（为真），执行语句块，执行完语句块接着再次执行条件表达式，如果表达式为真，则继续执行语句块，直到条件表达式为假，循环结束.
#include <stdio.h>
//for循环1-100的累加和
int main(int argc,char *argv[])
{
int i = 1;
int sum=0;
while (i<=100)
{
sum+=i;
i++;
}
printf("1+2+3+...+100=%d\n",sum);
return 0;
}
2)形式2∶do…while…
do
{
//循环体
语句块
}while(条件表达式)
执行顺序:
先执行do后面的语句块，然后判断while后面的条件表达式是否成立，如果成立，则继续执行do后面的语句块，执行完毕后接着执行while后面的条件表达式，当条件表达式不成立时，循环结束
注意:
不管条件是否成立，do后面的语句块都会执行一次，所以尽量少用do…while在while后面必须加一个分号
goto循环
#include <stdio.h>
int main(int argc,char *argv[])
{
//使用goto实现跳转
printf("1111111111111111\n");
goto NEXT;
printf("22222222222222222\n");
printf("333333333333333333\n");
NEXT:
printf("444444444444444444444\n");
//使用goto实现1-100的累加和
int i=1;
int sum =0;
JOOP:
sum+=i;
i++;
if(i<=100)
{
goto JOOP;
}
printf("1+2+3..+..+100=%d\n",sum);
return 0;
}
总结
可能有点多和复杂，有什么问题可以相互交流呀，最近会努力把其他章节更新好的。。
950
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
