---

1. 控制语句

1.1 分支语句

1.1.1 if-else语句

简化形式

if(x>y) printf("%d",x);

阶梯形式

int main()
{
    float score;

    printf("please input score: \n");
    scanf("%f", &score);

    if(score<0 || score>100)
    {
        printf("input error\n");
        return 0;
    }
    else
    {
        if(score >= 90)
        {
            printf("A\n");
        }
        else
        {
            if(score >= 70 && score < 90)
            {
                printf("B\n");
            }
            else
            {
                if(score >= 60 && score < 70)
                {
                    printf("C\n");
                }
                else
                {
                    if(score < 60)
                    {
                        printf("D\n");
                    }
                }
            }
        }
    }
    
    return 0;
}

嵌套形式
if()
if() 语句1
else 语句2

else
if() 语句3
else 语句4

注意：

1. 语句块，当有若干条语句的时候，必须用{… …}括号起来
2. 表达式
   1. 一般情况下为逻辑表达式或关系表达式
      如：if(a == b && x == y) printf(“%d”, x);
   2. 也可以是任意类型（包括整型，实型，字符型，指针类型）
      如: if (‘a’) printf(“%d”, a);
   3. 区分if(x=1)和 if(1==x)的不同

1.1.2 switch语句

switch 语句的基本形式

switch(表达式)
{
	case 常量表达式1: 语句块1; break;
	case 常量表达式2: 语句块2; break;
	case 常量表达式n: 语句块n; break;
	  
	default : 语句块n+1
}

switch语句的使用

1. 每个常量表达式的值必须各不相同，否则将出现矛盾
2. 当表达式的值与case后面的常量表达式的值相等时，就执行case后面的语句。
3. switch中的表达式可以是整形，字符型表达式或枚举。
4. case 常量：只起语句标号的作用
5. break语句用于强行跳出switch体，一般每个case后面应有一个break语句，defalut分支后的break可以省略
6. 多个case可以执行一条语句

int main()
{
    float score = 0;
    printf("please input your score:");
    scanf("%f", &score);

    if(score<0 || score >100)
    {
        printf("input error!\n");
    }
    else
    {
        switch((int)score/10)
        {
            case 9:
                printf("A\n");
                break;
            case 8:
                printf("B\n");
                break;
            case 7:
                printf("B\n");
                break;
            case 6:
                printf("C\n");
                break;
            default:
                printf("D\n");
        }
    }

    return 0;
}

1.2 循环语句

1.2.1 goto

int main()
{
    int i = 1, sum = 0;

    loop:
        if(i<=100)
        {
            sum += i;
            i++;
            goto loop;
        }
    printf("sum=%d \n", sum);
    return 0;
}

• 当程序有多个出口，使用goto把这些出口集中到一处很方便，特别是函数中有很多重复的工作的时候。
• 理由是：
  • 无条件跳转易于理解
  • 可以减少嵌套
  • 可以避免那些忘记更新某一个出口点的问题
    • 算是帮助了编译器做优化

1.2.2 while

• 循环条件：
  • 1.变量初值
  • 2.终止条件
  • 3.变量变化

int main()
{
    int i = 1, sum = 0;

    while(i<=100)
    {
        sum+=i;
        i++;
    }
    
    printf("sum=%d \n", sum);
    return 0;
}

1.2.3 do-while

注意：至少会执行一次

int main()
{
    int i = 101, sum = 0;

    do{
        sum+=i;
        i++;
    }while(i<=100);

    printf("sum=%d \n", sum);	//结果为 101
    return 0;
}

1.2.4 for

int main()
{
    int i=1, sum = 0;
    for(;;)
    {
        sum+=i;
        i++;
        if(i>100)
            break;
    }

    printf("sum=%d \n", sum);
    return 0;
}

for语句构成循环

• 表达式1可以省略，但循环之前应要给循环变量赋值
• 表达式2可以省略，将陷入死循环
• 表达式3可以省略，但在循环体中增加循环使变量的值改变的语句

//九九乘法表
int main()
{
    int i, x;
    for(i=1;i<=9;i++)
    {
        for(x=1;x<=i;x++)
        {
            printf("%d×%d=%d \t", x, i, i*x);
        }
    	puts("");
    }
    return 0;
}

1.3 辅助控制语句

1.3.1 break

用于从循环体内跳出一层循环体，即提前结束循环

• break只能用在循环语句和switch语句中。

for(r=1;r<=10;r++)
{
	area = PI * r * r;
	if(area>100)
		break;
	printf("r=%f,area=%f \n", r, area);
}

1.3.2 continue

结束本次循环，接着判定下一次是否执行循环
注意break和continue的区别

• continue只结束本次循环，而break终止本层循环

int main()
{
    int n;

    for(n=100;n<=120;n++)
    {
        if(n % 3 == 0)
            continue;	//余数为 0，结束本次循环，继续判断下一次是否循环
        printf("%d \n", n);
    }
    return 0;
}

1.3.3 return

return语句的一般形式：return(<表达式>)
主要用于终止包含它的函数的执行
若终止的为主函数，则主程序结束

