C语言基础（语句篇）

输入输出语句

按照格式输入输出(常用)

格式：

%d int

%f float

%c char

%lf double

%s 字符串

%#x 十六进制

%#o 八进制

%p 地址

%e 指数

%-m.n

-：代表左对齐，右对齐

m：位宽

当 m 大于实际数据位宽时，按 m 位宽输出

当 m 小于实际数据位宽时，按际数据位宽输出

.n：保留小数点后几位

输出：printf

int printf(const char *format, ...);

功能：按照指定的格式向终端输出内容

参数：format：要输出的字符串的内容 ，如果有%格式则有后面的参数

           ...：不定参（根据前面的%格式确定）

返回值：输出字符的个数

输入：scanf

int scanf(const char *format, ...);

功能：按照指定的格式从终端输入内容

参数：format：双引号里只能写%格式

           ...：变量的地址

返回值：正确输入数据的个数 （当输入数据都不正确或第一个开始数据不正确时，返回 0）

按照字符输入输出

输出：putchar

int putchar(int c)；

功能：按照字符输出向终端输出一个字符

参数：要输出字符的ascii码值 字符

返回值：输出字符的ascii码值

输入：getchar

int getchar(void)；

功能：按照字符输入 从终端输入一个字符

参数：无

返回值：输入字符的ascii码值

垃圾字符回收

空格、tab、回车

垃圾字符回收：

%*c：只能回收一个字符

char m,n;
scanf("%c%*c%c",&n,&m);
printf("%c %c",m,n);

空格：可以回收多个字符

char a,b;
scanf("%c %c",&a,&b);
printf("%c %c\n",a,b);

getchar：只能回收任意一个字符,一般用于循环语句中

#include<stdio.h>
int main(int argc, char const *argv[])
{
    while(1)
    {
        char a;
        scanf("%c",&a);
        getchar();//回收垃圾字符
        printf("%c\n",a);
    }
    return 0;
}

分支循环语句

控制语句if_else

基本结构

if(表达式)

{

        语句块 1;

}

else

{

        语句块 2;

}

执行顺序：先判断 if 后面的表达式是否成立，如果成立就执行语句块 1，否则执行语句块 2

 示例1：用户输入一个年龄，判断是否成年

#include<stdio.h>
int main(int argc, char const *argv[])
{
    int age;
    printf("input age:\n");
    scanf("%d",&age);
    if(age>=18)
    {
        printf("成年\n");
    }
    else
    {
        printf("未成年\n");
    }
    return 0;
}

 示例2：某公园门票的票价是每人50元，一次购票满30张，每张可以少收2元，试编写自动计费系统程序

输入格式:输入一个正整数，表示购票的数量

输出格式:输出一个整数，表示用户实际需要支付的金额

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num, price = 50, pay;
    printf("请输入所要购买的票数:\n");
    scanf("%d", &num);
    if (num >= 30)
    {
        price -= 2;
        pay = num * price;
    }
    else
    {
        pay = num * price;
    }
    printf("请支付%d元\n", pay);
    return 0;
}

分层结构

if(表达式 1)

{

        语句块 1;

}

else if(表达式 2)

{

        语句块 2;

}

else if(表达式 3)
{
        语句块 3;
}

else

{

        语句块 4;

}

执行顺序：依次判断if或else后面的表达式，哪个成立执行哪个语句块，其他语句块不执行，如果都不成立，执行else后面的语句块

 示例1：大小写字母相互转换

#include<stdio.h>
int main(int argc, char const *argv[])
{
    char zm;
    printf("input zm:");
    scanf("%c",&zm);
    if(zm>='a'&&zm<='z')
    {
        zm=zm-32;
    }
    else if(zm>='A'&&zm<='Z')
    {
        zm=zm+32;
    }
    else
    {
        printf("error\n");
    }
    printf("%c\n",zm);
    return 0;
}

嵌套结构

if(表达式 1)

{

        if(表达式 2)

        {

                语句块 1; // 表达式 1 成立，表达式 2 成立

        }

        else

        {

                语句块 2; // 表达式 1 成立，表达式 2 不成立

        }

}

else

{

        语句块 3; // 表达式 1 不成立

}

注意：if语句花括号可以省略，省略后只能匹配一条语句，if后面可以没有else，但是else前面必须要有if

 示例1：循环输入三个数，输出最大值

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int a, b, c;
    while(1)
    {
        printf("input 3 num:\n");
        scanf("%d %d %d", &a, &b, &c);
        int max = a;
        if (b > a)
        {
            if(b>c)
            max = b;
        }
        else if (c > b && c > a)
            max = c;
        printf("max=%d\n", max);
    }
    return 0;
}

控制语句switch_case

基本结构

switch(变量或者表达式)

{

        case 常量 1:

        语句块 1;

        break;

        case 常量 2:

        语句块 2;

        break;

        ....

        case 常量 n:

        语句块 n;

        break;

        default:

        语句块 n+1;

        break;

}

执行顺序： 判断 switch 后面的表达式的结果 和 case 后面的常量进行匹配，如果能匹配上则执行对应的语句块代码，遇到 break 结束语句，当 case 项都不匹配时，会执行 default 的语句块代码

注意：

表达式不能是浮点类型或者字符串（可以是整型、字符型或枚举）

