C++博客-mysileng-随笔分类-杨强linux视频笔记系列

linux高级编程day13 笔记 (转)

鑫龙 — Tue, 29 Jan 2013 10:35:00 GMT

摘要: 回顾：线程与进程 1.进程由于资源独立，进程的主要关注是解决资源共享 2.线程先天是数据共享,线程主要关注共享数据脏 1.互斥量(线程内) 读写锁 2.信号/条件量调度... 阅读全文

鑫龙 2013-01-29 18:35 发表评论

linux高级编程day12 笔记 (转)

鑫龙 — Thu, 17 Jan 2013 06:30:00 GMT

摘要: 一.多线程 1.了解多线程解决多任务实现。历史上Unix服务器不支持多线程 Unix/Linux上实现多线程有两种方式：内核支持多线程 &nb... 阅读全文

鑫龙 2013-01-17 14:30 发表评论

linux高级编程day11 笔记 (转)

鑫龙 — Sun, 13 Jan 2013 03:04:00 GMT

摘要: 回顾：多进程的问题：数据共享。多进程的问题：进程的上下文环境(context) 文件描述符号是整数以及对应上下文环境多进程的问题：上下文环境共享一.SELECT TCP服务器编程模式 1.... 阅读全文

鑫龙 2013-01-13 11:04 发表评论

linux高级编程day10 笔记 (转)

鑫龙 — Thu, 10 Jan 2013 04:49:00 GMT

摘要: 一.TCP的编程模型回顾： UDP模型的UML图 TCP模型的UML图案例1： TCP的服务器（在案例中使用浏览器作为客户程序） socket建立服务器的文件描述符号缓冲 bind把IP地址与端口设置到文件描述符号中 listen负责根据客户连接的不同IP... 阅读全文

鑫龙 2013-01-10 12:49 发表评论

linux高级编程day09 笔记 (转)

