C语言汇总

汇总一（linux环境）

/bin ：bin是二进制（binary）英文缩写。

/boot：存放的都是系统启动时要用到的程序。
/dev：包含了所有Linux系统中使用的外部设备。
/etc：存放了系统管理时要用到的各种配置文件和子目录。
/lib：存放系统动态连接共享库的。
/home：管理普通用户的主目录
/root:根用户（超级用户）的主目录

1. ~ 家目录符号
2. / 根目录符号
3. $ 普通用户
4. # 超级用户

汇总二（数据）

void类型大小为1个字节

'\0'---0
'\n'---10
' ' ---32 (这是个空格）
......
'0' ---48 (差48）
'1' ---49
......
'A' ---65
'B' ---66
......
'a' ---97 (差32）
'b' ---98

1.char

char 与 unsigned char （1字节） 2^8=256
char 数值范围：，-128~127
unsigned char 数值范围：0 ~256

若存储char类型 129，由于补码的存在，CPU读取的是补码，编译成功后，输出-127

若存储unsigned char 类型 -1 ，输出255

补码：1111 1111

反码：1111 1110

源码：1000 0001

float4字节、double 8字节

汇总三（常量、变量）

常量：

1.整型常量2.字符常量3.字符串常量4.浮点常量

变量：

定义：

<存储类型> <数据类型> <变量名>；

存储类型：1.自动：auto（可以不写）2.静态：static

3.寄存器：register4.外部：extern（静态存储）

数据类型：

1.字符变量

//1. 定义
char a;
//2. 定义并初始化
char a = 'a';
//3. 赋值
a = 'b';

2.整型变量

//1. 定义
short a;
int b;
long c;
//2. 定义并初始化
int b = 5;
//3. 赋值
b = 1;

3.浮点变量

//1. 定义
float a;
double b;
//2. 定义并初始化
float c = 5.5;
//3. 赋值
c = 1.1;

局部变量、全局变量、静态变量、外部变量

1.作用域：能使用的范围限制

#include <stdio.h>
int main(int argc, const char *argv[])
{
{
int a=10;
printf("in a=%d\n", a);
}
/*作用域*/
//printf("out a=%d\n", a);
return 0;
}



花括号内为一个语句块

.花括号内为一个语句段。

2.时间周期：能使用的时间限制

结论：两次调用的函数中，变量b使用的空间不同，第一次调用后b的空间会释放掉，第二次会重新申请空间，所以两次打印b的值不同。

3.局部变量和全局变量

#include <stdio.h>
/*全局变量*/
int a=10;
int main(int argc, const char *argv[])
{
{
/*局部变量*/
int b=20;
printf("a=%d\n", a);
printf("b=%d\n", b);
}
//printf("a=%d\n", a);
//printf("b=%d\n", b);
return 0;
}

局部变量存储与栈中，全局变量存在于静态存储区

4.静态变量和外部变量

静态变量

#include <stdio.h>
void fun(void)
{
//在程序执行期间，只申请一次空间
static int b = 1;
printf("b=%d\n", b);
b = 2;
//函数结束，静态变量不释放
}
int main(int argc, const char *argv[])
{
fun();
fun();
return 0;
//程序结束，静态变量释放
}

输出结果为 b=1 b=2

说明b为同一个，使用的是同一块地址空间，第二次调用函数时，不在申请新地址去存b。main函数结束时静态存储区才释放。

加上static从原来的栈中存放改为静态存储区，整个程序执行期间都有不销毁。改变了生命周期

静态区：

1.常量2.静态变量3.静态局部变量4.全局变量

auto类型的局部变量存储于栈之中

全局变量存储于静态空间区

程序结束，静态存储区内容才释放。

外部变量

A.c
int global_a = 100;
//static int global_a = 100;
B.c
#include <stdio.h>
extern int global_a;
int main(int argc, char *argv[])
{
//int global_a;
printf("global_a=%d\n", global_a);
return 0;
}
注意: extern声明的是定义过的全局变量（静态存储区），所以extern的变量是静态存储区（内存管理）
提醒：起名字要遵守语法规范，且要见名知意，尽量使用英文单词格式。

gcc A.c B.c -o out

若B.c中global_a前没写extern，同样会打印出结果。因为int global_a = 100;是全局变量存储于静态区，同样会执行，但是还是要申请，因为此文件中其他同名变量可能会赋值

注意: extern声明的是定义过的全局变量（静态存储区），所以extern的变量是静态存储区（内存管理）提醒：起名字要遵守语法规范，且要见名知意，尽量使用英文单词格式。

全局变量和局部变量同名的话，采用就近原则

汇总四（内存管理）

1.内存管理

数据区：这一块的内存在程序编译时就已经分配好，在程序整个运行期间都存在。属于静态内存分配。
栈：自动局部变量，系统分配的内存，向下增长
堆：程序员主动申请的、动态分配的内存，向上增长。（malloc、free）

2.自动局部变量和静态局部变量

(auto)自动局部变量：栈区；生命周期是当前语句块、函数，作用域是当前语句块、函数。
(static)静态局部变量：数据区；生命周期是当前程序，作用域是当前语句块、函数。

3.全局变量、静态全局变量

全局变量：数据区；生命周期是当前程序，作用域是当前程序。
注意不能被auto修饰，全局变量是静态内存分配。
(static)静态全局变量：数据区；生命周期是当前程序，
作用域是当前文件。不能跨越.c文件

4.全局变量与外部变量

全局变量可以被声明外部变量，所以外部变量是静态内存分配。
静态全局变量因为作用域的限制，不能被声明为外部变量。

汇总五（运算符）

1.浮点类型数据不能取余！

2.前++、前--

运算规则：先运算，后自增\自减

int a = 1, b = 2;
a = b++;
printf("a == %d, b == %d\n", a, b);
// a == 2, b == 3

3.后++、后--
运算规则：先自增\自减，后运算

int a = 1, b = 2;
a = ++b;
// a == 3, b == 3

4.逻辑运算

1.逻辑运算的结果只有真假值，&&的优先级比||高，优先执行；

2.|| 运算有提前截断现象，左条件式为真时，右条件不会执行。

#include <stdio.h>
int main(int argc, const char *argv[])
{
int a=1, b=2;
if( a++ || b++ ){
printf("a=%d, b=%d\n", a, b);
}
return 0;
}
//a=2,b=2

5.位运算

参与运算的量，按二进制位进行运算。
包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。

6.条件运算符（三目运算符）

表达式A ? 表达式B : 表达式C
这是一个三目运算符，用于条件求值，表达式A如果为真，执行表达式B，反之执行表达式C。

汇总六（输入输出）

1.输出字符 putchar

int putchar(int);
eg:
char a = 'A';
putchar(a);
参数: 为字符常量、变量或表达式
功能：把字符c输出到显示器上
返值：正常，为显示的代码值；

2.输出字符串 puts

int puts(const char *);
eg:
char str[20] = "hello world";
puts(str);
功能：向显示器输出字符串（输出完，换行）
说明：字符数组必须以‘\0’结束

3.输入字符 getchar

int getchar(void);
eg:
char c = getchar();
功能：从键盘读一字符
返值：正常，返回读取的代码值；出错或结束键盘输入,返回-1

4.输入字符串

char *gets(char *);
eg:
char str[20];
gets(str);
功能：从键盘输入一以回车结束的字符串放入字符数组中，
并自动加‘\0’
说明1：函数没有实现检查字符串长度能否完全放入，所以
输入串长度应小于字符数组维数。
说明2：与scanf函数不同，gets函数并不以空格作为字符
串输入结束的标志。

#include <stdio.h>
int main(int argc, const char *argv[])
{
char string[15] = {0};
printf("Input a string:");
gets(string);
printf("%s\n", string);
return 0;
}

5.scanf

int scanf(const char *restrict, ...);
eg:
int n;
char str[20];
scanf("%d %s", &n, str);
%d 有符号整型 %c 字符 %s 字符串 %f 单精度浮点型
%s 获取字符串时，提供的应当是一个指向字符数组的指针
功能：按指定格式从键盘读入数据，存入地址表指定存储单元中,并按回车键结束
返值：正常，返回输入数据个数
地址表：变量的地址，常用取地址运算符&

在整型时

字符型时

吃掉摁下的回车键；抑制符*的使用，吃掉了空格（字符之间多敲了一个空格）

scanf2.c
#include <stdio.h>
3.处理脏数据
int main(int argc, const char *argv[])
{
char ch1, ch2, ch3;
//%c 作为格式输入时，对空格键，tab键，\n 都作
为一个有效字符读入
scanf("%c%c%c", &ch1, &ch2, &ch3);
printf("ch1 = %c ch2 = %c ch3 = %c\n",
ch1, ch2, ch3);
//enter 按键需要吃掉 getchar获取到这个\n
getchar();
//%*c抑制一个字符
scanf("%c%*c%c", &ch1, &ch2);
printf("ch1 = %c ch2 = %c\n", ch1,ch2);
return 0;
}

6.3.处理脏数据

//回收垃圾方式的三种方式
//方法1：空格、若干空格、tab、\n
#if 0
scanf("%c %c %c", &a, &b, &c);
#endif
//方法2：%*c 回收任何一个字符， tab 键 ，空格键，
\n
#if 0
//%*c 回收任何一个字符， tab 键 ，空格键，
\n
scanf("%c%*c%c", &a, &b);
#endif
//方法3：getchar()回收
#if 0
scanf("%c", &a);
getchar(); //吃一个字符
scanf("%c", &b);
#endif
printf("a=%c b=%c c=%c\n", a, b, c);
return 0;
}

方式一可以吃掉多个空格

若只是输入一个字符，建议方式三