case 后面的 break 可以省略的，省略break后代码会顺序执行，直到遇到 break 结束

 示例1：从终端输入一个学生的成绩，判断学生成绩，打印成绩级别

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int a;
    printf("input:\n");
    scanf("%d",&a);
    switch (a / 10)
    {
    case 10:
    case 9:
        printf("A\n");
        break;
    case 8:
        printf("B\n");
        break;
    case 7:
        printf("C\n");
        break;
    case 6:
        printf("D\n");
        break;
    case 5:
    case 4:
    case 3:
    case 2:
    case 1:
    case 0:
        printf("不及格\n");
        break;
    default:
        printf("不是成绩\n");
        break;
    }
    return 0;
}

 示例2：写程序实现功能:读入两个整数(data1 和data2)和一个运算符(op),计算表达式data1 op data2 的值，其中 op 可以为+、-、*、/四个符号中的任一种(用 switch 语句实现)

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int data1, data2;
    char op;
    printf("input:\n");
    scanf("%d %d %c", &data1, &data2, &op);
    switch (op)
    {
    case '+':
        printf("%d+%d=%d\n", data1, data2, data1 + data2);
        break;
    case '-':
        printf("%d-%d=%d\n", data1, data2, data1 - data2);
        break;
    case '*':
        printf("%d*%d=%d\n", data1, data2, data1 * data2);
        break;
    case '/':
        printf("%d/%d=%d\n", data1, data2, data1 / data2);
        break;
    default:
        printf("请重新输入：\n");
        break;
    }
    return 0;
}

循环语句for

基本结构
for(表达式 1; 表达式 2; 表达式 3)
{
        语句块;
}
表达式 1：赋初值
表达式 2：循环终止条件
表达式 3：增值或减值语句

执行顺序

1. 首先执行表达式 1 给循环变量赋初值，判断表达式 2 是否成立，
2. 如果成立则执行语句块, 执行完语句块之后再执行表达式 3，
3. 再次判断表达式 2 是否成立，如果成立再次执行语句块
4. 重复 2、3 过程
5. 直到表达式 2 不成立则循环结束

 示例1：循环输出26个字母

#include<stdio.h>
int main(int argc, char const *argv[])
{
    char ch;
    for(ch='a';ch<='z';ch++)
    {
        printf("%2c",ch);
    }
    printf("\n");
    return 0;
}

 示例2：水仙花数：一个三位数的各个位的立方等于该数本身（100-999）

#include <stdio.h>
#include <math.h>
int main(int argc, char const *argv[])
{
    int n, a, b, c, i = 0;
    for (n = 100; n < 1000; n++)
    {
        a = n / 100;      // 百位
        b = n % 100 / 10; // 十位
        c = n % 10;       // 个位
        if (n == pow(a, 3) + pow(b, 3) + pow(c, 3))
        {
            printf("水仙花数%d\n", n);
            i++;
        }
    }
    printf("水仙花数有%d个\n", i);
    return 0;
}

 示例3：2006年培养学员80000人；每年增长%25，按此速度增长，到哪一年学员人数达到20万人

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int year=2006;
    int student;
     for(student = 8e4;student<=2e5;student=student*1.25)
    {
        year++;
    }
    printf("year=%d\n",year);
    return 0;
}

嵌套结构
for(表达式 1; 表达式 2; 表达式 3)
{
        for(表达式 4; 表达式 5; 表达式 6)
        {
        语句块 7;
        }
}

执行顺序

1. 首先执行表达式 1 给循环变量赋初值，判断表达式 2 是否成立
2. 如果成立则执行语句块(内层循环)，此时来到内层循环
3. 执行表达式 4，给循环变量赋初值，判断表达式 5 是否成立
4. 如果成立则执行语句块(内层循环的语句块)，执行完语句块，再去执行表达式 6
5. 判断表达式 5 是否成立，成立则执行语句块
6. 重复 4、5 过程，直到表达式 5 不成立，内层循环结束，执行表达式 3
7. 判断表达式 2 是否成立，成立则执行语句块(内层循环)
8. 重复 3、4、5、6 过程，直到表达式 2 不成立，整个循环结束

注：外层循环执行一次，内层循环执行一遍

 示例1：打印九九乘法表

#include<stdio.h>
int main(int argc, char const *argv[])
{
    int i,j;
    for(i=1;i<10;i++)
    {
        for(j=1;j<=i;j++)
        {
            printf("%d*%d=%d\t",j,i,j*i);
        }
        printf("\n");
    }
    return 0;
}

循环语句while do_while

基本结构

赋初值;

while(终止条件)

{

        语句块;

        增值或减值语句;

}

执行顺序： 首先判断条件，如果为真则执行循环，条件为假循环结束

do while语句基本结构

do

{

        语句块；

}while(表达式)

执行顺序：先执行语句块再进行条件判断，如果表达式为真则进入循环继续执行语句块，否则向下执行

 示例一：打印100-200中能被3整除的数

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int i = 100,n=0;
    while (i <= 200)
    {
        if (i % 3 == 0)
        {
            printf("%d能被3整除\n", i);
            n++;
        }
        i++;
        
    }
    printf("100-200中能被3整除的数有%d个\n",n);
    return 0;
}

循环控制语句

break：结束当前循环

continue：结束本次循环，继续下一次循环

 示例1：循环输入一个5位数，判断它是不是回文数。当输入0时循环结束。即12321是回文数，个位与万位相同，十位与千位相同

#include <stdio.h>
#include <stdbool.h>

int main() {
    int num;

    while (1) {
        printf("请输入一个5位数（输入0结束）：");
        scanf("%d", &num);

        if (num == 0) {
            break;
        }

        // 判断是否是5位数
        if (num < 10000 || num > 99999) {
            printf("输入错误，请输入一个5位数。\n");
            continue;
        }

        // 判断是否是回文数
        int reversed = 0, original = num, remainder;
        while (num != 0) {
            remainder = num % 10;
            reversed = reversed * 10 + remainder;
            num /= 10;
        }

        if (original == reversed) {
            printf("%d 是回文数。\n", original);
        } else {
            printf("%d 不是回文数。\n", original);
        }
    }

    return 0;
}