鑫龙 — Tue, 08 Jan 2013 04:18:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->struct sembuf { int sem_num;//下标 in... 阅读全文

鑫龙 2013-01-08 12:18 发表评论

linux高级编程day08 笔记 (转)

鑫龙 — Sun, 06 Jan 2013 03:32:00 GMT

摘要: 一.基于文件的通信 1.普通文件(io/mmap) 2.有名管道文件 3.匿名管道 4.Socket二.基于内存的通信 0.一组内核内存的工具 ipcs ipcs -m&nb... 阅读全文

鑫龙 2013-01-06 11:32 发表评论

linux高级编程day07 笔记 (转)

鑫龙 — Sat, 05 Jan 2013 08:03:00 GMT

摘要: 回顾: 1.信号的作用 2.理解信号: 软中断可靠与不可靠信号kill -l 3.信号发送与注册kill/raise alarm setitimer signal 4.信... 阅读全文

鑫龙 2013-01-05 16:03 发表评论

linux高级编程day06 笔记(转)

鑫龙 — Fri, 04 Jan 2013 02:42:00 GMT

摘要: 问题解答： 1.exit(状态码)返回状态码有什么意义? 返回值被系统得到.系统根据状态码进行日志记录. 返回值被调用者得到：system/wait.程序会根据返回状态码进行对应处理。 exit(状态码)=main函数中的return 状态码; &nbs... 阅读全文

鑫龙 2013-01-04 10:42 发表评论

linux高级编程day05 笔记 (转)

鑫龙 — Wed, 02 Jan 2013 03:01:00 GMT

摘要: 一.IO与文件目录管理 1.pread=lseek+read pread读取以后不改变读写位置 2.mmap映射： /proc/${pid}/mem 无法映射 3.IO的有效用户与实际用户默认情况：实际用户与有效用户一致。 &nbs... 阅读全文

鑫龙 2013-01-02 11:01 发表评论

linux高级编程day04 笔记(转)

鑫龙 — Mon, 31 Dec 2012 07:30:00 GMT

摘要: 一.IO与文件映射 1.IO的共享与效率 read与write其中数据缓冲的大小读取数据的缓冲大小：getpagesize。 2.定位与定位读取(随机读取) read与write在操作的时候，自动移动读取位置. lseek改变读取位置. pread/pwr... 阅读全文

鑫龙 2012-12-31 15:30 发表评论

linux高级编程day03 笔记(转)

鑫龙 — Sun, 30 Dec 2012 08:39:00 GMT

一、make与makefile
  1.回顾：
    目标的语法
    目标名：依赖目标
      @命令
      @命令

    make的命令行使用
      make -f make脚本文件目标名
  2.目标的划分
    目标依赖

  3.默认规则：
    a.不指定目标，执行第一个目标
    b.不指定make文件，默认文件是makefile Makefile
      makefile优先
  4.目标的调用规则：(make把目标当成当前文件夹下同名的文件)
    make执行目标：
      搜索与目标相同的文件
      如果文件存在，则判定文件是否被修改过。
文件未被修改，则停止执行，输出提示
文件修改过，则进行执行。（文件不存在属于被修改过范畴）

      比较：当前目标与依赖目标
  5.建议：
    只要有文件输出，就把任务作为一个目标,并且把输出的文件作为目标名。
范例：
input.o:input.c
gcc -c -fpic input.c
libdemo.so:input.o
gcc -shared -olibdemo.so input.o
demo:libdemo.so demo.c
gcc demo.c -ldemo -L. -odemo

6.潜规则(不建议)
适用于:.c目标与.o目标。
    查找.o目标，目标不存在，就把.o替换成.c
    如果.c存在，实施潜规则：直接调用gcc把.c执为.o
  7.变量
    变量名=值值

    $(变量名) ${变量}
  8.伪目标:
    不把目标作为文件处理的目标称为伪目标
    声明伪目标
.PHONY=目标

二、环境变量
  1.使用main的参数
  int main(int args,char *argv[],char **arge)
  {
  }
  命令行参数argv与环境行arge都是字符串数组.
  约定:最后一个字符串是NULL/0
  2.在C的标准库提供:外部变量
   extern char **environ;

#include
#include
extern char **environ;
int main(/*int args,char *argv[],char*arge[]*/)
{
    /*
    while(*arge)
    {
        printf("%s\n",*arge);
        arge++;
    }
    */
    /*
    int i=0;
    while(arge[i])
    {
        printf("%s\n",arge[i]);
        i++;
    }
    */
    while(*environ)
    {
        printf("%s\n",*environ);
        environ++;
    }
}

3.修改获取某个环境变量
getenv/setenv/unsetenv

#include
#include
main()
{
    char *val;
    val=getenv("PATH");
    printf("%s\n",val);
}

三、IO的基础
  1.认识内核对象
    不允许访问内核设备和内存,但可以通过内核系统函数去访问.
    对每个内核对象进行编号ID.
    如果访问内核对象,只能通过ID.
    编程模型:
      申请得到一个ID
      在内核系统函数中使用ID得到对应内核对象数据
  2.怎么访问文件
    使用函数,传递一个文件,系统打开文件,加载文件数据,
    返回一个ID.
    使用函数,传递ID,得到数据.
    使用函数传递ID,告诉系统释放文件.

    ID:文件描述符号.file description (fd)

    每个程序执行的时候都有一个目录,存放打开的文件描述符号
  3.每个程序默认打开三个文件设备:
    0:标准输入
    1:标准输出
    2:错误输出
  4.操作文件描述符号
    ssize_t write(int fd,
     void *buf,//要写入内核对象的数据
     size_t size);//写入数据大小
    返回:
      >0 实际写入的数据
      -1 写入错误
    ssize_t read(int fd,
      void *buf,//返回数据的空间
      size_t size);//空间大小
    返回:
      >0:实际读取的数据
      =0:碰到文件结束符号EOF (ctrl+d)
      -1:读取错误

    建议:
      0:输入
      1:输出
      2:错误输出
课堂练习:
  1.使用write向0 1 2 写数据
  2.使用read从0 1 读取数据,并判定输入的情况,然后根据相应的结果输出提示

#include
#include
main()
{
    //printf("%d\n",getpid());
    //while(1);
    /*
    int r=write(0,"Hello\n",6);
    write(1,"world\n",6);
    write(2,"louis\n",6);
    int a=20;

    write(1,&a,4);
    */
    char buf[32];
    //memset(buf,0,32);
    bzero(buf,32);

    int r=read(0,buf,30);
    printf("实际输入:%d\n",r);
    if(r>0)
    {
        buf[r]=0;
        printf("::%s\n",buf);
    }
    if(r==0)
    {
        printf("ctrl+d\n");
    }
    if(r==-1)
    {
        printf("输入错误!\n");
    }
}

三.基于文件的描述符号
  1.得到文件描述符号/释放文件描述符号
   a.文件类型
    目录文件d
    普通文件f
    字符设备文件c
    块设备文件b
    软连接文件l
    管道文件p
    socket文件s
   b.文件的属性
     1.属性的表达方式:绝对模式（0666类似的八进制数）,字符模式（rwx）
       0    0   0    0
          拥有者   组   其他用户
       0666
     2.文件的权限属性:
       读
       写
       执行
       粘附位权限
       用户设置位权限
       组设置位权限
      0   0         0      0       0
        特殊权限   Owner group 其他用户

       s:
       S
       t
       T
      2.1. s设置位
          2:组设置位
          4:用户设置位
         s对执行有效
         无效的设置位使用S表示

         设置位向其他用户开放拥有者权限的权限.用户设置位
         设置位向其他用户开放组用户权限的权限.组用户设置位
         设置位只对执行程序有意义(执行权限有意义)

      2.2. t设置位
          1:表示沾附位设置
          t对写文件有意义
         没有执行权限的沾附位使用T表示.
         沾附的目的:防止有些权限的用户删除文件.

      程序在执行的时候到底拥有的是执行者用户的权限
      还是文件拥有者的权限.(看setUID)
       程序执行中有两个用户:
          实际用户：标示进程到底是谁
          有效用户：标示进程访问资源的权限
上述一般情况是一样的，有时候被setUID改变
   总结:
     沾附位的作用: 防止其他有写权限用户删除文件
     设置位的作用: 向其他执行者开发组或者用户的权限.
练习:
  1.使用cat创建一个文件
  2.设置沾附位,并观察属性
  3.设置用户设置位, 并观察属性
  4.设置组设置位, 并观察属性
  5.考虑w权限与沾附位的关系
  6.考虑x权限与设置位的关系.

2.通过文件描述符号读写各种数据.
open函数与creat函数

int open(
                    const char *filename,//文件名
                    int flags,//open的方式[创建/打开]
                    mode_t mode//权限(只有创建的时候有效)
                    )

返回:
      >=0:内核文件描述符号.
      =-1:打开/创建失败

    open的方式:
      必选方式:O_RDONLY O_WRONLY O_RDWR,必须选择一个
      创建/打开:O_CREAT
      可选方式:
          对打开可选方式:O_APPEND O_TRUNC(清空数据)
          对创建可选方式:O_EXCL
     组合:
        创建:
          O_RDWR|O_CREAT
          O_RDWR|O_CREAT | O_EXCL

        打开:
          O_RDWR
          O_RDWR|O_APPEND
          O_RDWR|O_TRUNC
     权限:
       建议使用8进制数
    关闭
    void close(int fd);

案例1:
  创建文件
案例2:
  创建文件并写入数据
    20  short float
    tom 20 99.99
    bush 70 65.00
    达内 40 100.00
  注意:
    文件的创建的权限受系统的权限屏蔽的影响
    umask    //显示屏蔽权限.
    umask 0666 //设置权限屏蔽.

    ulimit -a 显示所有的其他限制.

/*创建文件*/
#include
#include
#include
#include <string.h>
main()
{
    int fd;

    char name[20];
    short age;
    float score;
    char sex;

    fd=open("test.dat",
        O_RDWR|O_CREAT|O_EXCL,
);
    if(fd==-1) printf("open error:%m\n"),exit(-1);


    //写第一条
    memcpy(name,"tom",strlen("tom")+1);
    age=20;
    score=99.99;
    sex='F';

    write(fd,name,sizeof(name));
    write(fd,&age,sizeof age);
    write(fd,&score,sizeof(float));
    write(fd,&sex,sizeof(sex));

    //写第二条
    memcpy(name,"Bush",strlen("Bush")+1);
    age=70;
    score=65.00;
    sex='M';
    write(fd,name,sizeof(name));
    write(fd,&age,sizeof age);
    write(fd,&score,sizeof(float));
    write(fd,&sex,sizeof(sex));

    //写第三条

    memcpy(name,"达内",strlen("达内")+1);
    age=10;
    score=99.00;
    sex='F';
    write(fd,name,sizeof(name));
    write(fd,&age,sizeof age);
    write(fd,&score,sizeof(float));
    write(fd,&sex,sizeof(sex));

    close(fd);
}

案例3:
  打开文件读取数据
  重点:
    怎么打开读取
    文件尾的判定

  基本类型的数据读写.

#include
#include
#include
#include

main()
{
    char name[20];
    short age;
    float score;
    char sex;
    int fd;
    int r;
    fd=open("test.dat",O_RDONLY);
    if(fd==-1) printf("open error:%m\n"),exit(-1);

    while(1)
    {
        r=read(fd,name,sizeof(name));
        if(r==0) break;
        r=read(fd,&age,sizeof(short));
        r=read(fd,&score,sizeof(float));
        r=read(fd,&sex,sizeof(sex));
        printf("%s,\t%4hd,\t%.2f,\t%1c\n",
                name,age,score,sex);
    }

    close(fd);
}

案例4:
  结构体读取
  描述:从键盘读取若干条数据,保存到文件
     数据追加

View Code

#include
#include
#include
#include
#include <string.h>
struct stu
{
    int no;
    char name[20];
    float score;
};
/*
.判定文件是否存在,存在打开，不存在创建
.输入记录
.保存记录
.提示继续输入
.继续/不继续
.关闭文件
*/
int openfile(const char *filename)
{
    int fd;
    fd=open(filename,O_RDWR|O_CREAT|O_EXCL,0666);
    if(fd==-1)//表示文件存在,则打开
    {
        fd=open(filename,O_RDWR|O_APPEND);
        return fd;
    }
    return fd;
}
void input(struct stu *record)
{
    bzero(record,sizeof(struct stu));
    printf("输入学号:");
    scanf("%d",&(record->no));
    printf("输入姓名:");
    scanf("%s",record->name);
    printf("输入成绩:");
    scanf("%f",&(record->score));
}
void save(int fd,struct stu *record)
{
    write(fd,record,sizeof(struct stu));
}
int iscontinue()
{
    char c;
    printf("是否继续输入:\n");
    //fflush(stdin);
    //fflush(stdout);
    scanf("\n%c",&c);
    if(c=='Y' || c=='y')
    {
        return 1;
    }
    return 0;
}

int main()
{
    int fd;
    int r;
    struct stu s={0};
    fd=openfile("stu.dat");
    if(fd==-1) printf("openfile:%m\n"),exit(-1);

    while(1)
    {
        input(&s);
        save(fd,&s);
        r=iscontinue();
        if(r==0) break;
        system("clear");
    }
    close(fd);
    printf("输入完毕!\n");
}

3.文件描述符号与重定向
     1.判定文件描述符号与终端的邦定关系
     int isatty(int fd)
     返回非0:fd输出终端
        0:fd输出被重定向
     2.防止重定向
       /dev/tty

#include
#include
#include
#include
#include <string.h>

int main()
{
    int fd;
    printf("Hello\n");
    write(1,"World\n",6);
    fd=open("/dev/tty",O_WRONLY);
    if(isatty(1))
    {
        write(1,"notredir\n",9);
    }
    else
    {
        write(1,"redir\n",6);
    }
    write(fd,"Killer\n",7);
}

总结:
  1.make的多目标依赖规则以及伪目标
  2.文件的创建与打开(了解设置位的作用)
  3.文件的读写(字符串/基本类型/结构体)
  4.了解描述符号与重定向

作业:
  1.完成上课的练习.
  2.写一个程序使用结构体读取1种的数据,
     并全部打印数据,
     并打印平均成绩
  3.写一个程序:
    查询1种的数据.比如:输入姓名,查询成绩
  4.写一个程序,录入保存如下数据:
    书名出版社价格存储量作者
  5.写一个程序负责文件拷贝
    main 存在的文件新的文件名
    要求:
      文件存在就拷贝,不存在提示错误.

鑫龙 2012-12-30 16:39 发表评论

linux高级编程day02 笔记 (转)

鑫龙 — Thu, 27 Dec 2012 05:27:00 GMT

brk/sbrk
维护一个位置。 brk/sbrk改变这个位置。
brk改变绝对位置
sbrk改变相对位置

昨天的补充：
永远记住：C的基本类型就那几种。
所有全新类型都是使用typedef重新定义的。
类型重定义的好处：
1. 维护方便
2. 便于移植（每个系统中都用同一个名，不用修改）
3. 容易理解

一、映射虚拟内存
没有任何额外维护数据的内存分配 mmap/munmap
1. 函数说明：

void *mmap(
void *start, //指定映射的虚拟地址，如果为0，则由系统指定开始位置
size_t length,//指定映射空间的大小。 pagesize的倍数
int prot, //映射的权限 PROT_NONE PROT_READ PROT_WRITE PROT_WRITE PROT_EXEC
int flags, //映射的方式
int fd, //文件描述符号
offset_t off //文件中的映射开始位置（必须是0或pagesezi的倍数）
);

关于映射的方式flags：
内存映射：又叫匿名映射，最后两个参数无效
文件映射：映射到某个文件
只有文件映射，最后两个参数才有效
MAP_ANONYMOUS:内存映射
MAP_SHAREDMAP_PRIVATE：二选一，文件映射

2. 案例：

#include
#include
#include
#include

int main()
{
int *p = mmap(
NULL,
getpagesize(),
PROT_READ|PROT_WRITE,
MAP_ANONYMOUS|MAP_SHARED,
0,
0);
*P = 20;
*(p+1) = 30;
*(p+2) = 40;
printf("%d\n", p[2]); //打印出40
munmap(p, 4096);
}

3. 总结：
选择什么样的内存管理方法？
STL
new

malloc小而多的数据
brk/sbrk同类型的大块数据，动态移动指针
mmap/munmap 控制内存的访问/使用文件映射/控制内存共享

二、编程工具与动态库
1. gcc
2. make
3. gdb
4. 其他工具
5. 动态库（共享库）

1. gcc
-o 输出文件名
-O-O1-O2-O3//编译优化
-g-g1-g2-g3//产生调试信息
-Wallerror//-Wall 显示所有警告-Werror 将警告当成错误提示
-w//关闭所有警告
-c//只编译不连接，产生 .o文件（目标文件）
-E//预编译
-S//汇编。产生 .s文件（汇编文件）

编译4过程是 -E(产生.i) -c(产生.o) -S(产生.s) 自动调用连接器ld

-D//在命令行定义宏（宏可以在代码中定义，也可以在命令行上定义）
-x//指定编译的语言类型 C, C++, .S(汇编)， none（自动判定）
-std=c89 使用标准C89
-std=c99 使用标准C99

三、静态库的编译
1. 编译过程（*.a） a是achieve的缩写
1.1 编译成目标文件
-static 可选
gcc -c -static 代码文件.c //生产可用于归档的目标代码:代码文件.0
1.2 归档成静态库
ar工具（常用-r -t选项）
ar -r 静态库被归档的文件名(上一步代码文件.o)
ar -r add.a add.o
nm工具（查看库中所蕴含的函数列表）
nm 静态库或动态库或目标文件或执行文件
1.3 使用静态库
gcc 代码文件静态库
小例子：
使用静态库完成如下程序
输入一个菱形半径，打印菱形
输入整型封装成IOTool
菱形打印封装成Graphic
计划：
1. 实现输入
2. 实现菱形
3. 编译静态库
4. 调用静态库

//iotool.c
#include
int inputInt(const char *info)
{
int r; //返回值
printf("%s:", info);
scanf("%d", &r);
return r;
}

//graphic.c
#include
void diamond(int r)
{
int x, y;
for(y=0; y<=2*r; y++)
{
for(x=0; x<=2*r; x++)
{
if(y == x+r || y == x-r ||y == -x+r || y == -x+3*r)
{
printf("*");
}
else
{
printf(" ");
}
}
printf("\n");

}
}

编译： gcc -c -static iotool.c

gcc -c -static graphic.c
ar -r demo1.a iotool.o graphic.o
ar -t demo1.a //相当于nm demo1.a

//main.c
main()
{
int r = inputInt("输入菱形半径：");
diamond(r);
}

编译: gcc main.c demo1.a -o main

执行：./main
把静态库作为代码的一部分来编译

总结：
1. 什么是库？
函数等代码封装的二进制已经编译的归档文件
2. ar归档工具
3. 采用库的方式管理代码优点：
容易组织代码
复用
保护代码版权
4. 静态库的“静态”的含义：
编译好的程序运行的时候不依赖库
库作为程序的一部分编译连接
5. 静态库的本质
就是目标文件的集合（归档）
6. -static可选

2. 库的规范与约定
库命名规则：
lib库名.a.主版本号.副版本号.批号
一般就写“lib库名.a”就行了。
ar -r libdemo2.a iotool.o graphic.o
库的使用规则
-l库名
-L库所在的目录
gcc main.c -o main -l demo2 -L.

四、动态库的编译
1. 什么是动态库（共享库）
动态库是可以执行的，静态库不能执行
但动态库没有main，不能独立执行
动态库不会连接成程序的一部分
程序执行时，必须需要动态库文件
2. 工具
ldd查看程序需要调用的动态库，ldd只能查看可执行文件（共享库文件或elf文件）
nm （查看库中的函数符号）
3. 动态库的编译
3.1编译
-c -f pic(可选) (-f 指定文件格式 pic 位置无关代码)
3.2 连接
-shared

编译：gcc -c -fpic iotool.c
gcc -c -fpic graphic.c
(非标准)gcc -shared -odemo3.so iotool.o graphic.o
(标准)gcc -shared -olibdemo4.so iotool.o graphic.o
4. 使用动态库
gcc 代码文件名动态库文件名
gcc 代码文件名 -l库名 -L动态库所在的路径
gcc main.c -ldemo4 -L. -o main

标准命名规则：
lib库名.so
lib库名.a

问题：
4.1 执行程序怎么加载动态库？
4.2 动态库没有作为执行程序的一部分，为什么连接需要制定动态库及目录？
因为连接器需要确认函数在动态库中的位置
动态库的加载：
1. 找到动态库
2. 加载动态库到内存（系统实现）
3. 映射到用户的内存空间（系统实现）
动态库查找规则：
/lib
/user/lib
LD_LIBRARY_PATH环境变量指定的路径中找
设置当前路径为环境变量：（自己定义的库最好设置好目录，或者放到上述公共目录）
export LD_LIBRARY_PATH=.:~:..:~Walle
缓冲机制：
系统把lib:/user/lib:LD_LIBRARY_PATH里的文件加载到缓冲
/sbin/ldconfig -v 刷新缓冲so中的搜索库的路径
小练习：
输入两个数，计算两个数的和。
要求：输入与计算两个数的和封装成动态库调用

五、使用libdl.so库
动态库加载原理
动态库中函数的查找已经封装成哭libdl.so
libdl.so里面有4个函数：
dlopen//打开一个动态库
dlsym//在打开的动态库里找一个函数
dlclose//关闭动态库
dlerror//返回错误

//dldemo.c
#include
main()
{
void *handle = dlopen("./libdemo4.so", RTLD_LAZY);
void (*fun)(int) = dlsym(handle, "diamond");
fun(5);
dlclose(handle);
}

gcc dldemo.c -o main -ldl

ldd main
./main

总结：
1. 编译连接动态库
2. 使用动态库
3. 怎么配置让程序调用动态库
4. 掌握某些工具的使用 nm ldd lddconfig objdump strit(去掉多余的信息)

六、工具make的使用与makefile脚本
背景：
make编译脚本解释
编译脚本makefile
make -f 脚本文件目标
脚本文件：
1. 文本文件（例如 demo.mk）
2. 基本构成语法
基本单位目标target
目标名：依赖目标
\t目标指令
\t目标指令

//demo.mk
demo:iotool.c graphic.c main.c
gcc iotool.c -c
gcc graphic.c -c
gcc iotool.o graphic.o -shared -o libdemo.so
gcc main.c -ldemo -L. -o main
make -f demo.mk demo 会生产main可执行文件

鑫龙 2012-12-27 13:27 发表评论

linux高级编程day01 笔记 (转)

鑫龙 — Wed, 26 Dec 2012 11:55:00 GMT

摘要: 1.malloc怎么分配空间　　　　malloc与new的关系　　　　看完下面的2再回答这个问题。2. linux对内存的结构描述　　　　a) /proc/${pid}/ 存放进程运行时候所有的信息。程序一结... 阅读全文

鑫龙 2012-12-26 19:55 发表评论