LinuxC复习.docx

LinuxC复习.docx

《LinuxC复习.docx》由会员分享，可在线阅读，更多相关《LinuxC复习.docx（16页珍藏版）》请在冰豆网上搜索。

LinuxC复习

Linux_C（复习）.txt心态决定状态，心胸决定格局，眼界决定境界。

当你的眼泪忍不住要流出来的时候，睁大眼睛，千万别眨眼，你会看到世界由清晰到模糊的全过程。

1，C语言概述：

编译类的语言

gcc默认加载的库/lib/libc.so.6

gcca.c-oabc-lc

2，hello.c

#include/usr/include/stdio.h

intmain（void）ls

intmain（intargc,char**argv）ls-l

{

printf（"helloworld!

\n"）;

return0;

}

3，变量，常量，运算符

[修饰符]存储类型数据类型变量名

修饰符：

const（常量）,volatile（易变的）

存储类型：

auto，register，static，extern

数据类型：

有符号：

signed无符号：

unsigned

intcharshortlongfloatdouble

412448

变量名：

下划线或者字母开头，由下划线，字母，数字!

为什么要定义变量：

用来存储数据！

变量的初始化：

intnum=10;

常量：

不能被改变！

9，‘a’，“abcde”，intarr[10];intfun（void）;constinta;

常见的运算符：

1，赋值运算符：

变量=值，变量=变量

inta；数据表现形式：

10进制，8进制，16进制。

a=23；a=027；a=0x17；计算机存储数据2进制

charch;

ch='a';'a'->ascii码->2进制

2，算术运算符：

+-*/%

intmain（）

{

inta=10;

a+=1;a=a+111

a*=4-2;a=a*（4-2）22

a-=5;a=a-517

printf（"a=%d\n",a）;

}

3，sizeof（）:

字节大小！

sizeof（类型），sizeof（变量），sizeof（指针），sizeof（数组名）

字符的输入，输出：

getchar（）;

charch;

ch=getchar（）;

putchar（）;

charch='a';

putchar（ch）;

intnum；

scanf（“%d”，&num）;

%d（10进制整数）%o（8进制整数）%x（16进制整数）%c（字符）

printf（“%d”，num）;

%d（10进制整数）%o（8进制整数）%x（16进制整数）%c（字符）

\n（回车）\t（tab键）

程序的结构：

1，顺序结构：

2，分支结构：

if，switch...case

条件：

1，关系运算符：

==!

=><>=<=

2，逻辑运算符：

&&（）||（）！

条件1&&条件2

真&&假（假）假&&真（假）假&&假（假）真&&真（真）

条件1||条件2

真||假（真）假||真（真）假||假（假）真||真（真）

注意：

条件1||条件2||条件3||条件4...

条件1&&条件2

if语句：

形式：

单分支：

双分支：

多分支：

if（条件）{if（条件）{if（条件1）{

语句；语句1；语句1；

}}}

else{elseif（条件2）{

语句2；语句2；

}}

else{

语句3；

}

if语句的嵌套：

if（条件）{

if（条件）{

语句；

}

}

条件运算符：

表达式1？

表达式2：

表达式3；

switch（表达式）{

case常量：

语句；

语句；

case9：

语句；

语句；

case‘a’：

语句；

语句；

default：

语句；

}

常量：

数值常量，字符常量！

如何选择if和switch？

if:

描述一定的范围

switch：

分支明确。

（菜单）

循环结构：

whiledo...while（）;for（）

while（条件）{

循环体；

}

do{

循环体;

}while（条件）;

for（表达式1；表达式2；表达式3）{

循环体；

}

break与continue？

break:

结束整个循环

continue:

结束本次循环

while（n<100）{

if（n%2==0）

continue;

n++;

}

for（n=0;n<100;n++）{

if（n%2==0）

continue;

}

数组：

为什么要使用数组？

数组：

相同数据的有限的集合！

数据类型数组名[成员个数];

数据类型：

每一个成员的类型

数组名：

标示符的命名规则

[常量（数值）]：

成员的个数

数组的初始化：

intarr[5];

intarr[5]={1,2,3,4,5};

intarr[5]={1,2,3};

intarr[]={1,2,3,4};

成员的引用：

数组名[下标]；

例如：

intarr[5];

arr[0]arr[1]arr[2]arr[3]arr[4]

arr[0]=存数据

=arr[0]取数据

数组的操作：

1，数组的遍历：

取值，存值！

2，数据交换：

数据的移动！

排序算法（冒泡）

二维数组：

定义，初始化：

数据类型数组名[常量][常量];

例如：

intarr[2][3]={{1,2,3},{4,5,6}};

arr[0][0]arr[0][1]arr[0][2]arr[1][0]arr[1][1]arr[1][2]

线性存储！

二维数组的操作：

字符数组:

charbuf[256];

字符串：

字符+'\0'"abcde"

字符串初始化：

charbuf[5]={'a','b','c','d','\0'};

charbuf[5]={"abcd"};

charbuf[5]="abcd";

charbuf[]="abcdef";

sizeof（buf）=7;

字符串的输入：

charbuf[100];

gets（buf）;

字符串的输出：

puts（buf）;

printf（"%s\n",buf）;

指针：

定义：

