#C语言基础 笔记一

Linux命令

终端

打开终端之后里面有一行内容   hq @ Ubuntu : ~/demo $

hq：用户名         

@：(没什么用)       

Ubuntu：主机名     

: (没什么用) 

~/demo：当前目录

~：家目录   

$：命令提示符

查看用户名：whoami

查看主机名：hostname

查看当前路径：pwd(绝对路径)

打开终端

1.直接点击

2.ctrl shift n：当前路径    注意：一定要有一个终端是打开的状态

3.ctrl alt t：家目录

关闭终端

1.直接点击

2.ctrl d

3.exit

查看

ls -a：查看当前路径下的所有文件包括隐藏文件 (前面是点开头的是隐藏文件)

ls -l ：查看当前文件的详细信息

d                rwxrwxr-x     9             hq        hq    4096   3月 18 16:19                demo

文件类型   权限              连接数    用户名 组名 大小    最后一次修改的时间    文件名

rwxrwxr-x  （用户、组用户、其他用户）

文件类型

dcb-lsp

d：目录

c：字符设备文件 sudo cat /dev/input/mouse (/设备文件/输入文件/输入里面mouse)

b：块设备文件

-：普通文件

l：软连接

s：套接字文件

p：管道文件

文件权限

三个三个一组

r：读

w：写

x：可执行

-：不可以

表示不可读就放一个 - 其他也是一样的，通过这个权限我们也可以得到它的权限值，这个权限值是多少：rwxrwxr-x (775)   111 111 101

修改权限：chmod 权限值 文件名

切换

cd 路径(分为绝对路径和相对路径)

绝对路径从跟目录索引

相对路径从当前路径索引

.     当前路径

..    上一级

cd ..   返回上一级

cd -    返回上一次路径

cd ~   返回家目录 cd cd /home/hq

文件系统结构

》》

新建

新建文件：

touch 文件名.后缀

touch 同名文件：会更新时间戳

新建目录：

mkdir 目录名

mkdir 同名目录：报错 会告诉你已经存在

mkdir -p 24031/day1/linux 创建多级目录

删除

rm 普通文件名 (可以用 tab 补齐文件名)

rm -r 目录名

复制

cp 普通文件名 目标路径  (可以在文件名前面加路径找到文件名 放到逆向复制的位置的路径)

cp -r 目录名 目标路径

另存为：cp 文件名 路径/新文件名

移动

mv 普通文件或者目录名 目标路径

重命名：mv 普通文件或者目录名 ./新的名字

常用的快捷键

补齐：tab

放大终端：ctrl shift +

缩小： ctrl -

历史命令：上下键 (上一个或下一个命令)

清屏：ctrl l 或者 clear

vi编辑器

打开文件：vi 文件名

命令行模式：

编辑模式(插入模式)：

底行模式：

命令行模式

复制：yy 复制很多行：nyy (n：行数)

剪切：dd 剪切很多行：ndd

粘贴：p

撤销：u

反撤销：ctrl r

删除光标后面的字符：x

删除光标前面的字符：X

光标移动到首行：gg

光标移动到末行：G

光标移动到行首：0

光标移动到行尾：$

整理代码格式：gg = G

插入模式

实现代码编辑功能

a：从光标所在位置的下一个字符键入

A：从光标所在行行尾键入

i：从光标所在位置的前一个字符键入

I：从光标所在行行首键入

o：从光标所在行下面另起一行键入

O：从光标所在行上面另起一行键入

底行模式

指定行复制：5, 10y 复制 5 - 10 行

指定行删除：5, 10d 删除 5 - 10 行

保存：w

退出：q

保存并退出：wq

强制：! (w!、q!、wq!)

替换：s/str1/str2 光标所在行第一个str1替换成 str2

s/str1/str2/g 光标所在行所有str1替换成 str2

替换全文：%s/str1/str2/g

取消行号：set nonu

设置行号：set nu

查找：/str

取消高亮：search nohl

简单的编程步骤

1.创建一个 .c 文件 touch hello.c

2.打开文件 vi hello.c

3.写代码：

#include <stdio.h>  // 头文件
int main()  // 主函数   int ：函数类型
{
	printf("hello world!\n");  // 打印语句   \n ：换行
	return 0;  // 函数返回值
}

4.保存并退出：wq

5.编译代码：gcc hello.c

6.执行可执行文件 ./a.out

练习：

编写一个c程序输出  Welcome to the game

