linux_C实习笔记.docx
《linux_C实习笔记.docx》由会员分享，可在线阅读，更多相关《linux_C实习笔记.docx（35页珍藏版）》请在冰点文库上搜索。
linux_C实习笔记
嵌入式实习笔记
第一周
linux基本命令：
计算机由软件和硬件：
硬件：
中央处理器（CPU），内存，硬盘，主板，显卡，电源，输入输出设备（键盘，
鼠标，显示器）。
内存：
无法长久保存数据，关机内容自动消失。
硬盘：
可以长久保存数据，关机内容不丢失
CPU:
只能直接操作内存，不能直接操作硬盘。
软件：
应用软件和系统软件。
一,linux的文件系统：
一个纯净的windows操作系统，大概拥有8千到1万个文件
windows：
根目录：
盘符C，D，E
linux：
根目录“/”
/opt应用程序
/usr用户通用文件
/binlinux的常用命令
/sbinlinux的不常用命令
/etc系统的一些配置文件
/dev设备管理
/var应用程序
/home用户登陆的目录
。
。
。
用more查看配置文件的内容
more/etc/passwd（查看用户信息）注意more后有空格
shadow（权限不够，管理员权限）eg：
more/etc/shadow
或cd/
cdect
morepasswd等价于命令more/etc/passwd
分页显示查询内容：
回车：
换行
空格：
翻页
q：
退出
基本命令：
文件的目录有两种描述方式绝对路径（根目录开始）和相对路径一个文件
的绝对路径只有一个，但是一个文件的相对路径可以有多个
eg：
more./../../home/soft1/tarena/m.cpp
特殊：
.当前目录，
..上一级目录
~用户登录目录
下一层目录的名字（就代表）下一层目录
在开发的一个过程当中，用相对路径命令格式：
命令【-选项】【-参数】（【】表示可选）（命令后必须有空格）
选项和参数是可选的，
，它指向一个1.clear清屏
2.pwd打印当前路径（让终端告诉我我在哪里）
3.cd改变当前目录
格式cd路径（注意cd后有空格）
cd.（无实际意义）切换到当前目录
cd..切换到上一级目录
cd/切换到根目录home
cd（后无其他操作时）默认切换到用户的主目录目录soft1
cd~切换到用户的登录目录
4.ls显示当前目录的文件列表
ls不加参数（不区分目录和文件，不会显示隐藏文件）默认
-a显示所有的子文件和子目录ls-a
-l显示详细信息
-al显示所有文件的详细信息
5.touch创建一个文件
touch文件名
6.mkdir创建一个目录
mkdir目录名
mkdir-p可以创建多层目录
7.cp拷贝目录和文件
-r拷贝目录
8.mv剪切目录或文件（不用加-r的选项）
9.rm删除文件或目录
-r删除目录（目录内容全部清空无法找回慎用）
10.rmdir删除目录（删除空目录）
11.vi打开一个文件，如果该文件不存在，就创建该文件
vi打开一个文件有3种状态
1.进入状态，按a，i，o进入编辑状态，
按“：
”进入命令行状态
2.命令行状态
w保存q退出
wq保存退出
setnu显示行号
w新文件名另存为
！
强制!
w强制保存，!
q强制退出
3.编辑状态，按Esc退回到进入状态
练习：
使用vi编辑Message.txt输入个人信息包括：
姓名，年龄，专业，打印出来
hello.c
敲一个程序打印一句话HelloWorld
1.用vi编辑一个.c的文件
2.保存退出，使用gcc编译连接3../a.out运行
在xx.c文件中，由3部分组成
#开头的叫做指令，常见指令，#include#if#define等
include的作用是包含一个文件，一般会包含在/usr/include下的头文件（.h）int
main（）叫函数，main主函数。
在一个程序之中，有且仅有一个主函数
函数由返回类型，函数名。
参数列表（多个参数用“，”隔开）函数体{}
在函数体中的内容叫语句，语句以分号结束
c程序原理:
1，编写一个c程序
2，与处理所有的指令
3，编译生成.o文件
4,连接程序，把库函数的外部资源和.o文件进行连接，生成a.out（可执行文件）文件
a.out
5，加载a.out文件（从硬盘加载到内存）
6,执行a.out文件
gcc（调用编译器，将源程序进行编译，生成文件.c）常用选项
gccHello.c
-c只编译不连接
-o目标文件名，给可执行文件取一个名字（默认的是a.out）
-E仅仅只做预处理
-S生成汇编代码
.....
#include<>只在系统提供的目录里面去找
#include""先在当前目录下查找该头文件，如果没有就去系统指定的目录查找练习编
写一个c程序，用printf函数打印个人信息
注释：
//单行注释
/**/多行注释
c语言的编码规范：
1，语句可以能分开放在多行
2，空格能够更好的区分代码
3，缩进能够更好的区分代码的层次，一般缩进2-4个空格的大小
4，空行能够更好的区代码块
5，变量和函数的名字要有意义，采取驼峰式命名规则或者是下划线命名法：
GameArea
A_name
数据类型：
基本数据类型：
整形：
int（4）short
（2）long（）
实型：
floatdouble
字符型：
char
如何获取数据类型所占字节数
sizeof（类型）sizeof是操作运算符
printf（"%d\n,sizeof（int）"）;变量：
其实就是内存中的一块区域。
变量名就对应这
个区域。
变量定义的格式
类型变量【=初值】；
inta；
inta=10；
inta，b，c；
inta=19，b，c=20；
初始化：
在变量定义的时候就给他一个值。
（区别于赋值：
（在变量定义之后改变它的值）a=20）
标示符：
变量或者函数，宏等实体的名字。
标示符的命名规则：
1，标示符由数字,字符或者下划线组成，其中数字不能是名字的第一个字符。
2，标示
符区分大小写
3，理论上标识符的长度不限，但编译时编译器会自动截断。
4，标示符不能和c语言的关键字同名
关键字
就是c语言自身已经使用的特殊单词，不能被程序员作为标示符，常见关键字：
int，
short，double，struct，break，continue。
。
。
标准输入输出函数
printf可以打印0-n个变量（参数数量可变）
printf（“字符串”）；
printf（格式字符串，表达式1，表达式2。
。
。
）
格式字符串：
普通字符串和转换格式（%d，占位符）
inta=10；
printf（“年龄是%d%d%d\n",a,b,c）;
其中转换格式：
i/d十进制的整数
c字符
chara=cA‟；
printf（“%c”\n）;
scanf（）
s字符串
f浮点型（float，如果你要输出一个double类型的数据，if）
p输出地址
x十六进制整数
o八进制的整数
scanf（）可以从键盘输入0-n个值，存到定义的内存区域
scanf（格式字符串，变量的地址）
inta；
scanf（“%d%d%d”，&a，&c,&d）;
从前向后逐一检查验证输入，遇到不符合类型格式时就返回，并把前面符合格式的存入
变量练习：
计算两个整数，然后程序输出这两个整数的和。
inta，b，c
a=b+c
输出菱形（用*）
第二周
char型的长度为1（一个字节）表示占8个位，（00000000）表示范围（char=256超
出范围）（-128~127）
枚举类型：
为了减少候选个数而存在，
构造类型：
1.数组：
定义格式：
类型数组名【长度】
数组中放的是类型相同的元素，使用的时候最后一个元素的下标是长度减1
注意：
c/c++中不作数组越界检查
二维/多维数组定义格式
类型数组名【长度】【长度】。
。
。
。
结构体：
定义格式：
struct结构体名
{
类型成员1；
类型成员2；
。
。
。
。
}；
访问成员，使用“.”访问成员，
结构体数组：
定义格式：
structSss【长度】
访问结构体数组中的元素成员：
ss【2】.name
联合体：
union
定义格式：
unionU
{
类型成员名；
类型成员名；
类型成员名；
......
}；
用法：
c.,‟联合体变量.成员
注意：
成员之间的相互影响。
指针：
定义格式：
类型*变量名；
赋值：
指针变量名=&同类型变量。
使用指针输入（scanf函数）
inti；
int*p；
scanf（“%d”，p）；或
inti；
scanf（“%d”，&i）；
第三周：
（C语言的灵魂）
指针：
指向数组的指针
int*p;
intarray[10];改：
int*p；
p=&array;intarray【10】
p=array;
注意：
警告：
从不兼容的指针类型赋值
p（整型）
array（数组指针）
类型：
数组名：
实际上是constint*array；
通过指向数组的指针对数组进行操作
*（p+i）=i；
注意：
i与类型有关，每次指针偏移字节
变态程序{与类型有关}时需要i*4偏移
intsize=sizeof（array）/sizeof（array[0]）;
求数组的长度
sizeof（数组名）/sizeof（数组名[0]）；
报错有游离的什么，可能是因为有中文
数组指针：
int（*p）[10];
实际上是一个指针数组，这个数组中的元素和指针类型一样。
指针数组：
int*p[10];
是一个数组，数组中的元素类型是指针，
二级指针：
就是指向指针的指针
inti;
int*pi;
int**ppi;
pi=&i;
ppi=π结构体指针：
structS{....};
structSss；
structS*pss；
pss=&ss；
ss.成员；
pss->成员；
（*pss）.成员；
sizeof（指针）的返回值为
intarray【10】=4*10=40；
doublearray【10】=8*10=80；
指针的长度占4个字节。
c语言的运算符：
1.算术运算符：
+-*/%++--
前++：
先改变值，
后++：
后改变值
注意：
前++：
++i+++i+++i
==
（（++i+++i）+++i）
当i=5时，上式为22，=（7+7）+8=22
（自增操作数必须是左值++++i）
i++++时系统会报错
只能2个++/--使用，不能出现3个的情况i+++
2.关系运算符：
><>=<=!
=
3.逻辑运算符：
||&&!
注意：
&&和||存在短路运算
短路运算符的条件：
&&前为假的时候，会出现短路
||前面为真的时候，会出现短路
*（if中0为假，直接输出0）
4.针对位运算的运算符：
&（位或）|（位与）~（取反）
5.位运算符：
>><<（左移右移）
左移一位乘2，左移两位乘4.
6.字节运算符：
sizeof（）
7.逗号运算：
inta，b；
8.条件运算符（算目运算符）；a>b?
a:
b;（输出最大值）max）;
9.下标运算符：
[]
第四周^（按位异或）（电路相应操作）流程控制语句:
分支语句：
while
（1）；{
printf（）
scanf（）
switch（控制表达式）{
case常量表达式：
语句1；
break；
case常量表达式:
语句2；
default：
语句；
}
return0；
}
退出：
ctrl+c
switch（num）{
case0：
return0；
case1：
语句1；
default：
语句；
}
注意：
1.控制表达式是被当成一个整数来处理，它只能是整数或者是字符，不能是实型
2.case语句可以有多个
3.case里面的语句可以有多条，并且不需要用{}括起来
4.default可以没有
case必须接常量，switch（里必须为整数）
break关键字：
跳出循环体或者一个语句块
循环语句：
while（条件表达式）{
语句；
步进语句；
}
while
（1）；死循环（eg：
年月日检测可以输入多次，避免./a.out）
do-while（）
do{
语句；
}
while（条件表达式）；
for语句：
基本格式：
for（表达式1；表达式2；表达式3；......）
{
循环体；
（break；循环体只执行一次）
}
注意：
表达式3一般为步进语句，表达式可以省略，但是“；”不可省
1.先执行表达式1
2.执行表达式2；
3.执行循环体
4.执行表达式3
5.从第二步开始循环执行2,3,4，步；
条件语句：
if语句
if/else：
如果或者否则
基本结构：
if（表达式）{//如果有且仅有一次
语句1；
}
elseif（表达式）{//或者可以没有，如果可以有0~n个
语句2；
}
else{//否则可以没有
语句3；
}
注意：
0为假，非0为真
if为真，else语句不会执行
1.if语句只能有一个分支语句被执行
2.有else的if语句，必须执行其中一个
3.elseif和else可以出现也可以不出现
4.else总与离它最近的未匹配的
第五周
C语言的函数：
从函数的定义来看：
库函数：
有c语言提供的无需用户自己定义也无需在程序中做类型说明，只需你在使用
的时候加上包含该函数定义的头文件
自定义函数：
用户按照一定的需求自己定义的函数，需要在函数使用之前进行类型说
明。
从函数的功能上可以分为：
有返回值的函数：
在被调用执行之后给调用者返回一个计算结果
没有返回值的函数：
一般是完成某些特定的功能，不需要给调用这返回一个值。
从主调
函数和被调函数之间的数据的传递；
带参函数：
在声明和定义一级被调用时都需要有参数。
不带参数的函数：
函数的一般形式：
类型说明符函数名（）
{
函数体
return【表达式】；
}
空类型：
void
如果通过return函数的类型和函数定义时返回的类型不匹配，一定义时的类型为准，
做一个隐式的类型转换。
函数的调用方式：
intadd（）{}
函数语句：
add（）；
函数表达式：
函数作为表达式的一部分。
intnum=add（）；
函数参数：
把一个函数放在另一个函数的参数位置。
printf（“%d”，add（））；
第六周
用函数实现动态链表：
栈区，堆区和全局数据区：
数据类型：
1.局部变量：
特点：
不初始化则为某一数字或乱码不确定：
存放在栈区的变量
作用域：
从变量的声明位置开始到函数的结束，
voidfunc（）
{
intnum;
.....
}
voidfunc1（）
声明周期：
从变量的声明开始到变量的所在函数结束
2.块变量：
（属于局部变量）
作用域：
从变量的声明位置开始到所在的代码块的结束位置；
声明周期：
从变量的声明位置开始到变量所在代码块结束
全局变量：
存放在全局数据区，
特点：
即使不给改变量初始化，变量的值固定为0；
作用域：
从声明位置开始到本程序结束位置。
声明周期：
从程序开始到程序结束。
*动态开辟内存，不释放则一直存在，
malloc：
在堆区开辟内存
free：
释放指定的那一块内存int*p；
p=（int*）malloc（sizeof（int））；
在堆区为p开辟内存
free（p）；释放p
malloc原型：
（void*）malloc（size_tsize）t：
表示int
栈区存放局部变量
堆区存放
链表：
不一定相邻物理地址
链表：
1.insert（intvalue）；//插入
2.DeleteValue（intvalue）;//全局变量
3.DisplayLink（Node*head）;
4.clearLink（Node*head）;
pnext=null；//避免野指针问题
free（节点内存）；
扩展：
随机函数：
rand（）,srand（）
生成随机数：
1.rand（）；
2.rand（）%10；
3.rand（）%（b-a）+a；9+1
srand（）：
srand（time（NULL））；
#include
rand（）产生的是伪随机数，srand（）函数提供随机数种子，种子不同的话随机数也
就不同，调用srand（time（NULL））
选择排序：
思路：
每一次从待排序列中选择一个最小或者最大的元素，顺序放在排好的数列的最
后，直到全部待排序数列排完。
第七周
linux的基本命令：
ls,mkdir,cd,touch,pwd,
lscdlsmkdir/cd
C基本数据类型：
charshortintlong
实型：
float（单精度）（4）
double（双精度）（8）
结构类型：
数组啊a[i]，结构体struct，
联合union,
指针：
（*）
数据结构：
栈，链表，排序（冒泡，选择）
小技巧：
交换数据：
1.中间变量
2.不用中间变量：
（1）a=a+b；
b=a-b；
a=a-b;
（2）a=a^b;
b=a^b;
a=a^b;
简单文件操作：
流式文件操作：
typedefstruct{
.......
}FILE;
FILE在头文件stdio.h中。
FILE这个结构体中包含了文件操作的基本属性，对文件的操做都要通过这个结构体的指
针来进行。
读文件（打开文件，内容显示）a.txt：
morea.txt
函数：
fopen（"文件名"，"权限字符串"）;
权限字符串：
w打开只写文件，若文件存在
则长度清为0；即该文件的内容会消失。
如果文件不存在，则新建文件。
r打开只读文件，该文件必须存在。
a以附加方式打开只读文件，如果不存在则新建，如果文件存在则写入文件的尾部。
fclose（FILE*file）;
fputc（'X',FILE*file）;写一个字符到文件流中
intfgetc（FILE*file）;从流中读一个字符
fputs（"hello",file）;
fgets（字符串，长度，文件指针）；
从文件流中读一行或者指定字符
char*fgets（char*s,intsize,FILE*stream）;
向文件内写入字符串：
#include
intmain（）
{
FILE*file;//改为a，多次执行时文件内的内容会重复出现
c++
结构体：
structS{.......}；
C:
structSss;C++:
Sss;//定义结构体变量可以省略struct关键字（c++可以兼容c
的定义方式）枚举类型：
在c++中枚举是一种独立的数据类型。
引用：
1.实际上可以理解成一个变量的别名。
2.引用在声明的时候必须初始化。
3.引用一旦初始化就不能再成为别的变量的引用。
4.不能有空引用。
类：
定义模式：
class类名
{
public：
..........
project:
...........
private：
..........
}；
声明：
类名对象名
声明时进行初始化：
类名对象名（.....）;
类有int数据，打印的函数
第八周
C基本数据类型：
指针：
结构类型指针，基本类型指针，
流程控制语句：
whiledo，dowhile，
函数，数据结构，
==============================
C++面向对象的语言
（类的大小取决于类内的数据成员）
三大特征：
封装，继承，多态
封装：
听过访问控制对类型（类或对象）的属性和行
********
构造函数：
自定义的构造函数:
********class类名
{
类名（参数列表）
{.......}
}；
构造函数的作用：
为进行访问限制。
1.分配对象所需要的资源（空间，文件，信号量.......）
2.给成员数据赋初值
析构函数：
（自定义）
class类名
{
~类名（void）
{析构函数体}
}；
注意：
析构函数没有参数，不能重载。
1.对于未定义的析构函数的类，系统会提供一个缺省的析构函数，该析构函数会调用成
员及其基类的析构函数。
2.缺省析构函数不负责释放动态分配的资源。
3.析构函数所释放的资源不仅局限于内存，还包括文件，信号。
。
。
。
重载：
在同一个作用域中，函数名相同，形参列表不同的函数可以有多个，他们构成重
载关系。
注意：
（形参表不同，包括形参的类型和个数，顺序）
Ab;
Aa（b）;//a类型的b对象
拷贝构造函数：
class类名
{
类名（const类型&obj）//obj代表变量
{
可以拷贝的方式从
obj复制成员变量的值
}
}；
//深拷贝和浅拷贝（拓展问题）
使用拷贝构造函数的时机：
用于同类型的对象做初
升级会员 