精华内容
下载资源
问答
  • 本科学生非计算机专业C语言程序设计试卷A宁波大红鹰学院2009-2010学年第二学期2009级本科机械制造及其自动化、电气工程及其自动化专业《计算机应用技术II(C)》期末考试试卷(A卷) 考试时间:120...A、1 B、非0的数...

    本科学生非计算机专业C语言程序设计试卷A

    宁波大红鹰学院

    2009-2010学年第二学期

    2009级本科机械制造及其自动化、电气工程及其自动化专业

    《计算机应用技术II(C)》

    期末考试试卷(A卷) 考试时间:120分钟

    题 号一二三四总分复核人分 数20201248100实得分评卷人

    得 分一、单选题(每小题2分,共20分)

    1、在C程序中,用( )表示逻辑值“真”。

    A、1 B、非0的数 C、非1的数D、大于0的数

    2、若从键盘输入58,则以下程序输出的结果是( )。

    main()

    { int a;

    scanf(“%d”,&a);

    if(a>50) printf(“%d”,a);

    if(a>40) printf(“%d”,++a);

    else printf(“%d”,--a);

    }

    A、58B、5858C、5859D、5857

    3、以下的for循环是( )。

    for(x=0,y=0; y!=123&&(x<4); x++);

    A、是无限循环B、循环次数不定C、执行4次D、执行3次

    4、设有数组定义: char array[ ]=“China”; 则数组array所占的空间为A、 4个字节 B、 5个字节 C、 6个字节 D、 7个字节B、A[3.5]C、a(5) D、a[10-10]

    6、有如下程序,该程序的输出结果是( )。

    main()

    {

    int n[5]={0,0,0},i,k=2;

    for(i=0; i

    n[i]=n[i]+1;

    printf(“%d\n”,n[k]);

    }

    A、不确定的值 B、2    C、1D、0

    7、对以下说明语句的正确理解是( )

    int a[10]={6,7,8,9,10};

    A、将5个初值依次赋给a[1]至a[5] B、将5个初值依次赋给a[0]至a[4]

    C、将5个初值依次赋给a[6]至a[10] D、此语句不正确

    8、以下程序的输出结果是include

    int f(int n)

    {

    return n+1;

    }

    main()

    {

    int i,j=0;

    for(i=1;i<3;i++)

    j+=f(i);

    printf(“%d\n”,j);

    }

    A、 3B、 4C、 5 D、6

    9、C语言中函数返回值类型由( )决定。

    A、 return语句中的表达式类型

    B、 定义函数时所指明的返回值类型

    C、 实参类型

    D、 调用函数类型

    10、华氏温度和摄氏温度的关系是: C=。已知:float C,F;由华氏求摄氏的正确的赋值表达式是____。

    A 、C=5/9(F-32) B、 C=5*(F-32)/9

    C、 C=5/9*(F-32) D、以上三个表达式都正确

    得 分二、程序填空题(每空2分,共20分)

    以下程序的功能是:任意输入一个整数m,判断是否是素数。

    说明:素数就是只能被1和它自己整除的数。

    #include

    main()

    {

    int m,i;

    ____________;

    for(i=2; i

    if( ) break;

    if(_____________)

    printf(“%d is a prime number\n ”,m);

    else printf(“%d is not a prime number\n”,m);

    }

    2、以下程序的功能是:编程求算式xyz+yzz=542中x、y、z的值(其中xyz和yzz分别表示一个三位数)。

    #include

    main()

    {

    int x,y,z,i,result=542;

    for(x=1;x<10;x++)

    for(y=1;y<10;y++)

    for( ;z<10;z++)

    {

    i=100*x+10*y+z+100*y+10*z+z;

    if( )

    printf("x=%d,y=%d,z=%d\n",x,y,z);

    }

    }

    3、以下程序的功能是:从键盘输入5个整数,找出最大数和最小数所在的位置,并把两者对调,然后输出调整后的5个数。

    #include

    main()

    {

    int a[5],max,min,

    展开全文
  • C语言非阻塞式键盘监听

    万次阅读 多人点赞 2016-05-09 23:11:27
    监听键盘可以使用C语言的字符输入函数,例如 getchar、getch、getche 等,我们会在《结合缓冲区谈谈C语言getchar()、getche()、getch()的区别》一节中重点讲解它们的区别。 使用getche函数监听键盘的例子: ...
    监听键盘可以使用C语言的字符输入函数,例如 getchar、getch、getche 等,我们会在《结合缓冲区谈谈C语言getchar()、getche()、getch()的区别》一节中重点讲解它们的区别。

    使用getche函数监听键盘的例子:
    1. #include <stdio.h>
    2. #include <conio.h>
    3. int main(){
    4. char ch;
    5. int i = 0;
    6. //循环监听,直到按Esc键退出
    7. while(ch = getch()){
    8. if(ch == 27){
    9. break;
    10. }else{
    11. printf("Number: %d\n", ++i);
    12. }
    13. }
    14. return 0;
    15. }
    运行结果:
    Number: 1  //按下任意键
    Number: 2  //按下任意键
    Number: 3
    Number: 4
    Number: 5  //按下Esc键

    这段代码虽然达到了监听键盘的目的,但是每次都必须按下一个键才能执行getch后面的代码,也就是说,getch后面的代码被阻塞了。

    阻塞式键盘监听非常不方便,尤其是在游戏中,往往意味着用户要不停按键游戏才能进行,所以一般采用非阻塞式键盘监听。

    使用conio.h头文件中的kbhit函数可以实现非阻塞式键盘监听。

    我们每按下一个键,都会将对应的字符放到键盘缓冲区,kbhit 函数会检测缓冲区中是否有字符,如果有字符返回非0值,没有返回0。但是kbhit不会读取字符,字符仍然留在缓冲区。请看下面的例子:
    1. #include <stdio.h>
    2. #include <windows.h>
    3. #include <conio.h>
    4. int main(){
    5. char ch;
    6. int i = 0;
    7. //循环监听,直到按Esc键退出
    8. while(1){
    9. if(kbhit()){
    10. ch = getch();
    11. if(ch == 27){
    12. break;
    13. }
    14. }
    15. printf("Number: %d\n", ++i);
    16. Sleep(1000); //暂停1秒
    17. }
    18. return 0;
    19. }
    运行结果:
    Number: 1
    Number: 2
    Number: 3
    Number: 4
    Number: 5  //按下Esc键

    每次循环,kbhit 会检测用户是否按下某个键(也就是检测缓冲区中是否有字符),没有的话继续执行后面的语句,有的话就通过 getch 读取,并判断是否是 Esc,是的话就退出循环,否则继续循环。

    kbhit 之所以能够实现非阻塞式监听是因为它只检测字符,而不要求输入字符。

    Sleep 是“睡眠”的意思,用来让程序暂停执行一段时间,以毫秒记。
    展开全文
  • c语言非递归实现迷宫

    千次阅读 2018-07-27 12:15:27
    此题可以使用栈来避开递归,首先需要开辟一个和迷宫具有同样几何形状的结构体二维数组来保存是从哪一个点(坐标)到达该点的(该初始化时将所有的坐标都置为0),还需要一个可以保存坐标的栈。每次将能够走通的点...

     此题可以使用栈来避开递归,首先需要开辟一个和迷宫具有同样几何形状的结构体二维数组来保存是从哪一个点(坐标)到达该点的(该初始化时将所有的坐标都置为0),还需要一个可以保存坐标的栈。每次将能够走通的点(值为1)都入栈然后在循环的开始处将栈顶元素弹出保存进temp变量(保存坐标的变量)中,访问temp变量四周的元素是否可以被访问,如果可以被访问(值为0)则将对应路径数组中的元素(即对应坐标)值改为temp变量的值并将该能被访问的变量入栈,再将迷宫中的0(能访问)更改为2(已被访问过)防止重复访问。最后从路径数组中的出口处开始倒序输出所走路径即可。

      在此种思想中栈保存了所有可以走通的点,当一个点的四周都不能够走通时弹出的该点坐标程序并没有进行任何实质性的处理,所以这就相当于一个“回溯”的过程。而访问四周的点的过程就是一个枚举的过程。

    stack.h

    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    #include<windows.h>
    #include <assert.h>
    typedef struct Pos
    {
        int _col;
        int _row;
    }Pos;
    typedef int Datatype;
    typedef struct Stack
    {
        Pos *_mz;
        size_t _size;
        size_t _capacity;
    }Stack;
    
    void StackInit(Stack** ps, size_t capacity)
    {
        assert(*ps);
        (*ps)->_size = 0;
        (*ps)->_capacity = capacity;
        (*ps)->_mz = (Pos *)malloc(sizeof(Pos)*(*ps)->_capacity);
        return;
    }
    Pos StackTop(Stack *s)
    {
        return s->_mz[s->_size - 1];
    }
    void StackPush(Stack **pps, Pos *x)
    {
        assert(pps);
        assert(*pps);
        if ((*pps)->_size == (*pps)->_capacity)
        {
            (*pps)->_capacity *= 2;
            (*pps)->_mz = (Pos*)realloc((*pps)->_mz, (sizeof(Pos))*(*pps)->_capacity);
        }
        assert(*pps);
        ((*pps)->_mz[(*pps)->_size])._col = x->_col;
        ((*pps)->_mz[(*pps)->_size])._row = x->_row;
        (*pps)->_size++;
    }
    Pos *StackPop(Stack *ps)
    {
        return ps->_mz + (--ps->_size);
    }
    int StackEmpty(Stack *ps)
    {
        assert(ps);
        return ps->_size;
    }
    void StackPrint(Stack *ps)
    {
        int i = 0;
        for (i = ps->_size - 1; i >= 0; i--)
            printf("(%d,%d)->", ps->_mz[i]._col + 1, ps->_mz[i]._row + 1);
        printf("\n");
    }

    test.c

    #include"maze.h"
    int main()
    {
        //Datatype arr[N][N] = {
        //  { 0,0,0,0,0,0,0 },
        //  { 0,0,0,1,1,1,1 },
        //  { 0,0,0,1,0,1,0 },
        //  { 0,0,0,1,0,1,0 },
        //  { 0,0,0,1,1,1,1 },
        //  { 0,0,0,1,0,0,0 },
        //  { 0,0,0,1,0,0,0 },
        //};
        Datatype arr[N][N] = {
            { 0,0,0,0,0,0 },
        { 0,0,1,1,1,1 },
        { 0,0,1,0,1,0 },
        { 0,0,1,0,1,0 },
        { 0,0,1,1,1,1 },
        { 0,0,1,0,0,0 },
        };
        Maze *maze = (Maze*)malloc(sizeof(Maze));
        memset(maze, 0, sizeof(Maze));
        MazeInit(&maze, arr);
        MazePrint(maze);
        MazeGetShortPath(maze);
        system("pause");
        return 0;
    }

    maze.h

    #pragma once
    #include"Stack.h"
    #define N  6
    typedef struct Maze
    {
        Datatype  _mz[N][N];
        Pos *_entry;
    }Maze;
    void MazeInit(Maze **pmaze, Datatype a[N][N])
    {
        int i = 0, j = 0;
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                (*pmaze)->_mz[i][j] = a[i][j];
            }
        }
    
        (*pmaze)->_entry = (Pos*)malloc(sizeof(Pos));
        (*pmaze)->_entry->_col = 5;
        (*pmaze)->_entry->_row = 2;
    }
    void MazePrint(Maze *pmaze) {
        int i = 0, j = 0;
        for (i = 0; i < N; i++)
        {
            for (j = 0; j < N; j++)
            {
                printf("%3d", pmaze->_mz[i][j]);
            }
            printf("\n");
        }
        printf("\n");
    }
    int MazeCheckIsAccess(Maze *pmaze, Pos* pos)
    {
        if (pos->_col >= 0 && pos->_col < N && pos->_row >= 0 && pos->_row < N)
        {
            if (pmaze->_mz[pos->_col][pos->_row] == 1)
                return 1;
        }
        return 0;
    }
    //没有因为找到出口结束,而是等栈为空结束。
    int MazeGetPath(Maze *pmaze)
    {
        Pos *cur  = pmaze->_entry;
        Pos *next = (Pos*)malloc(sizeof(Pos));
        Stack *path = (Stack *)malloc(sizeof(Stack));
        StackInit(&path, 10);
        StackPush(&path, cur);
        int flag = 0;
        while (StackEmpty(path) != 0)
        {
            (*cur) = StackTop(path);
            StackPop(path);
            pmaze->_mz[cur->_col][cur->_row] = 2;
            if (cur->_row == N - 1)
            {
                flag = 1;
                printf("找到了\n");
                MazePrint(pmaze);
            }
            {
                /*下*/
                next->_col = cur->_col + 1;
                next->_row = cur->_row;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    StackPush(&path, next);
                }
                //上
                next->_col = cur->_col - 1;
                next->_row = cur->_row;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    StackPush(&path, next);
                }
                //左
                next->_col = cur->_col;
                next->_row = cur->_row - 1;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    StackPush(&path, next);
                }
                //右
                next->_col = cur->_col;
                next->_row = cur->_row + 1;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    StackPush(&path, next);
                }
            }
        }
        if (flag == 0)
            printf("没有出口\n");
        free(next);
        return 1;
    }
    
    int MazeCheckIsShortAccess(Maze *pmaze, Pos* pos, Pos* next)
    {
        if (next->_col >= 0 && next->_col < N && next->_row >= 0 && next->_row < N)
        {
            if ((pmaze->_mz[next->_col][next->_row] == 1) || pmaze->_mz[next->_col][next->_row]>pmaze->_mz[pos->_col][pos->_row])
                return 1;
        }
        return 0;
    }
    void StackShortPath(Maze *pmaze, Stack *path)
    {
        int i = 0, j = N - 1;
        int shortcount = N * N;
        Pos cur;
        for (i = 0; i < N; i++)
        {
            if (pmaze->_mz[i][j] != 0 && pmaze->_mz[i][j] < shortcount)
            {
                shortcount = pmaze->_mz[i][j];
                cur._col = i;
                cur._row = j;
            }
        }
        printf("the short path size is:%3d\n", shortcount - 1);
        printf("the short path out is:(%d,%d)\n", cur._col + 1, cur._row + 1);
        Pos *next = (Pos*)malloc(sizeof(Pos));
        StackPush(&path, &cur);
        while (cur._col != pmaze->_entry->_col || cur._row != pmaze->_entry->_row)
        {
            cur = StackTop(path);
            {
                /*下*/
                next->_col = cur._col + 1;
                next->_row = cur._row;
                if (pmaze->_mz[next->_col][next->_row] == pmaze->_mz[cur._col][cur._row] - 1)
                {
                    StackPush(&path, next);
                }
                //上
                next->_col = cur._col - 1;
                next->_row = cur._row;
                if (pmaze->_mz[next->_col][next->_row] == pmaze->_mz[cur._col][cur._row] - 1)
                {
                    StackPush(&path, next);
                }
                //左
                next->_col = cur._col;
                next->_row = cur._row - 1;
                if (pmaze->_mz[next->_col][next->_row] == pmaze->_mz[cur._col][cur._row] - 1)
                {
                    StackPush(&path, next);
                }
                //右
                next->_col = cur._col;
                next->_row = cur._row + 1;
                if (pmaze->_mz[next->_col][next->_row] == pmaze->_mz[cur._col][cur._row] - 1)
                {
                    StackPush(&path, next);
                }
            }
        }
        StackPrint(path);
    }
    void MazeGetShortPath(Maze *pmaze)
    {
        Pos cur = *pmaze->_entry;
        Pos *next = (Pos*)malloc(sizeof(Pos));
        Stack *path = (Stack *)malloc(sizeof(Stack));
        StackInit(&path, 10);
        Stack *shortpath = (Stack *)malloc(sizeof(Stack));
        StackInit(&shortpath, 10);
        StackPush(&path, &cur);
        pmaze->_mz[cur._col][cur._row] = 2;
        int flag = 0;
        while (StackEmpty(path) != 0)
        {
            if (cur._row == N - 1)
            {
                MazePrint(pmaze);
                printf("找到了\n");
                flag = 1;
            }
            cur = StackTop(path);
            StackPop(path);
    
            {
                /*下*/
                next->_col = cur._col + 1;
                next->_row = cur._row;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    pmaze->_mz[next->_col][next->_row] = pmaze->_mz[cur._col][cur._row] + 1;
                    StackPush(&path, next);
                }
                //上
                next->_col = cur._col - 1;
                next->_row = cur._row;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    pmaze->_mz[next->_col][next->_row] = pmaze->_mz[cur._col][cur._row] + 1;
                    StackPush(&path, next);
                }
                //左
                next->_col = cur._col;
                next->_row = cur._row - 1;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    pmaze->_mz[next->_col][next->_row] = pmaze->_mz[cur._col][cur._row] + 1;
                    StackPush(&path, next);
                }
                //右
                next->_col = cur._col;
                next->_row = cur._row + 1;
                if (MazeCheckIsAccess(pmaze, next))
                {
                    pmaze->_mz[next->_col][next->_row] = pmaze->_mz[cur._col][cur._row] + 1;
                    StackPush(&path, next);
                }
            }
        }
        free(next);
        if (flag == 0)
        {
            printf("没有出口\n");
        }
        else {
            StackShortPath(pmaze, shortpath);
        }
        return;
    }

    这里写图片描述“`

    展开全文
  • 实验三 线性方程求根专业班级: 姓名: 学号:一、实验目的熟悉C语言编程;学习线性方程求根的方法及程序设计算法二、实验题目迭代函数对收敛性的影响用迭代法求方程的根f(x) 2x3 0x 1方案1:化方程为等价方程 x...

    实验三 非线性方程求根

    专业班级: 姓名: 学号:

    一、实验目的

    熟悉C语言编程;

    学习非线性方程求根的方法及程序设计算法

    二、实验题目

    迭代函数对收敛性的影响

    用迭代法求方程的根f(x) 2x3 0

    x 1方案1:化方程为等价方程 x ( x ) 2

    取初值x0 0 ,迭代10次。

    3x 2x 1 (x) 方案2:化 f ( x ) 0 为等价方程

    取初值x0 0 ,迭代10次,观察其计算值,并加以分析。

    初值的选取对迭代法的影响

    3x x 1 0在x 1.5附近的根。 用牛顿法求方程

    方案1:使用牛顿法并取x0 1.5,由xk 1f(xk) xk f (xk)得

    xk 13xk xk 1 xk 23xk 1迭代10次

    方案2:取x0 0,使用同样的公式

    xk 13xk xk 1 xk 23xk 1迭代10次,观察比较并分析原因。

    收敛性与收敛速度的比较

    求方 63 10f(x) x sinx 12x 1 程 的全部实根,

    方案1:用牛顿法求解;

    方案2:用简单迭代法;

    取相同迭代初值,比较各方法的收敛速度。

    三、实验原理与理论基础

    迭代法原理

    将非线性方程 f (x) = 0 化为一个同解方程 x (x)并且假设 (x)为连续函数 任取一个初值x0,代入右端,得

    x1 (x0)x2 (x1)xk 1 (xk)(k 0,1,2, ) ```

    称 x k 1 (x k)为求解非线性方程 x (x ) 的简单迭代法.

    展开全文
  • 初来乍到,多多指正!... int a = 1, b = 0, c = 1, i = 0, n = 0, sum = 0;//a是前一项,b是后一项 printf("请输入第几项:"); scanf_s("%d", &n); while (i < n) { c = a + b; a = b; b...
  • C语言种if只区分0与非0

    千次阅读 2019-05-27 00:01:51
    =0,那么if(t){}不会执行,今天才发现if把0当作flase,其它全为true。 int main(){ if(-1){ printf("1"); } if(0){ printf("2"); } if(1){ printf("3"); } if(!(-1)){ printf("4"); } if(!0){ ...
  • C语言--位运算符一、位运算符1.按位与:&1> 功能* 只有对应的两个二进制位为1时,结果位才为1,否则为0* 举例:10用二进制表示为1010, 7用二进制表示为0111。对两个数值进行&运算* 10100111------------...
  • 一,递归方式实现一个字符串”abcdefg”逆转. 我们可以按照如下步骤进行: 1,求出这个字符串的长度 2,两个索引 i和j, 初始值i为0,j为字符长度减1 3,然后将两个索引位置的字符交换,然后i加1,j减1. 4,如果i小于j...
  • 巳知线性表LA和线性表LB中的数据元素按值递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的元素仍按值递减有序排列。 输入 三行,第一行A,B集合的个数n,m 第二行:集合A的数据; 第三行:集合B的...
  • 给定 N 个 0 的个位数字,用其中任意 2 个数字都可以组合成 1 个 2 位的数字。要求所有可能组合出来的 2 位数字的和。例如给定 2、5、8,则可以组合出:25、28、52、58、82、85,它们的和为330。 输入格式: 输入...
  • 典型性C语言教程-0

    千次阅读 2007-04-27 21:06:00
    典型性C语言教程-0起因 自从实验室里面配备了Sun公司赞助的Ultra 20工作站之后,老师就不时的要求我给实验室的兄弟姐妹讲Solaris的使用和管理。我发现好多学生对C语言——传说中和Unix一起诞生,为了编写Unix而被...
  • 如果直接输出阶乘再求最后零数,阶乘过大,会出现溢出的情况,因此在每次求阶乘的时候会把数截取掉,然后在缩放 #include <stdio.h> #include <math.h> int main(){ int i,n,sum=1; scanf("%d",&...
  • 逻辑 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 操作符 作用 ————————————————————————————— > ...
  • 0\数据类型基本类型:整型:int短整型long 长整型实型(浮点型): 单精度FLOAT双精度DOUBLE指针构造: 数组、结构、联合、枚举空类型 void1\输入输出输入输出在C语言文件头#include 或者 #include"stdio.h"C语言提供的...
  • c语言简单实现循环单链表 # include <stdio.h> # include <malloc.h> # include <stdlib.h> //定义链表的节点 typedef struct Node { int data; //数据域 struct Node *pNext; //指针域 }...
  • 满意答案yingdie00532014.02.03采纳率:44%等级:12已帮助:6620人#include "stdio.h"int cishu=0;int compare(int x,int y){cishu++;if(xelse if(x==y) return 0;else return 1;}int binary(int a[],int left,int ...
  • C语言中,在有些结构体里面,会出现一个“0长度数组”的定义,例如: typedef struct tag_test {  int a;  int buf_len;  char p[0]; }test_s; 从对数组的定义上,上面的结构基本等同于如下的结构: ...
  • 现在po一下C语言版本的,留作以后接口使用. 1 #include 2 #include 3 4 #define HEAP_SIZE 100 5 #define HEAP_FULL_VALUE -100 6 7 #if 0 8 /*小顶堆存储结构*/ 9 typedef struct small_heap ...
  • #include<stdio.h> #include<stdlib.h> double fx(double x, double y) { return(y - 2 * x / y); } ...double x0, y0, h; int N; printf("请输入x0,y0,h,N:"); scanf_s("%lf%lf%...
  • 学霸的迷宫 题目描述 学霸抢走了大家的作业,班长为了帮同学们找回作业,决定去找学霸决斗。...接下来n行,每行m个数,数之间没有间隔,为0或1中的一个。0表示这个格子可以通过,1表示不可以。假设你现在已
  • C语言逻辑运算符的含义

    千次阅读 2015-10-13 00:05:12
    为逻辑. 逻辑(!x)的结果有2种 : TRUE(1), FALSE(0) 逻辑的等价式 !x = (x == 0) 例子: #include "stdafx.h" #include int _tmain(int argc, _TCHAR* argv[]) { int x=3; int iTemp = 0; do { printf...
  • #define ERROR 0 #define OVERFLOW -1 typedef char TElemType; typedef struct BiTNode{ TElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; typedef int Status; typedef struct LNode{ ...
  • #include ...#define OVERFLOW 0 #define ERROR -1 #define OK 1 #define FALSE 0 #define TRUE 1 typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; LNode *next; }L
  • C语言

    2019-09-27 11:55:37
    1. 赋值表达式的值就是其左侧到值。 如 a=1 这个表达式到值就是a的值 ...4. scanf 得到正确的输入值,返回1,否则返回0 5. 关系运算符到优先级低于+ - * /在内的算术运算符,但高于赋值运算符5. 关系...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,314
精华内容 1,325
关键字:

c语言非0

c语言 订阅