建立test1、test2文件夹;在test1文件夹中建立1.txt文件，在1.txt中写上50行“hello farsight!”,复制1.txt成为2.txt，并把2.txt中所有的“farsight”改成“world”;移动test1文件夹到test2文件夹下;删除test1

编程语言发展历程

机器语言：010101110001

汇编语言：范围不是很广，相当于面向机器的语言，就是对这个机器适用，但是不代表放到其他地方也适用

高级语言：c java c++

gcc 编译器

1) 预处理

展开头文件、删除注释、替换宏定义，不检查语法错误

gcc -E xxx.c -o xxx.i

2) 编译

检查语法错误，没有问题会转成汇编语言，生成汇编文件

gcc -S xxx.i -o xxx.s

3) 汇编

将汇编文件转换成二进制文件

gcc -c xxx.s -o xxx.o

4) 链接

链接库文件，最终生成机器能够识别的可执行文件

gcc xxx.o -o xxx

./xxx 执行

gcc hello.c -o hello // 将 hello.c 直接生成一个可执行文件

计算机存储单位

单位的转换 位(bit)、字节(Byte)

1字节 = 8位

1KB = 1024B    1MB = 1024KB     1GB = 1024MB     1T = 1024G

计算机的数据表示形式

数值型数据 和 非数值型数据

数值型数据

数值型数据就是你能够进行算术运算的并且得到一些明确的数值概念的一些数据，比如进制这些数据

二进制<BIN>  ：0 - 1 (逢二进一) 

八进制<OCT>：0 - 7 (逢八进一) 

十进制<DEC>：0 - 9 

十六进制<HEX>：0-9、a-f 

进制转换：

十进制转二进制：

1. 短除法：除2倒取余

2. 拆分法：拆成2的几次方和

3. 计算器：程序员模式

二进制转十进制：

2的次方和，从右向左从0开始依次增加(把所有1的位加起来)

101100 = 0+4+8+32 = 44

除2倒取余

拆分法：拆成2的几次方和

2的次方和，从右向左从0开始依次增加(把所有1的位加起来)

101100=4+8+32=44

八进制转二进制：

一位8进制用3位二进制表示，以数字0开头 (可以使用421码) 100 010 001 

二进制转八进制：

从低位开始，3个二进制为一组便是一位8进制，不够补零

100100 = 044

1011010011 = 001-011-010-011 = 01323

031 011 001

0756 111 101 001

11010 032

01011011 001 011 011 0133

十六进制转二进制：

一位16进制用4位二进制表示，以数字0x开头 (可以使用8421码)1000 0100 0010 0001

0xab = 1010 1011

0x3ce = 0011 1100 1110

二进制转十六进制：

从低位开始，4位二进制为一组便是一位16进制，不够补零

1100101110 = 0011 - 0010 - 1110 = 0x32e

0xAB 1010 1011

0x3CE 0011 1100 1110

1010 1001 0111 0xA97

0101 1101 0011 0x5D3

// 将下面的内容都转成二进制
389  056  0xac12

110000101
101 110
1010 1100 0001 0010

// 将下面的二进制内容分别转换成八进制、十进制、十六进制
101010110101
八进制：05265
十进制：2741
十六进制：0xab5

非数值型数据

非数值型数据就是 ascii码    在虚拟机终端中输入 man ascii

\0  ascii码是 0          一般作为字符串的结束的标志

\n 10 一般表示换行

空格(SPACE) 32

字符0  48

字符9  57

A 65

Z 90

a 97

z 122

用字符0减去 48 就是我们想要的数字

对应的字符0-9 减去48 就是我们想要的数字0-9

字符0       - 48 ==> 数字0

大写字母 + 32 ==> 小写字母

小写字母 - 32 ==> 大写字母

查看 man 手册 共9章 ：man man

1 shell命令

2 系统调用函数

3 库函数

退出man手册：q

词法符号

词法符号就是你在程序设置的时候在里面规定的一些由几个字符组成的一些简单的有意义的最小的语法单位

关键字 运算符 标识符 标点符号 分隔符

标点符号：

, ; () [] {}

分隔符：

换行 空格 tab

关键字：

概念：由系统预定义(提前定义好的)的具有特殊功能的词法符号(32 个需要记住，要会写)

分类：

存储类型：auto(自动)、static(静态)、extern(外部引用)、register

数据类型：char(字符型)、short(短整型)、float(单精度浮点型)、int(整型)、double(双精度浮点型)、long(长整型) { signed(有符号)、unsigned(无符号) }