2. 数组

2.1 一维数组

• 构造数据类型之一
• 数组是具有一定顺序关系的若干个变量的集合，组成数组的各个变量称为数组的元素
• 数组中各元素的数据类型要求相同，用数组名和下标确定，数组可以是一维的，也可以是多维的。

2.1.1 一维数组的定义

1. 所谓一维数组是指只有一个下标的数组，它在计算机的内存中是连续存储的。
2. C语言中，一维数组的说明一般形式如下：
   <存储类型> <数据类型 > <数组名>[<表达式>]；
   

数组名表示内存首地址，是地址常量。sizeof(数组名)是数组占用的总内存空间
编译时分配连续的内存，内存字节数=数组维数*sizeof(元素数据类型)

int main()
{
    int a[6], i;
    for(i=0;i<6;i++)
    {
        printf("%p \n", a+i);
    }
    printf("%d \n", sizeof(a));	//24个字节
    return 0;
}

2.1.2 一维数组的引用

• 数组必须先定义，再使用
• 只能逐个引用数组元素，不能一次引用整个数组
• 数组元素表示形式： 数组名[下标]
  • 其中，下标可以是常量 或者 整型表达式

2.1.3 一维数组的初始化

1. 初始化方式：在定义数组的时候，为数组元素赋初值
   int a[5] = {1,2,3,4,5};
2. 说明
   1. 数组不初始化，其元素值为随机数
   2. 对static数组元素不赋初值，系统会自动赋以0
   3. 只给部分数组元素赋初值，剩下的元素为0

static int a[5];	等价于：a[0]=0;a[1]=0;a[2]=0;a[3]=0;a[4]=0;
int a[5] ={6,2,3}	等价于：a[0]=6;a[1]=2;a[2]=3;a[3]=0;a[4]=0;
int a[]={1,2,3,4,5,6};	编译系统根据初值个数确定数组维数

冒泡排序

int main()
{
    int a[] = {1, 8, 2, 7, 6, 5}, i, y, n, ting;
    n = sizeof(a) / sizeof(int);

    for(i=0;i<n-1;i++)
    {
        for(y=0;y<n-1-i;y++)
        {
            if(a[y] > a[y+1])
            {
                ting = a[y+1];
                a[y+1] = a[y];
                a[y] = ting;
            }
        }
    }
    for(i=0;i<n;i++) printf("%d ", a[i]);
    return 0;
}

2.2 二维数组

2.2.1 二维数组的定义

定义方式：（声明时列数不能省略，行数可以）
数据类型 数组名[常量表达式][常量表达式]；
例如：
int a[3][4];
float b[2][5];
int c [2][3][4];
元素个数 = 行数*列数

2.2.2 二维数组的存放顺序

原因：内存是一维的
二维数组：按行序优先

二维数组a是由 三个元素组成 a[0]、a[1]、a[2]
每个元素a[i] 由包含2个元素的一维数组组成

2.2.3 二维数组的引用

形式：数组名[下标][下标]
二维数组元素的初始化
1.分行初始化
2.按元素排列顺序初始化
例如：
int a[2][3] = {{1,2,3},{4,5,6}};

a[0][0]、a[0][1]、a[0][2]、 a[1][0]、a[1][1]、a[1][2]

int a[][3]={{1},{4,5}}; //一维数组的长度省略

