C语言中有三大结构，分别是顺序结构、选择结构和循环结构（分支结构）：
-
C语言顺序结构就是让程序按照从头到尾的顺序依次执行每一条C语言代码，不重复执行任何代码，也不跳过任何代码。
-
C语言选择结构也称分支结构，就是让程序“拐弯”，有选择性的执行代码；换句话说，可以跳过没用的代码，只执行有用的代码。
-
C语言循环结构就是让程序“杀个回马枪”，不断地重复执行同一段代码。
if else语句
#include <stdio.h>
int main()
{
int age;
printf("请输入你的年龄：");
scanf("%d", &age);
if(age>=18){
printf("恭喜，你已经成年，可以使用该软件！\n");
}else{
printf("抱歉，你还未成年，不宜使用该软件！\n");
}
return 0;
}
if 和 else 是两个新的关键字，if 意为“如果”，else 意为“否则”，用来对条件进行判断，并根据判断结果执行不同的语句。总结起来，if else 的结构为：
if(判断条件){
语句块1
}else{
语句块2
}
执行过程可表示为下图：
所谓语句块（Statement Block），就是由{ }包围的一个或多个语句的集合。如果语句块中只有一个语句，也可以省略{ }，例如：
if(age>=18) printf("恭喜，你已经成年，可以使用该软件！\n");
else printf("抱歉，你还未成年，不宜使用该软件！\n");
由于if else 语句可以根据不同的情况执行不同的代码，所以也叫分支结构或选择结构，上面的代码中，就有两个分支。
求两个数中的较大值：
#include <stdio.h>
int main() {
int a, b, max;
printf("输入两个整数：");
scanf("%d %d", &a, &b);
if (a > b) max = a;
else max = b;
printf("%d和%d中较大的数为：%d", a, b, max);
return 0;
}
/*
输入两个整数：34 28↙
34和28的较大值是：34
*/
只使用if语句
有的时候，我们需要在满足某种条件时进行一些操作，而不满足条件时就不进行任何操作，这个时候我们可以只使用 if 语句。也就是说，if else 不必同时出现。
单独使用 if 语句的形式为：
if(判断条件){
语句块
}
意思是，如果判断条件成立就执行语句块，否则直接跳过。其执行过程可表示为下图：
#include <stdio.h>
int main()
{
int a, b, max;
printf("输入两个整数：");
scanf("%d %d", &a, &b);
max=b; // 假设b最大
if(a>b) max=a; // 如果a>b，那么更改max的值
printf("%d和%d的较大值是：%d\n", a, b, max);
return 0;
}
多个if else语句
if else 语句也可以多个同时使用，构成多个分支，形式如下：
if(判断条件1){
语句块1
} else if(判断条件2){
语句块2
}else if(判断条件3){
语句块3
}else if(判断条件m){
语句块m
}else{
语句块n
}
意思是，从上到下依次检测判断条件，当某个判断条件成立时，则执行其对应的语句块，然后跳到整个 if else 语句之外继续执行其他代码。如果所有判断条件都不成立，则执行语句块n，然后继续执行后续代码。
也就是说，一旦遇到能够成立的判断条件，则不再执行其他的语句块，所以最终只能有一个语句块被执行。
例如，使用多个 if else 语句判断输入的字符的类别：
#include <stdio.h>
int main(){
char c;
printf("Input a character:");
c=getchar();
if(c<32)
printf("This is a control character\n");
else if(c>='0'&&c<='9')
printf("This is a digit\n");
else if(c>='A'&&c<='Z')
printf("This is a capital letter\n");
else if(c>='a'&&c<='z')
printf("This is a small letter\n");
else
printf("This is an other character\n");
return 0;
}
在使用 if 语句时还应注意以下两点：
-
在 if 语句中，判断条件必须用括号括起来。
-
语句块由
{ }包围，但要注意的是在}之后不需要再加分号;（当然加上也没错）。
if语句的嵌套
if 语句也可以嵌套使用，例如：
#include <stdio.h>
int main(){
int a,b;
printf("Input two numbers:");
scanf("%d %d",&a,&b);
if(a!=b){ //!=表示不等于
if(a>b) printf("a>b\n");
else printf("a<b\n");
}else{
printf("a=b\n");
}
return 0;
}
if 语句嵌套时，要注意 if 和 else 的配对问题。C语言规定，else 总是与它前面最近的 if 配对，例如：
if(a!=b) // ①
if(a>b) printf("a>b\n"); // ②
else printf("a<b\n"); // ③
// ③和②配对，而不是和①配对。
关系运算符
关系运算符在使用时，它的的两边都会有一个表达式，比如变量、数值、加减乘除运算等，关系运算符的作用就是判明这两个表达式的大小关系。注意，是判明大小关系，不是其他关系。
C语言提供了以下关系运算符：
| 关系运算符 | 含 义 | 数学中的表示 |
|---|---|---|
| < | 小于 | < |
| <= | 小于或等于 | ≤ |
| > | 大于 | > |
| >= | 大于或等于 | ≥ |
| == | 等于 | = |
| != | 不等于 | ≠ |
关系运算符都是双目运算符，其结合性均为左结合。关系运算符的优先级低于算术运算符，高于赋值运算符。在六个关系运算符中，<、<=、>、>=的优先级相同，高于==和!=，==和!=的优先级相同。
在C语言中，有的运算符有两个操作数，例如 10+20，10和20都是操作数，+ 是运算符。我们将这样的运算符称为双目运算符。同理，将有一个操作数的运算符称为单目运算符，将有三个操作数的运算符称为三目运算符。
常见的双目运算符有 +、-、*、/ 等，单目运算符有 ++、--等，三目运算符只有一个，就是 ? :
关系运算符的两边可以是变量、数据或表达式，例如：
- a+b > c-d
- x > 3/2
- ‘a’+1 < c
- -i-5*j == k+1
关系运算符也可以嵌套使用，例如：
- a > (b > c)
- a != (c == d)
关系运算符的运算结果只有 0 或 1。当条件成立时结果为 1，条件不成立结果为 0。例如：
-
5>0 成立，其值为 1；
-
34-12>100 不成立，其值为 0；
-
(a=3)>(b=5) 由于3>5不成立，故其值为 0。
我们将运算结果 1 称为“真”，表示条件成立，将 0 称为“假”，表示条件不成立。
与其他编程语言不同的是，C语言中没有布尔类型的值（true、false），转而直接用1和0两个数代替，这是C作为接近底层硬件的语言的特点：可以将一切类型都用数字表示，比如用数字表示字符，再用字符数组表示字符串，用数字表示布尔值等。关系运算的结果仍然是数字，因此在这种情况下，关系运算符有了与其他语言不同的特性：可以嵌套或连续使用。
的代码会将关系运算符的结果输出：
纯文本复制
#include <stdio.h>
int main(){
char c='k';
int i=1, j=2, k=3;
float x=3e+5, y=0.85;
int result_1 = 'a'+5<c, result_2 = x-5.25<=x+y;
printf( "%d, %d\n", result_1, -i-2*j>=k+1 );
printf( "%d, %d\n", 1<j<5, result_2 );
printf( "%d, %d\n", i+j+k==-2*j, k==j==i+5 );
return 0;
}
/*
1, 0
1, 1
0, 0
*/
对于含多个关系运算符的表达式，如 kji+5，根据运算符的左结合性，先计算kj，该式不成立，其值为0，再计算0i+5，也不成立，故表达式值为0。
需要提醒的是，==才表示等于，而=表示赋值，要注意区分，切勿混淆。
左结合性：即在优先级相同的情况下，从左边开始运算，每运算一次，表达式就会变短，过程看上去就像变量与运算符结合了一样，所以称为结合性。
再谈 if 语句的判断条件
if 语句的判断条件中不是必须要包含关系运算符，它可以是赋值表达式，甚至也可以是一个变量，例如：
//情况①
if(b){
//TODO:
}
//情况②
if(b=5){ //情况①
//TODO:
}
这些都是允许的。只要整个表达式的值为非0，条件就成立。
条件判断中的表达式的值只要不是0，条件都成立。这一点又是和其他语言不同的地方，在Java中，如果在if中只写一个非布尔值的变量，是会直接报错的。而C中可以这么做，究其原因，还是因为C将布尔值简化为了1和0的表示。
if(a=b)
printf("%d",a);
else
printf("a=0");
这段代码的意思是，把 b 的值赋予 a，如果为非0则输出该值，否则输出“a=0”字符串。
逻辑运算符
C语言中的逻辑运算：
| 运算符 | 说明 | 结合性 | 举例 |
|---|---|---|---|
| && | 与运算，双目，对应数学中的“且” | 左结合 | 1&&0、(9>3)&&(b>a) |
| 或运算，双目，对应数学中的“或” | |||
| ! | 非运算，单目，对应数学中的“非” | 右结合 | !a、!(2<5) |
逻辑运算的结果
在编程中，我们一般将零值称为“假”，将非零值称为“真”。逻辑运算的结果也只有“真”和“假”，“真”对应的值为 1，“假”对应的值为 0。
与运算(&&)
参与运算的两个表达式都为真时，结果才为真，否则为假。例如：
5&&0
5为真，0为假，相与的结果为假，也就是 0。
(5>0) && (4>2)
5>0 的结果是1，为真，4>2结果是1，也为真，所以相与的结果为真，也就是1。
或运算(||)
参与运算的两个表达式只要有一个为真，结果就为真；两个表达式都为假时结果才为假。例如：
10 || 0
10为真，0为假，相或的结果为真，也就是 1。
(5>0) || (5>8)
5>0 的结果是1，为真，5>8 的结果是0，为假，所以相或的结果为真，也就是1。
非运算(!)
参与运算的表达式为真时，结果为假；参与运算的表达式为假时，结果为真。例如：
!0
0 为假，非运算的结果为真，也就是 1。
!(5>0)
5>0 的结果是1，为真，非运算的结果为假，也就是 0。
#include <stdio.h>
int main(){
int a = 0, b = 10, c = -6;
int result_1 = a&&b, result_2 = c||0;
printf("%d, %d\n", result_1, !c);
printf("%d, %d\n", 9&&0, result_2);
printf("%d, %d\n", b||100, 0&&0);
return 0;
}
/*
0, 0
0, 1
1, 0
*/
优先级
逻辑运算符和其它运算符优先级从低到高依次为：
赋值运算符(=) < &&和|| < 关系运算符 < 算术运算符 < 非(!)
&& 和 || 低于关系运算符，! 高于算术运算符。
按照运算符的优先顺序可以得出：
-
a>b && c>d 等价于 (a>b)&&(c>d)
-
!b==c||d<a 等价于 ((!b)==c)||(d<a)
-
a+b>c&&x+y<b 等价于 ((a+b)>c)&&((x+y)<b)
另外，逻辑表达式也可以嵌套使用，例如a>b && b || 9>c，a || c>d && !p。
&&和||为双目运算符，在所有的双目运算符中优先级最低，!为单目运算符，优先级高于所有双目运算符
#include <stdio.h>
int main(){
char c='k';
int i=1,j=2,k=3;
float x=3e+5,y=0.85;
printf( "%d,%d\n", !x*!y, !!!x );
printf( "%d,%d\n", x||i&&j-3, i<j&&x<y );
printf( "%d,%d\n", i==5&&c&&(j=8), x+y||i+j+k );
return 0;
}
/*
0,0
1,0
0,1
*/
switch case 语句
#include <stdio.h>
int main() {
int a;
printf("Input integer number:");
scanf("%d", &a);
switch (a) {
case 1:
printf("Monday\n");
break;
case 2:
printf("Tuesday\n");
break;
case 3:
printf("Wednesday\n");
break;
case 4:
printf("Thursday\n");
break;
case 5:
printf("Friday\n");
break;
case 6:
printf("Saturday\n");
break;
case 7:
printf("Sunday\n");
break;
default:
printf("error\n");
break;
}
return 0;
}
/*
Input integer number:4↙
Thursday
*/
switch 是另外一种选择结构的语句，用来代替简单的、拥有多个分枝的 if else 语句，基本格式如下：
switch(表达式){
case 整型数值1: 语句 1;
case 整型数值2: 语句 2;
......
case 整型数值n: 语句 n;
default: 语句 n+1;
}
它的执行过程是：
- 首先计算“表达式”的值，假设为 m。
- 从第一个 case 开始，比较“整型数值1”和 m，如果它们相等，就执行冒号后面的所有语句，也就是从“语句1”一直执行到“语句n+1”，而不管后面的 case 是否匹配成功。
- 如果“整型数值1”和 m 不相等，就跳过冒号后面的“语句1”，继续比较第二个 case、第三个 case……一旦发现和某个整型数值相等了，就会执行后面所有的语句。假设 m 和“整型数值5”相等，那么就会从“语句5”一直执行到“语句n+1”。
- 如果直到最后一个“整型数值n”都没有找到相等的值，那么就执行 default 后的“语句 n+1”。
需要重点强调的是，当和某个整型数值匹配成功后，会执行该分支以及后面所有分支的语句。
#include <stdio.h>
int main(){
int a;
printf("Input integer number:");
scanf("%d",&a);
switch(a){
case 1: printf("Monday\n");
case 2: printf("Tuesday\n");
case 3: printf("Wednesday\n");
case 4: printf("Thursday\n");
case 5: printf("Friday\n");
case 6: printf("Saturday\n");
case 7: printf("Sunday\n");
default:printf("error\n");
}
return 0;
}
/*
Input integer number:4↙
Thursday
Friday
Saturday
Sunday
error
*/
输入4，发现和第四个分支匹配成功，于是就执行第四个分支以及后面的所有分支。这显然不是我们想要的结果，我们希望只执行第四个分支，而跳过后面的其他分支。为了达到这个目标，必须要在每个分支最后添加break;语句。
break 是C语言中的一个关键字，专门用于跳出 switch 语句。所谓“跳出”，是指一旦遇到 break，就不再执行 switch 中的任何语句，包括当前分支中的语句和其他分支中的语句；也就是说，整个 switch 执行结束了，接着会执行整个 switch 后面的代码。
使用 break 修改上面的代码：
#include <stdio.h>
int main(){
int a;
printf("Input integer number:");
scanf("%d",&a);
switch(a){
case 1: printf("Monday\n"); break;
case 2: printf("Tuesday\n"); break;
case 3: printf("Wednesday\n"); break;
case 4: printf("Thursday\n"); break;
case 5: printf("Friday\n"); break;
case 6: printf("Saturday\n"); break;
case 7: printf("Sunday\n"); break;
default:printf("error\n"); break;
}
return 0;
}
/*
Input integer number:4↙
Thursday
*/
由于 default 是最后一个分支，匹配后不会再执行其他分支，所以也可以不添加break;语句。
最后需要说明的两点是：
- case 后面必须是一个整数，或者是结果为整数的表达式，但不能包含任何变量。请看下面的例子：
case 10: printf("..."); break; //正确
case 8+9: printf("..."); break; //正确
case 'A': printf("..."); break; //正确，字符和整数可以相互转换
case 'A'+19: printf("..."); break; //正确，字符和整数可以相互转换
//case 9.5: printf("..."); break; //错误，不能为小数
//case a: printf("..."); break; //错误，不能包含变量
//case a+10: printf("..."); break; //错误，不能包含变量
- default 不是必须的。当没有 default 时，如果所有 case 都匹配失败，那么就什么都不执行。
条件运算符
条件运算符的语法格式为：
表达式1 ? 表达式2 : 表达式3
条件运算符是C语言中唯一的一个三目运算符，其求值规则为：如果表达式1的值为真，则以表达式2 的值作为整个条件表达式的值，否则以表达式3的值作为整个条件表达式的值。条件表达式通常用于赋值语句之中。
if(a>b){
max = a;
}else{
max = b;
}
//等价于
max = (a>b) ? a : b;
使用条件表达式时，还应注意以下几点：
- 条件运算符的优先级低于关系运算符和算术运算符，但高于赋值符。因此
max=(a>b) ? a : b;
可以去掉括号而写为
max=a>b ? a : b;
-
条件运算符?和：是一对运算符，不能分开单独使用。
-
条件运算符的结合方向是自右至左。例如：
a>b ? a : c>d ? c : d;
应理解为：
a>b ? a : ( c>d ? c : d );
这也就是条件表达式嵌套的情形，即其中的表达式又是一个条件表达式。
#include <stdio.h>
int main(){
int a, b;
printf("Input two numbers:");
scanf("%d %d", &a, &b);
printf("max=%d\n", a>b?a:b);
return 0;
}
/*
Input two numbers:23 45
max=45
*/
while循环
while循环
while循环的一般形式为：
while(表达式){
语句块
}
意思是，先计算“表达式”的值，当值为真（非0）时， 执行“语句块”；执行完“语句块”，再次计算表达式的值，如果为真，继续执行“语句块”……这个过程会一直重复，直到表达式的值为假（0），就退出循环，执行 while 后面的代码。
通常将“表达式”称为循环条件，把“语句块”称为循环体，整个循环的过程就是不停判断循环条件、并执行循环体代码的过程。
用 while 循环计算1加到100的值：
#include <stdio.h>
int main(){
int i=1, sum=0;
while(i<=100){
sum+=i;
i++;
}
printf("%d\n",sum);
return 0;
}
// 5050
do-while循环
do-while循环的一般形式为：
do{
语句块
}while(表达式);
do-while循环与while循环的不同在于：它会先执行“语句块”，然后再判断表达式是否为真，如果为真则继续循环；如果为假，则终止循环。因此，do-while 循环至少要执行一次“语句块”。
注意while(i<=100);最后的分号;，这个必须要有。
for循环
for 循环的使用更加灵活，完全可以取代 while 循环。
#include <stdio.h>
int main() {
int sum = 0;
for (int i = 1; i <= 100; ++i) {
sum += i;
}
printf("%d", sum);
return 0;
}
// 5050
for 循环的一般形式为：
for(表达式1; 表达式2; 表达式3){
语句块
}
它的运行过程为：
- 先执行“表达式1”。
- 再执行“表达式2”，如果它的值为真（非0），则执行循环体，否则结束循环。
- 执行完循环体后再执行“表达式3”。
- 重复执行步骤 2) 和 3)，直到“表达式2”的值为假，就结束循环。
上面的步骤中，2) 和 3) 是一次循环，会重复执行，for 语句的主要作用就是不断执行步骤 2) 和 3)。
“表达式1”仅在第一次循环时执行，以后都不会再执行，可以认为这是一个初始化语句。“表达式2”一般是一个关系表达式，决定了是否还要继续下次循环，称为“循环条件”。“表达式3”很多情况下是一个带有自增或自减操作的表达式，以使循环条件逐渐变得“不成立”。
for循环的执行过程可用下图表示：
for循环的一般形式：
for(初始化语句; 循环条件; 自增或自减){
语句块
}
for循环中的三个表达式
for 循环中的“表达式1（初始化条件）”、“表达式2(循环条件)”和“表达式3（自增或自减）”都是可选项，都可以省略（但分号;必须保留）。
3个表达式可以同时省略：
for( ; ; )语句
相当于
while(1)语句
“表达式1”可以是初始化语句，也可以是其他语句。
for( sum=0; i<=100; i++ ) sum=sum+i;
“表达式1”和“表达式3”可以是一个简单表达式也可以是逗号表达式。
for( sum=0,i=1; i<=100; i++ ) sum=sum+i;
或 for( i=0; (c=getchar())!='\n'; i+=c );
表达式2”一般是关系表达式或逻辑表达式，但也可是数值或字符，只要其值非零，就执行循环体。
for( i=0; (c=getchar())!='\n'; i+=c );
或
for( ; (c=getchar())!='\n' ; )
printf("%c",c);
break和continue
使用while或for循环时，如果想提前结束循环（在不满足结束条件的情况下结束循环），可以使用break或continue关键字。
break关键字
当 break 关键字用于 while、for 循环时，会终止循环而执行整个循环语句后面的代码。break 关键字通常和 if 语句一起使用，即满足条件时便跳出循环。
#include <stdio.h>
int main(){
int i=1, sum=0;
while(1){ //循环条件为死循环
sum+=i;
i++;
if(i>100) break;
}
printf("%d\n", sum);
return 0;
}
// 5050
在多层循环中，一个 break 语句只向外跳一层。例如，输出一个4*4的整数矩阵：
#include <stdio.h>
int main(){
int i=1, j;
while(1){ // 外层循环
j=1;
while(1){ // 内层循环
printf("%-4d", i*j);
j++;
if(j>4) break; //跳出内层循环
}
printf("\n");
i++;
if(i>4) break; // 跳出外层循环
}
return 0;
}
/*
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
*/
continue语句
continue 语句的作用是跳过循环体中剩余的语句而强制进入下一次循环。continue语句只用在 while、for 循环中，常与 if 条件语句一起使用，判断条件是否成立。
#include <stdio.h>
int main(){
char c = 0;
while(c!='\n'){ //回车键结束循环
c=getchar();
if(c=='4' || c=='5'){ //按下的是数字键4或5
continue; //跳过当次循环，进入下次循环
}
putchar(c);
}
return 0;
}
/*
0123456789↙
01236789
*/
本例我们输入的是 0123456789，当读取到4或5时，if 的条件c=='4'||c=='5'成立，就执行 continue 语句，结束当前循环，直接进入下一次循环，也就是说putchar(c);不会被执行到。而读取到其他数字时，if 的条件不成立，continue 语句不会被执行到，putchar(c);就会输出读取到的字符。
break与continue的对比：break 用来结束所有循环，循环语句不再有执行的机会；continue 用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。
循环嵌套
在C语言中，if-else、while、do-while、for 都可以相互嵌套。所谓嵌套（Nest），就是一条语句里面还有另一条语句，例如 for 里面还有 for，while 里面还有 while，或者 for 里面有 while，while 里面有 if-else，这都是允许的。
//for 嵌套执行的流程
#include <stdio.h>
int main()
{
int i, j;
for(i=1; i<=4; i++){ //外层for循环
for(j=1; j<=4; j++){ //内层for循环
printf("i=%d, j=%d\n", i, j);
}
printf("\n");
}
return 0;
}
/*
i=1, j=1
i=1, j=2
i=1, j=3
i=1, j=4
i=2, j=1
i=2, j=2
i=2, j=3
i=2, j=4
i=3, j=1
i=3, j=2
i=3, j=3
i=3, j=4
i=4, j=1
i=4, j=2
i=4, j=3
i=4, j=4
*/
在C语言中，代码是顺序、同步执行的，当前代码必须执行完毕后才能执行后面的代码。这就意味着，外层 for 每次循环时，都必须等待内层 for 循环完毕（也就是循环4次）才能进行下次循环。虽然 i 是变量，但是对于内层 for 来说，每次循环时它的值都是固定的。
//输出一个4×4的整数矩阵
#include <stdio.h>
int main()
{
int i, j;
for(i=1; i<=4; i++){ //外层for循环
for(j=1; j<=4; j++){ //内层for循环
printf("%-4d", i*j);
}
printf("\n");
}
return 0;
}
/*
1 2 3 4
2 4 6 8
3 6 9 12
4 8 12 16
*/
可以看到，内层 for 每循环一次输出一个数据，而外层 for 每循环一次输出一行数据。
输出九九乘法表
#include <stdio.h>
int main(){
int i, j;
for(i=1; i<=9; i++){ //外层for循环
for(j=1; j<=i; j++){ //内层for循环
printf("%d*%d=%-2d ", i, j, i*j);
}
printf("\n");
}
return 0;
}
/*
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
*/
需要注意的是，内层 for 的结束条件是j<=i。外层 for 每循环一次，i 的值就会变化，所以每次开始内层 for 循环时，结束条件是不一样的。具体如下：
-
当 i=1 时，内层 for 的结束条件为 j<=1，只能循环一次，输出第一行。
-
当 i=2 时，内层 for 的结束条件是 j<=2，循环两次，输出第二行。
-
当 i=3 时，内层 for 的结束条件是 j<=3，循环三次，输出第三行。
-
当 i=4、5、6… 时，以此类推。
总结
选择结构
选择结构（分支结构）涉及到的关键字包括 if、else、switch、case、break，还有一个条件运算符? :（这是C语言中唯一的一个三目运算符）。其中，if…else 是最基本的结构，switch…case 和? :都是由 if…else 演化而来，它们都是为了让程序员书写更加方便。
你可以只使用 if，也可以 if…else 配对使用。另外要善于使用 switch…case 和? :，有时候它们看起来更加清爽。
if…else 可以嵌套使用，原则上嵌套的层次（深度）没有限制，但是过多的嵌套层次会让代码结构混乱。
循环结构
C语言中常用的循环结构有 while 循环和 for 循环，它们都可以用来处理同一个问题，一般可以互相代替。
除了 while 和 for，C语言中还有一个 goto 语句，它也能构成循环结构。不过由于 goto 语句很容易造成代码混乱，维护和阅读困难，饱受诟病，不被推荐，而且 goto 循环完全可以被其他循环取代，所以后来的很多编程语言都取消了 goto 语句。
对于 while 和 do-while 循环，循环体中应包括使循环趋于结束的语句。
对于 while 和 do-while 循环，循环变量的初始化操作应该在 while 和 do-while 语句之前完成，而 for 循环可以在内部实现循环变量的初始化。
for 循环是最常用的循环，它的功能强大，一般都可以代替其他循环。
最后还要注意 break 和 continue 关键字用于循环结构时的区别：
-
break 用来跳出所有循环，循环语句不再有执行的机会；
-
continue 用来结束本次循环，直接跳到下一次循环，如果循环条件成立，还会继续循环。
此外，break 关键字还可以用于跳出 switch…case 语句。所谓“跳出”，是指一旦遇到 break，就不再执行 switch 中的任何语句，包括当前分支中的语句和其他分支中的语句；也就是说，整个 switch 执行结束了，接着会执行整个 switch 后面的代码。
1888
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