构造类型：struct(结构体)、union(共用体)、enum(枚举)

选择结构：if else switch case default

循环结构：for while goto do { break continue }(循环控制语句)

其他(其他功能)：void(空类型)、typedef(重定义)、const(常量化、是只读的)、

sizeof(计算数据所占空间大小)、volatile(防止编译器优化)、return(函数返回值)

typedef int datatype;

int a; == datatype a;

标识符：

命名规则：

1. 由数字、字母、下划线组成

2. 开头不能是数字

3. 不能和关键字重复

练习： x y sum a100 _A7b_3x 3’a x*y @ b.8 while

运算符

算数运算符

逻辑运算符

位运算符

关系运算符

赋值运算符

三目运算符

算数运算符：

+ - * / % ++ --

/  ：整数相除，向下取整

当你除号两边都是整数的时候，得到的也会是一个整数

%：取余只用于整数运算

10 % 3 = 1;

练习：将 12345 的个十百千万位分别输出到终端

++:

如果把它当做一个表达式来算的话，你要根据这个自加和自减的位置来判断先后运算的顺序，位置不一样先后顺序不一样.（-- 同理)

赋值语句：

int a = 3;

1) int b = a++; // 3 // ++在后，先赋值，在自加

2) int b = ++a; // 4 // ++在前，先自加，在赋值

练习:

int main()

{

int a =10;

int b = a--;// b=10 a=9

int c = a + b;// c=19

int d =(a++)+ c;// d=9+19=28 a=10

printf("%d\n", d);//

}

#include <stdio.h>

int main(int argc,char*argv[])

{

int a =10;

int b =++a;//

int c = a +(b++);//

int d = b + c;//

int e =(d++)-(--c);//

printf("%d\n", e);

}

include <stdio.h>

int main(int argc,char*argv[])

{

int a =10;

int b =++a;// b = 11 a = 11

int c = a +(b++);// c = 22 b = 12

int d = b + c;// d = 34

int e =(d++)-(--c);// 34 - 21

printf("%d\n", e);// e = 13

}

打印语句：

**** printf 从右向左 ****

int a = 3;

1) printf("%d\n", a++); // 3 // ++在后，先打印在自加

2) printf("%d\n", ++a); // 4 // ++在前，先自加在打印

独立成句：

int a = 3;

1) a++; 都相当于给a赋一个值a = a+1;

        printf("%d\n", a); // 4

2) ++a;

        printf("%d\n", a); // 4

练习：

int main()
{
    int a = 10;
    int b = a--;  // b = 10, a =9
    int c = a + b;  // c = 19
    int d = (a++) + c;  // a = 10
    printf("%d\n", d);  // d = 28
}

#include <stdio.h>

int main(int argc, char *argv[])
{
    int a = 10;
    int b = ++a;  // b = 11 a = 11
    int c = a + (b++); // c = 22 b = 12
    int d = b + c; // d = 34
    int e = (d++) - (--c);  // 34 - 21
    printf("%d\n", e);  // e = 13
}

逻辑运算符：

&&(与) ||(或) !(非)，也就是看你这个逻辑表达式是真的还是假的

逻辑与：&&

全真则真，一假则假

逻辑或：||

一真则真，全假则假

逻辑非：！

一真则真，全假则假

截断法则

● 在逻辑与运算中：如果前面的表达式为假，则后面的表达式不执行

● 在逻辑或运算中：如果前面的表达式为真，则后面的表达式不执行

逻辑与的截断法则：
    int a = 3, b = 4, c = 5, d = 6, m = 2, n = 2;
    (m = a > b) && (n = c > d);
    printf("%d %d\n", m, n); // 0 2
逻辑或的截断法则：
    int a = 3, b = 4, c = 5, d = 6, m = 2, n = 2;
    (m = a < b) || (n = c > d);
    printf("%d %d\n", m, n); // 1 2

位运算符：

位运算的位指的是二进制里的每一位，指的是 0 和 1，没有真假，因为他不是一个逻辑上的判断真假，而是让你去计算0和1通过这些位运算符算出来的结果到底是什么，按位进行操作

&(位与)        |(位或)       ^(异或)         ~(取反)           <<(左移)          >>(右移)

	原码	反码	反码
正数	本身	本身	本身
负数	本身	除符号位按位取反	反码 +1

