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.常量

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

2.变量：

定义：

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

存储类型：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;
}

方式一可以吃掉多个空格

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

汇总七（控制语句）

1.条件语句

a. if ---- else

b. Switch -- case 多条件选择语句

2.循环语句

a.while

continue 当前循环到此结束，重新开始

break则是退出循环

b. do ---- while

while循环中 (条件)后面没有分号，do while 循环中 (条件) 后面有"，"
while与do while执行循环体与判断的顺序不同
3)各自的应用场合不同。while强调"条件是否满足"do while强调"动作的行为"

两个死循环

c.for循环

3.break与continue

break

break从循环体内跳出，即提前结束当前循环

注意:

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

continue

continue语句结束本次循环，接着判定下一次是否执行循环。

注意:

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

continue是循环控制语句，不能实现跳出条件语句if、switch。

4.return

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

return 表达式的结果可以被返回到调用函数接收存储。

return的值一般有以下几种含义:

1.函数是否正常执行的反馈

库函数常用0表示正常结束，非0有异常情况

自定义函数，判定真假，非零为真

2.函数需要返回一个运算结果值

根据定义的返回值类型，存储、返回值。传值要注意类型一致，或主动强制转换

汇总八（数组）

1.一维数组

1.1.数组的定义

<存储类型> <数据类型> <数组名> $N$ ;

数据类型表示每个成员的数据类型；
数组名代表数组的首地址，是常量地址；
N是数组定义时申请的成员数量。
每个成员依次使用0,1,2,3......N-1来标记成员在数组中的位置，这个标记称作下标；
是数组的取值符号，定义时里面填写申请的数组成员数量；调用时里面填写下标值，用来取特定下标成员的值：数组名字 $n$ ，表示下标为n的数组成员的值；
& 是取地址符号，用来获取变量的首地址，可以和数组结合，用来获取特定数组位置的首地址。
符号 * 是指针的取值符号，这里因为数组也和地址有关系，所以可以使用符号 * 来做取值操作。

注意：数组是顺序的使用一块连续的存储空间的构造类型

a &a 值相等，表示的含义不同

a 一维数组a的常量地址，代表整个数组。

&a 取整个数组的首地址

a $1$ 一维数组a的第二个成员的值。

&a $1$ 一维数组a的第二个成员的首地址。

a+1 从一维数组a的第一个成员首地址，偏移一个成员单位，到第二个成员的首地址。

*(a+1) 一维数组a的第二个成员的值。

1.2数组的初始化

1.data $5$ 使用的下标为0 . 1 . 2 . 3 . 4

2.若初始化一部分则后面的值自动补0

复制代码

#include <stdio.h>
int main(int argc, const char *argv[])
{

/**********定义**********/
//定义一个有5个int成员的数组dataA
int dataA[5];
/**********定义并初始化**********/
//定义一个有5个int成员的数组dataB, 并初始化一部分
int dataB[10]={1,2,3,4,5};
int dataC[] = {1,2,3,4,5};

/**********观察数组成员初始值**********/
//dataA[0] dataA[1] dataA[2] dataA[3] dataA[4] dataA[5] ......
printf("sizeof(dataA)=%u,dataA[5]=%d\n",sizeof(dataA), dataA[5]);
//error: dataA[5] 越界了
printf("sizeof(dataB)=%u,dataB[5]=%d\n",sizeof(dataB), dataB[5]);
printf("dataB[10]=%d\n", dataB[10]);
//error: dataB[10] 越界了，dataC只有0~9个成员，编译器不检查数组越界！！！

//sizeof计算数组申请的长度
int n = sizeof(dataC)/sizeof(int);
printf("dataC has %d members\n", n);
printf("sizeof(dataC)=%u,dataC[5]=%d\n",siz
eof(dataC), dataC[5]);
//error: dataC[5] 越界了，dataC只有0~4个成员，编译器不检查数组越界！！！

return 0;
}

1.3数组的赋值和初始化

数组为构造类型，不能直接赋值和读取，二者都需要借助for循环

复制代码

#include <stdio.h>
int main(int argc, const char *argv[])
{
/**********定义**********/
//定义一个有5个int成员的数组dataA
int dataA[5]={1,2,3,4,5};
int i;

/**********遍历(调用)**********/
for(i=0; i<5; i++){
printf("dataA[%d]=%d\n", i,dataA[i]);
}

/**********赋值**********/
#if 0
//error 数组不能整体赋值
//dataA={5,4,3,2,1};
//dataA[5]={5,4,3,2,1};
#else

//right
for(i=0; i<5; i++)
  {
dataA[i] = i+1;
  }

#endif
return 0;
}

注意事项：

数组必须逐个元素引用，而不能整体引用。
数组名是常量，不能被赋值。

