个人转载
原出处:c - 随笔分类 - hahazexia - 博客园 (cnblogs.com)
原作者:hahazexia - 博客园 (cnblogs.com)
#include<stdio.h>
int main(void) /*一个简单程序*/
{
int num; /*定义变量*/
num=1; /*为num赋值*/
printf("I am a simple"); /*为num赋值*/
printf("computer.\n");
printf("My favorite number is %d because it is first.\n",num);
return 0;
}
#include指示和头文件
#include<stdio.h>
#include语句是C预处理器指令。C编译器在编译前要对源代码做一些准备工作，这称为预处理。
stdio.h文件代表标准输入输出头文件（standard input/output header）。人们称出现在文件顶部的信息集合为头（header）。
main()函数
一个C程序总是从被称为main()的函数开始执行。函数是C程序的基本模块。
注释
/*一个简单程序*/
包含在/**/之间的部分是程序注释。
还有另一种风格的注释，它被限制在一行之内。
//这种注释被限制在一行之内
花括号，程序体和代码块
所有C函数都使用花括号{}代表函数体的开始与结束。
声明
int num;
这一行叫声明语句。它声明了两件事情。第一，有一个名为num的变量。第二，int说明num是一个整数。
int是C语言的一个关键字，它代表一个基本数据类型。关键字是表达语言的单词，不能用于其他目的。
num是一个标示符，也就是你为一个变量、函数或其他实体所选的名字。
在C语言中，所有变量必须在使用前被声明。
名字的选择
可以用来作为标示符的字符有字母、数字、下划线。第一个字符必须是字母或者下划线。
C语言的名字是区分大小写的。
赋值
num=1;
赋值是最基本的操作之一，声明语句在内存之中为变量num分配了空间，而赋值语句在那个地方为变量存储了一个值。
printf()函数
printf("I am a simple");
printf("computer.\n");
printf("My favorite number is %d because it is first.\n",num);
圆括号中的是printf函数的参数，程序将识别两个双引号之间的内容并将它们显示在屏幕上。
\n是转义字符，它是换行符。%d是一个占位符，其作用是指示输出num值得位置。
return语句
return 0;
return语句是最后一个语句。在int main (void)中int表示main()函数的返回值应该是一个整数。带有返回值的函数需要一个return语句，该语句包括关键字return，后面紧跟着要返回的值，然后别忘了分号。
位、字节和字
最小的存储单位称为位（bit），它容纳两个值之一，0或1。
字节（byte）是常用的计算机存储单位，几乎对所有的机器，1个字节均为8位。因为一个位是0或者1，所以一个8位字节包含256种可能的0、1组合。
对于给定的计算机，字（word）是自然的存储单位。比如原始的Apple机，一个字刚好有8位。
C的数据关键字
int类型
int是有符号整数，可正可负可以是0，而取值范围则依赖于系统。旧的PC机有16位的字，因而用16位存储一个整数值，取值范围为-32768到32767。目前的PC机有32位的字，所以取值范围是-2147483647到2147483647。
声明int变量
int erns; int hogs,cow,goats;
初始化变量
int hogs=21; int cows=32,goats=14; int dogs,cats=94;/*这种语句有效，但是形式不友好*/
八进制和十六进制
要用八进制显示就用%o代替%d，要用十六进制显示就用%x。如果要显示C语言前缀，可以使用说明符%#o、%#x、%#X分别生成0、0x、0X前缀。
printf("dec=%d,octal=%o,hex=%x\n",x,x,x);
printf("dec=%d,octal=%#o,hex=%#x\n",x,x,x);
其他整数类型
C提供3个附属关键字修饰基本整型：short、long和unsigned。
short int类型（可简写为short类型）可能占用比int更少的空间，用于数值比int值小的场合。
long int类型（可简写为long类型）可能占用比int类型更多的空间，用于大数值的场合。
long long int类型（可简写为long long类型）可能占用比long类型更多的空间，用于更大数值的场合。
unsigned int（可简写为unsigned类型）用于非负值的场合。范围与有符号的不同，16位的unsigned取值范围为0到65535，而int的取值范围为-32768到32767。
C90标准中允许unsigned long int（简写为unsigned long）和unsigned short int（简写为unsigned short）类型。C99又增加了unsigned long long int（简写为unsigned long long）类型。
整数溢出
如果整数太大超出了整型范围会怎么样？
/*toobig.c 超出您系统上最大int值*/
#include<stdio.h>
int main(void)
{
int i=2147483647;
unsigned int j=4294967295;
printf("%d %d %d\n",i,i+1,i+2);
printf("%u %u %u\n",j,j+1,j+2);
return 0;
}
下面是结果：
2147483647 -2147483648 -2147483647 4294967295 0 1
当整型数据达到最大值时，它将溢出到起始点。
无符号整型的起始点是0，有符号整型的起始点是-2147483648。
long和long long常量
在支持long long类型的系统中，使用ll或者LL后缀标识long long类型，如3LL。
u或者U后缀标识unsigned long long类型，比如5ull、10LLU、6LLU、9Ull。
char类型
字符常量及其初始化
char grade='A';
char grade=65;
这两种方法都是可以的。
非打印字符
Bool类型
C用值1表示true，用值0表示false。
可移植类型：inttypes.h
C99提供了可选的名字集合，确切描述有关信息。
例如：int16_t表示16位有符号整数类型，uint32_t表示32位无符号整数类型。
要是这些名字有效，必须在程序中包含inttypes.h头文件。
float、double和long double类型
C标准规定，float必须至少表示6位有效数字，取值范围至少为10^-37到10^+37。
double类型必须至少表示10位有效数字。double一般使用64位长度，有更高的精度。
long double比double精度更高。
浮点常量
-1.56E+12 2.87e-3
可以省略正号，可以一没有小数点或者指数部分。
3.14159 .2 4e16 .8E-5 100.
在浮点常量中不要使用空格。
默认情况下编译器将浮点常量当做double类型。可以加f或者F后缀使编译器把它当做float类型，或者加l或L当做long double类型。
C99有种新的十六进制格式表示浮点常量，0x或0X为前缀，接着是十六进制数字，然后是p或者P，最后是2的指数。
0xa.1fp10
a是10，.1f表示1/16加上15/256，p10表示2^10。
浮点值的上溢和下溢
假设系统中的最大float值是3.4E38。
float toobig=3.4E38*100.0f;
printf("%e\n",toobig);
以上语句会发生上溢。printf函数会显示此值为inf或infinity。
将0.1234E-10除以10，将得到结果0.0123E-10,但是失去了一位有效数字，这叫下溢。
负数和虚数类型
三种复数类型：float_Complex、double_Complex和long double_Complex。
三种虚数类型：float_Imaginary、double_Imaginary和long double_Imaginary。
字符串
字符串（character string）就是一个或多个字符的序列。
"Zing went the strings of my heart!"
C没有专门定义字符串的变量类型，而是把它存储在char数组中。
存储字符串的数组的最后一个元素是\0，这个字符是空字符（null character），用来标记字符串的结束。空字符不是数字0，它是非打印字符，它的ASCⅡ码值为0。
strlen()和sizeof()
strlen()计算字符串的长度，sizeof()计算变量在内存中占的字节数。
常量和C预处理器
使用C预处理器定义常量。
#define MAX 100
const修饰符
const int MAX=100;
系统定义的明显常量
C头文件limits.h和float.h分别提供关于整型和浮点型的大小限制的信息。其中定义了一些常量，例如limits.h包含下面类似的行：
#define INT_MAX +32767 #define INT_MIN -32768
以下是limits.h中的一些常量
以下是float.h中的一些符号常量
printf()函数
类似于%d这样的符号叫做转换说明，他们指定了如何把数据转换成可显示的形式。
控制字符串是一个描述项目如何打印的字符串，它就是双引号内的语句。它包含两部分：实际要打印的字符，转换说明。
printf()转化说明修饰符
printf()的标志
使用修饰符和标志的示例
以下是整数输出的例子
#include <stdio.h>
#define PAGES 931
int main (void)
{
printf("*%d*\n",PAGES);
printf("*%2d*\n",PAGES);
printf("*%10d*\n",PAGES);
printf("*%-10d*\n",PAGES);
return 0;
}
输出结果如下：
*931* *931* * 931* *931 *
以下是浮点数输出的例子
#include <stdio.h>
int main (void)
{
const double RENT=3852.99;
printf("*%f*\n",RENT);
printf("*%e*\n",RENT);
printf("*%4.2f*\n",RENT);
printf("*%3.1f*\n",RENT);
printf("*%10.3f*\n",RENT);
printf("*%10.3e*\n",RENT);
printf("*%+4.2f*\n",RENT);
printf("*%010.2f*\n",RENT);
return 0;
}
输出结果如下：
*3852.990000* *3.85299e+03* *3852.99* *3853.0* * 3852.990* * 3.863e+03* *+3852.99* *0003852.99*
以下是其他组合的例子:
#include <stdio.h>
int main (void)
{
printf("%x %X %#x\n",31,31,31);
printf("**%d**% d**% d**\n",42,42,-42);
printf("**%5d**%5.3d**%05d**%05.3d**\n",6,6,6,6);
return 0;
}
输出结果如下：
1f 1F 0x1f **42** 42**-42** ** 6** 006**00006** 006**
以下是字符串输出的例子：
#include <stdio.h>
#define BLURB "Authentic imitation! "
int main(void)
{
printf("/%2s/\n",BLURB);
printf("/%24s/\n",BLURB);
printf("/%24.5s/\n",BLURB);
printf("/%-24.5s/\n",BLURB);
return 0;
}
输出结果如下：
/Athentic imitation! / / Authentic imitation!/ / Authe/ /Authe /
转换说明的意义
转换说明把存储在计算机中的二进制格式的数值转换成一系列字符（一个字符串）以便于显示。
例如，数字67的内部存储形式可能是二进制01001100。%d转换说明符将它转换成字符7和6，并显示成76。
%x把相同的值转换成十六进制的4c。%c把相同的值转换成L。
转换说明其实就是翻译说明。%d意为“把给定的值翻译成十进制整数文本表示，并打印出来”。
不匹配的转换
不匹配的整数转换
#include <stdio.h>
#define PAGES 336
#define WORDS 65618
int main (void)
{
short num=PAGES;
short mnum=-PAGES;
printf("num as short and unsigned short: %hd %hu\n",num,num);
printf("-num as short and unsigned short: %hd %hu\n",mnum,mnum);
printf("num as int and char: %d %c\n",num,num);
printf("WORDS as int,short,and char: %d %hd %c\n",WORDS,WORDS,WORDS);
return 0;
}
输出结果如下
num as short and unsigned short: 336 336 -num as short and unsigned short: -336 65200 num as int and char: 336 P WORDS as int,short and char: 65618 82 R
mnum的无符号输出结果是65200却不是336.这是由于有符号short int值在此参考系统中的表示方式造成的。
首先，它们的大小是2字节。其次该系统使用被称为2的补码的方式表示有符号整数。在这种方法中，数字0到32767代表它们本身，而数字32768到65535则代表负数，65535代表-1、65534代表-2，以此类推。
因此，-336由65536-336，也即65200来表示。当被解释成一个有符号整数时，65200代表-336；当被解释成无符号整数时，65200则代表65200。当然，并不是所有系统都是用这样的方法。
这即是说，%u转换不能把符号和数字分开。
看第三行的输出结果，可以知道当把一个大于255的值转换成字符时，short int占系统的2个字节，而char占1个字节，当printf打印时只截取了两个字节中的一个字节。
相当于以256为除数，取该数字被除后的余数再转换。
最后以short int输出一个更大的值也跟上面一样，4个字节取了其中两个字节转换输出。
不匹配的浮点数转换
#include <stdio>
int main(void)
{
float n1=3.0;
double n2=3.0;
long n3=2000000000;
long n4=1234567890;
printf("%.1e %.1e %.1e %.1e\n",n1,n2,n3,n4);
printf("%ld %ld\n",n3,n4);
printf("%ld %ld %ld %ld\n",n1,n2,n3,n4);
return 0;
}
输出结果如下：
3.0e+00 3.0e+00 3.1e+46 1.7e+266 2000000000 1234567890 0 1074266112 0 1074266112
当使用%e打印n3时，%e期望一个double类型值，在本系统这是一个8字节的值。当printf()查看n3（它在本系统中是一个4字节值）时，它也查看了邻近的4个字节，其中只有一部分是真正的n3。
输出的第三行表示，如果printf()在其他的地方出现不匹配的错误，即使正确的说明符也会产生虚假的结果。
printf("%ld %ld %ld %ld",n1,n2,n3,n4);
该调用把四个变量传递给计算机，计算机把它们堆栈中。计算机根据变量的类型将数据放入堆栈中而不是根据转换说明符。
所以n1和n2各占8个字节（float被转换成double），而n3和n4各占4个字节。
然后printf()函数按照转换说明符将堆栈中的数据读取出来，%ld只读取4个字节，但是n1和n2都占8个字节，因此即使n3和n4的转换说明符正确，printf()函数也会读取错误的字节。
printf()函数的返回值
printf()函数的返回值是所打印的字符的数目。如果输出有错误，会返回一个负数或者其他值。
int s;
s=printf("what do you wangt to do?\n");
printf("%d",s);
输出结果是
what do you want to do? 26
打印较长的字符串
#include <stdio.h>
int main(void)
{
printf("Here's one way to print a ");
printf("long string.\n");
printf("Here's another way to printf a \
long string.\n");
printf("Here's the newest way to printf a "
"long string.\n"); /*ANSI C*/
return 0;
}
scanf()函数
以下是转换说明符
以下是转换修饰符
从scanf()角度看输入
当使用%d来读取一个整数，scanf()会跳过空白字符（空格、制表符和换行符）直到遇到一个非空白字符。当scanf()遇到一个数字字符或者一个符号，它会保存并读取下一个字符；就这样scanf()会持续读取和保存字符直到它遇到一个非数字字符。如果遇到一个非数字的字符，它就得出结论：数字到了尾部。这就意味当程序下次开始读取的时候，将从前面被放弃的那个非数字字符开始。如果使用了字段宽度，那么scanf()在字段结尾或者在第一个空白字符处（两者最先到达的一个）终止。
如果第一个非空白字符不是数字，是一个char类型字符，那么scanf()会把字符放回输入，并停在那里。没有把任何值赋给变量，下次的读取时就会从那个字符开始。
如果使用%s，那么空白字符以外的所有字符都是可接受的，所以scanf()跳过空白字符直到遇到一个非空白字符，然后保存直到遇到再次遇到空白字符之前的所有非空白字符。这就意味着%s使scanf()读取一个不含空白字符的字符串。如果使用了字段宽度，那么scanf()在字段结尾或者在第一个空白字符处（两者最先到达的一个）终止。
如果使用%c，那么所有的字符都是平等的，不会跳过空白字符。如果在%c前有一个空格，那么scanf()会跳到第一个非空白字符处。也就是说，scanf("%c",&ch)读取在输入中遇到的第一个字符，而scanf(" %c",&ch)则读取遇到的第一个非空白字符。
scanf()的返回值
scanf()返回成功读入的项目的个数，如果没有读入任何项目，它会返回0。
当它检测到“文件尾部”时，返回EOF（EOF是在stdio.h中定义的特殊值。一般EOF被定义为-1）。
printf()和scanf()的*修饰符
当转换说明符是%*d，那么参数列表应该包含一个*的值和一个d的值，*的参数告诉函数字段宽度是多少。
#include <stdio.h>
int main(void)
{
unsigned width,precision;
int number=256;
double weight=242.5;
printf("What field width?\n");
scanf("%d",&width);
printf("The number is: %*d: \n",width,number);
printf("Now enter a width and a precision:\n");
scanf("%d %d",&width,&precision);
printf("Weight=%*.*f\n",width,precision,weight);
return 0;
}
而在scanf()中，当*在%和说明符字母之中，它使函数跳过相应的项目。
#include <stdio.h>
int main(void)
{
int n;
printf("Please enter three integers: \n");
scanf("%*d %*d %d",&n);
printf("The last integer was %d\n",n);
return 0;
}
基本运算符
基本算术运算的运算符：=、+、-、*、/。（C没有指数运算符，用pow()函数代替）
赋值运算符=
赋值运算符=把右边的变量或者表达式的值赋给右边的变量。
#include <stdio.h>
int main(void)
{
int jane,tarzan,cheeta;
cheeta=tarzan=jane=68;
printf(" cheeta tarzan jane\n");
printf("First round score %4d %8d %8d\n",cheeta,tarzan,jane);
return 0;
}
结果如下
cheeta tarzan jane First round score 68 68 68
加法运算符+
加法运算符+把两边的值加起来。
income=salary+bribes;
printf("%d",4+20);
减法运算符-
减法运算符-从前面的数减去后面的数。
takehome=224.00-24.00;
+和-运算符被称为二元或双值运算符，这表示它们需要两个操作数。
符号运算符-和+
这两个运算符用于指示一个值的代数符号。
rocky=-12; smokey=+12;
乘法运算符*
表示两数相乘。
cm=2.45*inch;
除法运算符/
用/表示除法。
整型数的除法和浮点数的除法有很大不同。浮点数除法得到浮点数结果，整数除法得到整数结果。但是整数不能有小数部分，当3去除5的时候，小数部分会被丢弃。
在C中，整数除法结果的小数部分会被丢弃，这个过程叫截尾。
#include <stdio.h>
int main(void)
{
printf("integer division: 5/4 is %d \n",5/4);
printf("integer division: 6/3 is %d \n",6/3);
printf("integer division: 7/4 is %d \n",7/4);
printf("floating division: 7./4. is %1.2f \n",7./4.);
printf("mixed division:7./4 is %1.2f \n",7./4);
return 0;
}
结果如下
integer division: 5/4 is 1 integer division: 6/3 is 2 integer division: 7/4 is 1 floating division: 7./4. is 1.75 mixed division: 7./4 is 1.75
截尾是不会先四舍五入的，会直接将小数部分截掉。
当混合类型进行除法时，编译器会将两个操作数转变成一致的类型。
运算符的优先级
其他运算符
sizeof运算符和size_t类型
#include <stdio.h>
int main(void)
{
int n=0;
size_t intsize;
intsize = sizeof(int);
printf("n=%d,n has %zd bytes;all ints have %zd bytes.\n",
n,sizeof n,intsize);
return 0;
}
sizeof运算符以字节为单位返回其操作数的大小。操作数可以是具体数据对象（如一个变量），或者一个类型（如float）。如果是一个类型，就必须放在括号里。
C规定sizeof返回size_t类型的值。这是一个无符号整数类型，它不是新类型，而是根据标准类型定义的。
C有一个typedef机制，它允许为已有的类型创建一个别名。例如：
typedef double real;
取模运算符%
取模运算符用于整数运算。它计算出两数相除的余数。
增量和减量运算符++和--
增量运算符将操作数的值加1.它有两种方式出现，++出现在变量前面是前缀模式，在变量后面是后缀模式。
#include <stdio.h>
int main(void)
{
int ultra=0,super=0;
while(super<5)
{
super++;
++ultra;
printf("super=%d,ultra=%d\n",super,ultra);
}
return 0;
}
输出结果如下
super=1,ultra=1 super=2,ultra=2 super=3,ultra=3 super=4,ultra=4 super=5,ultra=5
上面程序中的两个增量运算符语句等价于
super=super+1; ultra=ultra+1;
当然前缀模式和后缀模式是有区别的，以下示例显示了区别
#include <stdio.h>
int main(void)
{
int a=1,b=1;
int aplus,plusb;
aplus=a++;
plusb=++b;
printf("a aplus b plusb \n");
printf("%1d %5d %5d %5d\n",a,aplus,plusb);
return 0;
}
结果如下
a aplus b plusb 2 1 2 2
前缀和后缀增量的区别就在于a++是使用a的值后再自增，++a是自增后再使用a的值。
当然这是当它们和其他运算合用的时候才会有的区别，单独使用增量运算符时是没有区别的。
自增运算符的优先级
增量和减量运算符有很高的优先级，只有圆括号比它们的优先级高。
不要太聪明
如果一次使用太多的增量运算符，就会出现不期望的结果。
while(num<21)
{
printf("%10d %10d\n",num,num*num++);
}
这个程序看起来合理，其实它只能在某些系统上正常工作。问题是当printf()获取要打印的值时，它可能先计算最后一个参数的值，从而在计算其他参数之前增加num的值。所以，结果不会是：
5 25
而可能是：
6 25
另一个不确定的语句是：
ans=num/2+5*(1+num++);
在C中，编译器决定先计算哪个的值，所以如果先计算了num++，那么和先计算num/2就会是两个不同的结果。
通过两个原则避免这些问题：
如果一个变量出现在同一个函数的多个参数中时，不要将增量或减量运算符用于它上面。
当一个变量多次出现在一个表达式里时，不要将增量或减量运算符用于它上面。
表达式和语句
表达式（expression）是由运算符和操作数组合构成的。简单的表达式是一个单独的操作数。下面是一些表达式：
4 -6 a*(b+c/d)/20 q=5*2 x=++q%3 q>3
每一个表达式都有一个值
这是表达式最重要的属性。例如,
-4+6，值为2
c=3+8，值为11
5>3，值为1
6+(c=3+8)，值为17
语句
语句是一条完整的计算机指令。在C中，语句用结束处的一个分号标识。
#include <stdio.h>
int main(void) /*求出前20个整数的和*/
{
int count,sum; /*声明语句*/
count=0; /*赋值语句*/
sum=0;
while(count++<20)
sum=sum+count;
printf("sum=%d\n",sum); /*函数语句*/
return 0;
}
声明语句用来声明变量。
赋值语句为变量赋值。
函数语句引起函数的执行。
while语句被称为结构化语句。
while语句
以下为while循环的一般形式
while(expression)
statement
statement可以是一个带有分号的简单语句，也可以是花括号中的一个复合语句。
比较大小：使用关系运算符和表达式
新的_Bool类型
一个_Bool变量可以具有值1（真）或值0（假）。如果把一个非零的值赋给_Bool变量，它会被设置成1。
_Bool input_is_good;
input_is_good=(scanf("%ld",&num)==1);
while(input_is_good)
运算符优先级
for循环
for(initialize;test;update)
statement
for语句用三个分号分开的控制表达式来控制循环过程。initialize表达式只在循环语句执行之前执行一次。然后对test表达式求值，如果为真就执行一次循环，然后计算update表达式，接着再次检查test表达式。
更多的赋值运算符：+=、-=、*=、/=和%=
逗号运算符
逗号运算符扩展了for循环的灵活性。
#include<stdio.h>
int main(void)
{
const int FTRST_OZ=37;
const int NEXT_OZ=23;
int ounces,cost;
printf("ounces cost\n");
for(ounces=1,cost=FTRST_OZ;ounces<=16;onces++,
cost+=NEXT_OZ)
printf("%5d $%4.2f\n",ounces,cost/100.0);
return 0;
}
这个程序在初始化和更新表达式中使用了逗号表达式。
逗号表达式还有两个属性。首先，它保证分开的表达式按从左到右的次序进行计算（也就是说，逗号是个顺序点，逗号左边所有的副作用都在程序运行到逗号右边之前生效）。例如：
ounces++,cost=ounces*FIRST_OZ
其次，整个逗号表达式的值是右边成员的值。语句：
x=(y=3,(z=++y+2)+5);
如果不小心在写一个数字时使用了逗号：
houseprice=249,500;
C把它解释成一个逗号表达式，houseprice=249是左表达式，而500是右表达式。因此整个式子的值就是右边表达式的值。它等同于下面的代码：
houseprice=249; 500;
do while循环
do
statement
while(expression);
在expression为假之前重复执行statement部分。
if语句
if语句被称为分支语句或选择语句。
if(expression)
statement
如果expression求得的值为真（非零），就执行statement；否则跳过该语句。
在if语句中添加else关键字
if(expression)
statement1
else
statement2
如果expression为真(非零)，就执行statement1;如果expression为假或非零，就执行else后面的语句。
getchar()和putchar()
getchar()读取一个字符，putchar()打印一个字符。
ctype.h系列字符函数
ANSI C有一系列标准的函数用来分析字符，ctype.h偷吻检查包含这些函数的原型。这些函数接受一个字符作为参数，如果该参数属于某种特定的类型则返回非零值（真），否则返回零（假）。
以下是字符判断函数
以下是字符映射函数
注意，映射函数并不改变原始参数，它只返回改变之后的值。
多重选择else if
if(score<1000)
bonus=0;
else if(score<1500)
bonus=1;
else if(score<2000)
bonus=2;
else if(score<2500)
bonus=4;
else
bonus=6;
当有众多的else和if时，else和与它最近的一个if相匹配。
逻辑运算符
仅当exp1和exp2都为真的时候，exp1&&exp2才为真。
如果exp1或exp2为真或两者都为真，exp1||exp2为真。
如果exp1为假，则!exp1为真；并且如果exp1为真，则!exp1为假。
改变拼写法：iso646.h
iso646.h头文件里定义了逻辑运算符的可供选择的拼写法。
包含了这个头文件，就可以用and代替&&，用or代替||，用not代替!。
优先级
!运算符的优先级高于乘法运算，和增量运算符的优先级相同，仅此于圆括号。&&运算符的优先级高于||，这两者的优先级都低于关系运算符而高于赋值运算符。
求职的顺序
逻辑表达式是从左到右求值的。一旦发现使表达式为假的因素，立即停止求值。
条件运算符?:
expression1 ? expression2 : expression3
当expression1的值为真，整个表达式的值和expression2的值相同。如果expression1为假，整个表达式的值等于expression3的值。
continue和break
continue语句
#include<stdio.h>
int main(void)
{
const float MIN=0.0f;
const float MAX=100.0f;
float score;
float total=0.0f;
int n=0;
float min=MAX;
float max=MIN;
printf("Enter the first score(q to quit):");
while(scanf("%f",&score)==1)
{
if(score<MIN || score>MAX)
{
printf("%0.1f is an invalid value.Try again:",score);
continue;
}
printf("Accepting %0.1f: \n",score);
min=(score<min)?score:min;
max=(score<max)?score:max;
total+=score;
n++;
printf("Enter next score(q to quit):");
}
if(n>0)
{
printf("Average of %d scores is %0.1f.\n",n,total/n);
printf("Low=%0.1f,high=%0.1f\n",min,max);
}
else
printf("No valid scores were entered.\n");
return 0;
}
continue语句可用于三种循环形式。当运行到该语句时，它将导致剩余的迭代部分被忽略，开始下一次迭代。
break语句
break语句导致跳出循环。
#include<stdio.h>
int main(void)
{
float length,width;
printf("Enter the length of the rectangle:\n");
while(scanf("%f",&length)==1)
{
printf("Length=%0.2f:\n",length);
printf("Enter its width:\n");
if(scanf("%f",&width)!=1)
break;
printf("Width=%0.2f:\n",width);
printf("Area=%0.2f:\n",length*width);
printf("Enter the length of the rectangle:\n");
}
printf("Done.\n");
return 0;
}
多重选择：switch和break
#include<stdio.h>
#include<ctype.h>
int main(void)
{
char ch;
printf("Give me a letter of the alphabet,and i will give");
printf("an animal name\nbeginning with that letter.\n");
printf("Please type in a letter; type # to end my act.\n");
while((ch=getchar())!='#')
{
if('\n'==ch)
continue;
if(islower(ch))
swich(ch)
{
case 'a':
printf("argali,a wild sheep of Asia");
break;
case 'b':
printf("babirusa,a wild pig of Malay\n");
break;
case 'c':
printf("coati,racoonlike mammal\n");
break;
case 'd':
printf("desman,aquatic,molelike critter\n");
break;
case 'e':
printf("echidna,the spiny anteater\n");
break;
case 'f':
printf("fisher,brownish marten\n");
break;
default:
printf("That's a stumper!\n");
}
else
printf("I recognize only lowercase letters.\n");
while(getchar()!='\n')
continue;
printf("Please type another letter or a #.\n");
}
printf("Bye!\n");
return 0;
}
此示例程序中当输入dab时，仅处理了第一个字符。产生这种动作的是下面的代码：
while(getchar()!='\n')
continue;
也可以使用多重case标签。
switch(ch)
{
case 'a':
case 'A':a_ct++;
break;
.......
}
goto语句
goto label;
.
.
.
label: statement
扫一扫
2327
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