很多数据都会以补码的形式存储在机器里面
以补码的形式存放在寄存器中
所以单片机读取出来的数据呢
也是以补码形式的数据
所以要将补码转换成原码
CPU里面有加法器
很可惜是没有解法器的

位与：& 

全1则1，有0则0

8 & 10 = 0000 1000 = 8

8：0000 1000

10: 0000 1010

-8 & 10 = 8

-8原码：1000 1000

-8反码：1111 0111

-8补码：1111 0111 + 0000 0001 = 1111 1000

10三码：0000 1010

-8补码：1111 1000

&

10 补码：0000 1010

=

0000 1000 = 8

35 原码0010 0011 反码补码

47 原码0010 1111 反码补码

35+47=0010 0011

位或 ：| 

有1则1，全0则0

8 | 10=

0000 1000

0000 1010 0000 1010=10

异或 :  ^

不同为1，相同为0

8^10

0000 1000

0000 1010 00000010=2

取反：~

按位取反 0-1

~15 = -16

15原码：0000 1111

反码：0000 1111

补码：0000 1111

~：1111 0000

-1得到反码：1110 1111

除符号位按位取反：1001 0000 即-16

~-14 = 13

-14 原码：1000 1110

反码：1111 0001

补码：1111 0010

~：0000 1101

左移：<<

左移几位，右面补几个零

8 << 2 = 32 (公式：n << m = n * 2m)

8<<2=32

原码0000 1000 左移 0010 0000

右移：>>

右移几位，左边补几个符号位(0-1)

-13 >> 1 = -7 (公式：n >> m = n / 2m)

-13>>1=

原码1000 1101 反码1111 0010 补码1111 0011

右移1111 1001 反码1000 0110 补码1000 0111即-7

置一公式：a  |  (1<<n)    

置零公式：a & (~(1<<n))

<question>​​​​​​​

关系运算符：

关系运算符就是用来比较他们的大小的

> < >= <= == !=

1<x<5(这种形式是不允许出现的) => x > 1 && x < 5

赋值运算符：

= += -= *= /=

a += 3; => a = a + 3;

三目运算符：

条件运算符

表达式1 ? 表达式2 : 表达式3

运算法则：先判断表达式1是否成立，如果成立就执行表达式2，否则就执行表达式3

int a = 3, b = 5;
int c = a > b ? a++ : ++b; // ==>  int c = ++b;
printf("%d\n", c);  // 6

运算符优先级

关于运算符优先级的口诀：（从高到低）  ​​​​​​​<question>

口诀： 单算移关与 异或逻条赋    从右向左单条赋

• 单元运算符（最高优先级）

  • ++、--（后缀形式）
  • +、-（正负号）
  • !、~（逻辑非、按位取反）
  • sizeof、&、*（sizeof操作符、地址运算符、指针解引用）
  • (type)（类型转换）

• 算术运算符

  • *、/、%（乘法、除法、取模）
  • +、-（加法、减法）

• 移位运算符

  • <<、>>（左移、右移）

• 关系运算符

  • >、<、>=、<=（大于、小于、大于等于、小于等于）

• 相等性运算符

  • ==、!=（等于、不等于）

• 按位与运算符

  • &

• 按位异或运算符

  • ^

• 按位或运算符

  • |

• 逻辑与运算符

  • &&

• 逻辑或运算符

  • ||

• 条件运算符

  • ?:

• 赋值运算符

  • =
  • +=、-=、*=、/=、%=、&=、^=、|=、<<=、>>=（复合赋值运算符）

• 逗号运算符（最低优先级）

  • ,

练习：

1. sizeof关键字的作用？(深圳元征信息科技)

计算数据所占内存大小，以字节为单位

2. 下面四个选项中，均是C语言关键字的是；(B ) (鲁科安全)

A. auto enum include B. switch typedef continue

B. signed union scanf D. if struct type

3. C语言中的标识符只能由字母，数字和下划线三种字符组成，且第一个字符：_C_ (智洋)

A. 必须为字母 B. 必须为下划线

C. 必须为字母或下划线 D. 可以是字母，数字和下划线中任一字符

4.. 在C语言中，要求运算符必须是整型的运算符是 ( D )。(鲁科安全，北京君正集成电路)

A. / B. ++ C. != D. %

变量

概念：在程序运行中发生变化的量

定义格式：

存储类型 数据类型 变量名

auto(省略的时候默认是 auto) int a;

存储类型：就是变量的存储的位置

数据类型就是变量所占字节的个数

数据类型