int main()
{
    int a[][3] = {1, 2, 3, 4};		//1 2 3 在a[0]里，4 0 0 在a[1]里
    int i, j;

    for(i=0;i<2;i++)
    {
        for(j=0;j<3;j++)
        {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }

    printf("%p %d \n", a, sizeof(a));
    printf("%p %d \n", a[0], sizeof(a[0]));
    printf("%p %d \n", a[1], sizeof(a[1]));
    return 0;
}

2.3 多维数组

具有两个或者两个以上下标的数组称为多维数组。

int c[2][3][4]
c[0][0][0]、c[0][0][1]、c[0][0][2]、c[0][0][3]
c[0][1][0]、c[0][1][1]、c[0][1][2]、c[0][1][3]
c[0][2][0]、c[0][2][1]、c[0][2][2]、c[0][2][3]
c[1][0][0]、c[1][0][1]、c[1][0][2]、c[1][0][3]
c[1][1][0]、c[1][1][1]、c[1][1][2]、c[1][1][3]

3. 字符数组和字符串

3.1 字符数组

字符数组是元素的数据类型为字符类型的数组
char c[10], ch[3][4];
字符数组的初始化

• 逐个字符赋值
  • char ch[5] = { ‘H’,‘e’,‘l’,‘l’,‘o’ };
  • char ch[5] = {‘a’,‘b’,‘c’};

int main()
{
    char str1[] = {'a', 'b', 'c', '\0'};
    char str2[6] = {'a', 'b', 'c'};
    printf("%s \n", str1);
    printf("%s \n", str2);
    return 0;
}

例如：

• char ch[6] = {“hello”};
• char ch[6] = “hello”;
• char ch[] = “hello”;

3.2 字符串数组

C语言中没有字符串常量，用字符数组处理字符串，字符串结束表示：‘\0

int main()
{
    char fruit[][10] = {"apple","grape","pear","orange","peach"};
    int x, y, n, m;
    n = sizeof(fruit) / sizeof(fruit[0]);	//行
    m = sizeof(fruit[0]) / sizeof(char);	//列

    for(x=0;x<n;x++)
    {
        for(y=0;y<m;y++)
            putchar(fruit[x][y]);
        putchar('\n');
    }
    
    printf("---\n");
    
	for(x=0;x<n;x++)
    {
        printf("%s \n", fruit[x]);
    }
    return 0;
}

输入一个字符串，将字符串逆序输出

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 20
int main()
{
    char str[N] = {0};
    int n, i;

    printf("please input str:");
    gets(str);
    n = strlen(str);

    for(i=n-1;i>=0;i--)
    {
        putchar(str[i]);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define N 20
int main()
{
    char str[N] = {0}, s;
    int n, i, j;

    printf("please input str:");
    gets(str);

    n = strlen(str);

    j = n - 1;
    i = 0;
    while(i<j)
    {
        s = str[j];
        str[j] = str[i];
        str[i] = s;
        
        i++;
        j--;
    }
    puts(str);
    return 0;
}

3.3 字符串函数

C语言库中实现了很多字符串处理的函数

#include <string.h>

几个常见的字符串处理函数

1. strlen, 求字符串长度函数
2. strcpy, 字符串拷贝函数
3. strcat, 字符串连接函数
4. strcmp, 字符串比较函数

3.3.1 strlen

字符串长度函数strlen

• 格式：strlen(字符数组)
• 功能：计算字符串长度
• 返回值：返回字符串实际长度，不包括’\0’在内
  • \xhh 表示十六进制数代表的符号
  • \ddd 表示八进制的

char s[10] = {'a', '0', '\0', 'b', 'c', '\0'};
printf("%d %d\n", strlen(s), sizeof(s));	//结果为 2 10

char s1[] = "\t\v\\\0will\n";;
printf("%d %d\n", strlen(s1), sizeof(s1));	//结果为 3 10

char s2[] = "\x69\141\n"; //i a 换行
printf("%d %d\n", strlen(s2), sizeof(s2));	//结果为 3 4

3.3.2 strcpy

字符串拷贝函数 strcpy

• 格式：strcpy(字符串1，字符串2)；
• 功能:将字符串2拷贝到字符串1中
• 返回值：返回字符数组1的首地址
• 说明：
  • 字符数组1 必须足够大
  • 拷贝时 ‘\0’ 一同拷贝

char s[] = "hello world!";
char s2[N];
strcpy(s2, s);

puts(s);	//hello world!
puts(s2);	//hello world!

3.3.3 strcat

字符串连接函数strcat

• 格式：stracat(字符数组1，字符数组2)
• 功能：把字符数组2连接到字符数组1后面
• 返回值：返回字符数组1的首地址
• 说明：
  • 字符数组1必须足够大
  • 连接前，两串均以 ‘\0’ 结束，连接后，串1 的 ‘\0’ 取消，新串最后加 ‘\0’

char s[20] = "hello";
char s2[] = " world!";
strcat(s, s2);

puts(s);	//hello world!

3.3.4 strcmp

字符串比较函数 strcmp

• 格式：strcmp(字符串1，字符串2)
• 功能：比较两个字符串
• 比较规则：对两串从左向右逐个字符比较(ASCII), 直到遇到不同字符或 '\0’为止
• 返回值：返回int型整数
  • 1.若字符串1 < 字符串2，返回负整数
  • 2.若字符串1 > 字符串2，返回正整数
  • 3.若字符串1 = 字符串2，返回零

char s[20] = "hello";
char s2[] = "hello";
printf("%d \n", strcmp(s, s2));	// 0

char st[20] = "hello";
char st2[] = "aello";
printf("%d \n", strcmp(st, st2));	// 1

char std[20] = "hbc";
char std2[] = "hello";
printf("%d \n", strcmp(std, std2));	// -1

3.3.5 字符串扩展用法

• strncpy(p, p1, n) 复制指定长度字符串
• strncat(p, p1, n) 附加指定长度字符串
• strcasecmp(p, p1) 忽略大小写比较字符串
• strncmp(p, p1, n) 比较指定长度字符串
• strchr(p, c) 在字符串中查找指定字符
• strstr(p, p1) 查找字符串

1. isalpha()检查是否为字母字符
2. isupper()检查是否为大写字母字符
3. islower()检查是否为小写字母字符
4. isdigit()检查是否为数字字符

#include <ctype.h>

char s[] = "helab";
char s2[] = "world";
strncpy(s, s2, 3);
puts(s);	// worab

char s[] = "hello";
char s2[] = "world";
strncat(s, s2, 3);
puts(s);	//hellowor

char s[] = "hello";
char s2[] = "HELLO";
printf("%d \n", strcasecmp(s, s2));	// 0

char s[] = "hello";
char s2[] = "hello\n";
printf("%d \n", strncmp(s, s2, 3));	// 0