数组定义后，其空间就确定下来了，所以为常量

同个数组中的所有元素的数据类型都是相同的。
不能在方括号中用变量来表示元素的个数，但是可以是符号常数或常量表达式。

1.4 排序

冒泡排序

从标准输入获取数字

复制代码

#include<stdio.h>
#define N 10
int main(int argc, const char *argv[])
{
	int data[N]={0};
	int a,i,j,temp;
	for(a=0;a<=N-1;a++){
		scanf("%d",&data[a]);
	}
	for(i=0;i<=N-1;i++)
	{
		for(j=0;j<=N-1-i;j++)
		{
			if(data[j]<data[j+1])
			{
				temp=data[j+1];
				data[j+1]=data[j];
				data[j]=temp;
			}


		}
	}
	for(i=0;i<N;i++)
	{
	printf("%d ",data[i]);
	}
	putchar(10);
	return 0;

}

sort_maopao.c
#include <stdio.h>
#define N 10
int main(int argc, const char *argv[])
{
int a[N] = {2, 5, 1, 3, 4, 10, 7, 9, 8,
6};
int i = 0, j = 0;
int temp = 0;
/* 冒泡的趟数 ，N 个数， N-1趟*/
for (i = 0; i < N-1; i++){
// 每排一趟序，找到一个最大值，下次比较元
素个数减1
for (j = 0; j < N-1-i; j++){
//较大的数值下沉
if (a[j] > a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
缺点：数据读取、存储、交换次数太频繁。
简单选择排序：
}
}
for ( i = 0; i < N; i++){
printf("%d ", a[i]);
}
putchar(10);
return 0;
}

2.字符数组

2.1定义和初始化

复制代码

#include <stdio.h>
#define N 10
int main(int argc, const char *argv[])
{
int i = 0;
char ch;

#if 1
char str[N];
#endif

#if 0
char str[N] = {'h','e','l','l','o'};
#endif

#if 0
char str[N] = "hello";
#endif

#if 0
char str[] = "hello";
#endif

#if 0
while( ((ch=getchar()) != '\n') && (i <N) )
{
str[i++] = ch;
}
#endif

#if 1
for(i = 0; i < N; i++)
{
printf("%d:%c\t", str[i], str[i]);
}
putchar(10);
#endif

//scanf("%s", str);
//printf("%s\n", str);
return 0;
}

输入可采用 scanf

输出可采用printf

易出现问题及应对方法

问题：字符数组未初始化的使用

char a $10$ ;

for 赋值 {'h','e','l','l','o'}; 不能整体赋值构造类型！

不能整体赋值，a属于常量地址，不能被赋值

char a $10$ ;

赋值 "hello";

如果数组没有初始化，局部变量空间存储内容情况是未知的。

第一种情况的数组赋值后，'o'后面不一定哪个位置有\0；

第二种情况的数组赋值后，'o'后面自动填充了'\0'。

2.2 字符串函数

2.2.1 求字符串长度

复制代码

1. 函数原型：
#include <string.h>//头文件
size_t strlen(const char *s);
2.
参数：字符串首地址（地址==指针）；
返回值：int , 获取的字符串长度，不包括'\0'.
#include <stdio.h>
#include <string.h>
#define N 20
int main(int argc, const char *argv[])
{
char string[N] = "hello world";
int len = strlen(string);
//len =strlen("hello world");

//printf("len = %d, string = %s\n",strlen("hello world"), string);
printf("len = %d, string = %s\n", len,string);
return 0;
}

2.2.2

汇总一（linux环境）

汇总二（数据）

1.char

float4字节、double 8字节

汇总三（常量、变量）

1.常量

2.变量：

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

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

数据类型：

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

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

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

3.局部变量和全局变量

4.静态变量和外部变量

静态变量

外部变量

汇总四（内存管理）

1.内存管理

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

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

4.全局变量与外部变量

汇总五 （运算符）

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

2.前++、前--

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

3.后++、 后--

4.逻辑运算

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

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

5.位运算

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

汇总六 （输入输出）

1.输出字符 putchar

2.输出字符串 puts

3.输入字符 getchar

4.输入字符串

5.scanf

6.3.处理脏数据

汇总七（控制语句）

1.条件语句

a. if ---- else

b. Switch -- case 多条件选择语句

2.循环语句

a.while

b. do ---- while

两个死循环

3.break与continue

break

continue

4.return

汇总八（数组）

1.一维数组

1.1.数组的定义

1.2数组的初始化

1.3数组的赋值和初始化

注意事项：

1.4 排序

冒泡排序

2.字符数组

2.1定义和初始化

2.2 字符串函数

2.2.1 求字符串长度

汇总五（运算符）

3.后++、后--

汇总六（输入输出）