名称	字节	取值范围(了解)
char 字符型	1字节	-2^7 ~ 2^7-1
short 短整型	2字节	-2^15 ~ 2^15-1
int 整型	4字节	-2^31 ~ 2^31-1
long长整型	4字节	-2^31 ~ 2^31-1
float 单精度浮点型	4字节	有效数据 6-7位
double 双精度浮点	8字节	有效数据 15-16位

float a = 1111.1111;  // 1111.111084
float b = 111111.11;  // 111111.109375
double c = 1111111111111.1111;  // 1111111111111.111084

// printf("%f\n", a);
printf("%lf\n", c);

printf("%d\n", sizeof(int)); // 4

变量分类

局部变量、全局变量的区别？

                       局部变量                        全局变量

1. 定义位置： 函数体内部                    函数体外部

2. 存储位置： 栈区                               全局区(静态区)

3. 初值：        未赋初值时值为随机数  未赋初值时，值为0

4. 生命周期： 同函数体共存亡             同整个程序共存亡

5. 作用域：    作用于函数体内部          作用于整个程序

内存图

常量

概念：

程序运行中不会发生改变的量

分类：

1. 字符型常量

用 ' ' 括起来

'a' -> 字符a

a -> 变量

'\0' // 字符串的结束标志

' ' // 空格也是字符

'\n' // '+' '-'

'A'  //65

#include <stdio.h>

int main(int argc, char const *argv[])
{
    char a = 'A';
    char b = '\x41';
    char c = '\101';
    char d = 65;
    char e = '\\'; 
    printf("%c %c %c %c %c\n", a, b, c, d, e);
    
    return 0;
}

hq@Ubuntu:~/song$ ./a.out 
A A A A \

2. 字符串常量

用 " " 括起来

"hello" 字符串后面 \0

3. 整型常量

int // 我们使用 int 存储多一点

4. 浮点型常量

float(占4字节) double(占8字节)

5. 指数常量

3*10^8 -> 3e8

2*10^-12 -> 2e-12

不是 10的几次方就不能用 e ，要用 pow 函数，只不过现在接触不到

6. 标识常量

宏定义：起标识作用

遵循标识符的命名规则

一般用大写表示

格式： #define 宏名 常量或表达式

特点：只能单纯的替换，不要进行手动运算(原样替换，替换完再计算)

练习：

#define N 2

#define M N+3

#define NUM N+M/2+1

void main()

{

int a = NUM;

printf("%d\n", a); // 6

}

// 2+2+3/2+1

练习：结合宏定义三目运算符实现两个数求最大值

// 最后要实现的是，我们的宏表示的是两个数的最大值、

#include <stdio.h>
#define MAX a > b ? a : b
int main(int argc, char const *argv[])
{
    int a = 5, b = 8;
    printf("%d\n", MAX);
    return 0;
}

宏函数

#include <stdio.h>
#define MAX(a, b) a > b ? a : b
int main(int argc, char const *argv[])
{
    int a = 5, c = 8;
    printf("%d\n", MAX(3, 7));
    return 0;
}

输入输出

有两类：

1. 按格式输入 输出

2. 按字符输入 输出

函数三要素：功能、参数、返回值

1. 按格式输出

man 3 printf

#include <stdio.h>

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

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

参数：format：字符串 "hello world"

格式：

"%d" int

"%hd" short

"%ld" long

"%lld" long long

"%f" float

"%c" char

"%lf" double

"%s" 字符串

"%#x" 十六进制

"%#X" 十六进制

"%#o" 八进制

"%p" 地址

"%e" 指数

"%-m.n" 含义：

.n ：打印小数点后几位

m：位宽 // 当 m 大于实际位宽，按m输出，当m小于实际位宽，按实际输出

-：左对齐，默认右对齐

返回值：输出字符的个数

2. 按格式输入

man scanf

#include <stdio.h>

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

功能：按格式从终端输入

参数：同 printf

返回值：正确的输入数据的个数

当第一个数输入格式不正确时，会直接返回0

#include <stdio.h>
int main(){
    int a;
    double b;
    char c;
    char d[100];

    int ret=scanf("%d,%lf,%c,%s",&a,&b,&c,d);
    printf("%d,%lf,%c,%s,正确个数%d\n",a,b,c,d,ret);
}

hq@Ubuntu:~/song$ ./a.out 
111,22.33,m,hello
111,22.330000,m,hello,正确个数4

练习：