数据类型*指针变量；

数据类型：

存取数据的大小！

*指针，指针+1

指针变量：

保存地址！

&取地址：

&变量

*存取数据：

*指针==*指针

操作：

1，p+1

2，p++

3，p-q

4，p

指针的作用：

提供另外一种存取数据的方式！

指针与数组

charbuf[100];

char*p;

p=buf;

指针与字符串：

char*p=“abcd”；

指针与函数：

voidfun（char*buf,intn）;

char*fun（char*p）;

指针数组：

char*buf[100];

指针与结构体：

structnode{

intnum;

structnode*next;

};

函数指针：

void（*p）（inta）；

函数：

数据类型函数名（形参列表）；函数声明

intmain（）

{

函数名（实参）;函数调用

}

数据类型函数名（形参列表）函数的实现

{

c语句；

}

数据类型：

返回值的类型，没有返回值void

函数名：

地址常量（类似数组名）

形参列表：

参数1，参数2

函数的作用：

提高代码的利用率

函数的声明

intmain（）

{

{函数调用

功能1；

}

}

{

功能1；

}

函数的执行过程

intfun（inta）;

intmain（）

{

inta;

a=10;

a=fun（a+1-4）;

}

intfun（inta）

{

printf（"%d\n",a+1）;

returna+3;

}

变量的作用域：

局部变量，全局变量，static，字符串常量

编写函数：

函数传值：

1，传int,char

voidfun（inta,intb）;

charfun（charch）;

2，传数组

voidfun（intarr[12],intlen）;

voidfun（int*arr,intlen）;

intfun（intarr[],intlen）;

传字符串：

voidfun（char*buf）;

voidfun（charbuf[]）;

char*fun（char*buf,charch）;

intmain（）{

intarr[9]={7};

fun（arr,9）

}

voidfun（intarr[1077],intlen）{

intabc[8];

printf（"%d\n",sizeof（arr））;

}

函数传二维数组：

voidfun（inta[][3],intlen）;

intmain（）

{

intarr[2][3]={1,2,3,4,5,6};

fun（arr,2）;

}

voidfun（inta[][3],intlen）{

inti,j;

for（i=0;i

for（j=0;j<3;j++）

printf（"%d",a[i][j]）;

}

函数指针：

void（*p）（inta）;

mansignal

manpthread_create

自定义函数：

自己写

库函数：

别人写的！

1，内存分配：

malloc：

申请内存malloc（大小），返回地址

free：

free（地址）

2，字符串处理函数：

bzero,strlen,strcmp,strcpy,strcat,strchr,strstr,atoi

联想：

mem开头，带n的，strncpy十几个字符串函数

库函数：

多，少！

./a.out-l-c-dargc=4

argv[0]argv[1]argv[2]argv[3]

intmain（intargc,char*argv[]）

{

inti;

for（i=0;i

printf（"%s\n",argv[i]）;

}

argc=4

编写计算器：

1，argc,argv

./a.out12+23判断argv[2]

2，add1223sub133

开发板中busybox（命令，ls，cp...）

intmain（）

{

数据区；

算法；

错误处理：

error1:

}

作业:

帧头：

1a2b帧尾：

3c4d

数据如：

1a2balks3c4ddflh1a2bic3c4dlkd1a1a2b2bo3c4diuqw3c4derl1a2bkj1a2bchi1a2buqw3c4delr3c4dkjckjh1a2bwqoirul3c4dsadf3c4d

帧头帧尾之间的为正确数据！

注意半帧的情况！

结构体：

自定义一个新的类型

定义结构体：

structabc{

inta;

charb[100];

};

定义变量:

structabc变量名称；

structabctt;

成员赋值：

结构体变量.成员=；

结构体指针->成员=；

1，计算结构体大小！

2，结构体初始化：

structabctt={10,"abcdef"};

tt.a=10;

strcpy（tt.b,"abcdef"）;

学生管理系统：

1，添加

2，查找

3，删除（按照id删除，按照年龄删除，按照姓名删除）

4，打印（按照id排序，按照年龄排序，按照姓名排序）

执行过程：

while

（1）{

addstudent[1]

searchstudent[2]

deletestudent[3]

printstudent[4]

quit[0]

enter:

}

线性结构：

结构体数组：

链表：

structnode{

数据区；

结构体指针；

};

共用体：

枚举：

Linux中文件操作：

标准库：

打开文件：

fopen

文件操作：

读写

字节fgetcfputc

字符串（行）fgetsfputs

块（段）freadfwrite

关闭文件：

fclose

字节流：

od-c文件（ascii）

od-x文件（16进制）

文件：

普通文本文件，二进制文件

fopen（地址1，地址2）

输入：

地址1：

”文件名“地址2：

“打开文件方式”

返回值：

地址：

FILE*成功：

地址（堆）失败：

NULL

文件名：

绝对路径，相对路径

打开方式：

rwr+w+aa+

fclose（地址）

文件操作：

fgetc（地址）

输入：

fopen的返回值

输出：

成功：

取一个字符，失败：

EOF（-1）（到文件结尾）

fgets（地址1，长度，地址2）

输入：

地址1：

字符数组长度：

<=数组大小地址2：

fopen返回值

输入：

成功：

地址1，失败：

NULL