汇总一（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