一个水分子的质量约为3.0*10^-23g，1夸脱水大约有950g，

编写一个程序，要求输入水的夸脱数，然后显示这么多水中包含多少水分子。

表示：3.0e-23 打印格式：%f 或 %e

#include <stdio.h>
#define M 3.0e-23
#define N 950
int main(){
    int a;
    printf("输入水的的夸克数:");
    scanf("%d",&a);
    float sum=( N/M )*a;
    printf("共包含水分子:%e\n",sum);
    return 0;   
}

hq@Ubuntu:~/song$ ./a.out 
输入水的的夸克数:1
共包含水分子3.483333e+25

3. 按字符输入

man getchar

#include <stdio.h>

int getchar(void);

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

参数：无

返回值：输入字符的ASCII值

#include <stdio.h>

int main(int argc, char const *argv[])
{
    int ret = getchar();  // ret 里面存放的是输入字符的 ascii 值
    printf("%d\n", ret);  
    return 0;
}

hq@Ubuntu:~/song$ ./a.out 
a
97

4. 按字符输出

man putchar

#include <stdio.h>

int putchar(int c);

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

参数：c：要输出字符的 ASCII值

返回值：输出字符的 ASCII值

// putchar(97);

// putchar('A'); == putchar(65);

// putchar(10); == putchar('\n');

#include <stdio.h>

int main(int argc, char const *argv[])
{
    int ret = putchar(65);  // ret 里面存放的是输入字符的 ascii 值
    putchar(10);
    printf("%d\n", ret);  
    return 0;
}

hq@Ubuntu:~/song$ ./a.out 
A
65

垃圾字符回收

#include <stdio.h>

int main(int argc, char const *argv[])
{
    char a;
    char ch;
    scanf("%c%c", &a, &ch);
    printf("a = %c ch = %c\n", a, ch);
}

hq@Ubuntu:~/song$ ./a.out 
AB
a = A ch = B


hq@Ubuntu:~/song$ ./a.out 
A B 
a = A ch =  

​​​​​​​

1. 通过空格回收

scanf(" %c %c", &a, &ch);

可以回收一个或多个空格、回车、tab

#include <stdio.h>

int main(int argc, char const *argv[])
{
    char a;
    char ch;
    scanf("%c %c", &a, &ch);
    printf("a = %c ch = %c\n", a, ch);
}

hq@Ubuntu:~/song$ ./a.out 
A B
a = A ch = B

2. %*c

只能回收任意一个字符

#include <stdio.h>

int main(int argc, char const *argv[])
{
    char a;
    char ch;
    scanf("%c%*c%c", &a, &ch);
    printf("a = %c ch = %c\n", a, ch);
}

hq@Ubuntu:~/song$ ./a.out 
a?b
a = a ch = b

3. getchar()

只能回收任意一个字符，一般用在循环里面

#include <stdio.h>

int main() {
    int c;
    
    printf("请输入一个字符（按Enter键结束）：\n");
    
    // 读取第一个字符
    c = getchar();
    
    // 循环以读取并丢弃多余的字符（包括换行符）
    while (c != '\n' && c != EOF) {
        c = getchar();
    }
    
    printf("已回收所有垃圾字符。\n");
    
    return 0;
}
//程序首先读取一个字符，然后进入一个循环，持续读取字符直到遇到换行符（\n）或文件结束符（EOF）
//这样可以确保输入缓冲区中没有残留的字符。

练习：

1. 用getchar、putchar实现大写字母转换成小写字母

#include <stdio.h>

int main(int argc, char const *argv[])
{
    int ret=getchar();
    if(ret>=65&&ret<=90)
    {
        putchar(ret+32);
        putchar(10);
    }
    else if(ret>=97&&ret<=122)
    {
        putchar(ret-32);
        putchar(10);
    }
    else
    {
        printf("ERROR\n");    
    }

    return 0;
}

3. 在Linux系统上，如果局部变量没有初始化，默认变量的值是:   随机值    (紫光云数)

4. 以下程序的输出结果是( C) (鲁科安全)

#include
#define M 5
#define N M+M
main()
{
    int k;
    k = N*N*5;
    printf("%d\n", k);
}

A. 500 B. 125 C. 55 D. 100

5. 用宏定义表示出一年中有多少秒(假设一年为365天)

#define D 365
#define H 24
#define M 60
#define S 60
int main(int argc, char const *argv[])
{
    printf("%d\n",D*H*M*S);
    return 0;
}