LINUXQQ

九月 1, 2009

dup函数

Filed under: C语言 — 标签: — admin @ 9:39 上午

dup函数 :复制文件描述符
相关头文件:#include <unistd.h>
函数表达式:int dup(int filedes);
参数说明:dup的函数参数filedes表示需要复制的文件的文件描述符
返回值说明:如果成功复制一个文件返回新的文件描述符,失败则返回-1
函数功能详解:dup函数总是找到进程文件表中的第一个可用的文件描述符 ,将参数指定的文件描述符 复制到该描述符后 ,返回这个描述符。
函数使用说明:
        dup函数总是将复试的文件描述符复制到进程中第一个可用的文件描述符的位置 ,因此利用这一个特性可以知道进程中最小可用的文件描述符
        dup函数复制的文件必须是一个已经打开的有效文件 。dup函数的参数不能是随便的一个整数,从而避免引起系统混乱。

利用函数dup,我们可以复制一个描述符。传给该函数一个既有的描述符,它就会返回一个新的描述符,
这个新的描述符是传给它的描述符的拷贝。这意味着,这两个描述符共享同一个数据结构。例如,
如果我们对一个文件描述符执行lseek操作,得到的第一个文件的位置和第二个是一样的。

需要注意的是,我们可以在调用fork之前建立一个描述符,这与调用dup建立描述符的效果是一样的,
子进程也同样会收到一个复制出来的描述符。

dup2函数跟dup函数相似,但dup2函数允许调用者规定一个有效描述符和目标描述符的id。dup2函数成功返回时,目标描述符(dup2函数的第二个参数)将变成源描述符(dup2函数的第一个参数)的复制品,换句话说,
两个文件描述符现在都指向同一个文件,并且是函数第一个参数指向的文件。下面我们用一段代码加以说明: ?
int oldfd;
oldfd = open(“app_log”, (O_RDWR | O_CREATE), 0644 );
dup2( oldfd, 1 );
close( oldfd );
注:

dup()或者dup2()主要是将某个特定的文件描述字输出输出的重定向!
他们保证将复制的文件描述字到当前未打开的最小描述字!
标准输出对应着1,
close(1);
dup(fd);
close(fd);
先关掉了标准输出,那么这个描述字就空闲着,你一旦dup就重定向到他了,他们两共享同一个打开的文件表项,然后你将输出标准流到它现在指定的地方,也就是那个文件!
建议使用dup2(),上面的你那个改为
dup2(fd,STDOUT_FILENO);
这样好看多了吧?
本例中,我们打开了一个新文件,称为“app_log”,并收到一个文件描述符,该描述符叫做fd1。我们调用dup2函数,
参数为oldfd和1,这会导致用我们新打开的文件描述符替换掉由1代表的文件描述符(即stdout,因为标准输出文件的id为1)。
任何写到stdout的东西,现在都将改为写入名为“app_log”的文件中。

需要注意的是,dup2函数在复制了oldfd之后,会立即将其关闭,但不会关掉新近打开的文件描述符,因为文件描述符1现在也指向它。

下面我们介绍一个更加深入的示例代码:

1: #include <stdio.h>
 2: #include <stdlib.h>
3: #include <unistd.h>
 4:
 5: int main()

6: {
7: int pfds[2];
 8:
 9: if ( pipe(pfds) == 0 ) …{ //建立一个管道
 10:

 11: if ( fork() == 0 ) …{ //子进程
12:
13: close(1); //关闭stdout描述符
 14: dup2( pfds[1], 1 ); //把stdout重定向到管道(pfds[1])
 15: close( pfds[0] ); //关掉管道的输入端
 16: execlp( “ls”, “ls”, “-1″, NULL ); //把子进程的映像替换为命令ls –1的进程映像
 17:
18: }else …{ //父进程
 19:
 20: close(0); //关闭stdin描述符
 21: dup2( pfds[0], 0 ); //让stdin变成管道的输出端
 22: close( pfds[1] ); //关闭管道的stdout端(pfds[1])
 23: execlp( “wc”, “wc”, “-l”, NULL ); //把父进程的映像替换为命令wc -1的进程映像
 24:
 25: }
 26:
 27: }
 28:
 29: return 0;
 30: }

我们将ls –1命令的标准输出作为标准输入,连接到wc –l命令

首先在第9行代码中建立一个管道,然后将应用程序分成两个进程:一个子进程和一个父进程。

在子进程中首先关闭stdout描述符(第13行),然后提供了ls –1命令功能,
不过它不是写到stdout(第13行),而是写到我们建立的管道的输入端,这是通过dup函数来完成重定向的。

在第14行,使用dup2 函数把stdout重定向到管道(pfds[1])。之后,马上关掉管道的输入端。然后,使用execlp函数把子进程的映像替换为命令ls –1的进程映像,一旦该命令执行,它的任何输出都将发给管道的输入端。
现在来研究一下管道的接收端 。从代码中可以看出,管道的接收端是由父进程来担当的

首先关闭stdin描述符(第20行),因为我们不会从机器的键盘等标准设备文件来接收数据的输入,而是从其它程序的输出中接收数据。然后,再一次用到dup2函数(第21行),让stdin变成管道的输出端,这是通过让文件描述符0(即常规的stdin)等于pfds[0]来实现的。关闭管道的stdout端(pfds[1]),
因为在这里用不到它。最后,使用 execlp函数把父进程的映像替换为命令wc -1的进程映像,命令wc -1把管道的内容作为它的输入(第23行)。

在该程序中,需要格外关注的是,我们的子进程把它的输出重定向的管道的输入 ,然后,父进程将它的输入重定向到管道的输出。
这在实际的应用程序开发中是非常有用的一种技术。

1. 文件描述符在内核中数据结构
 在具体说dup/dup2之前, 我认为有必要先了解一下文件描述符在内核中的形态。
一个进程在此存在期间,会有一些文件被打开,从而会返回一些文件描述符,

从shell中运行一个进程, 默认会有3个文件描述符存在(0、1、2) ,

0与进程的标准输入相关联,
1与进程的标准输出相关联,

2与进程的标准错误输出相关联,

一个进程当前有哪些打开的文件描述符可以通过/proc/进程ID/fd目录查看 。 下图可以清楚的说明问题:

 进程表项

————————————————
   fd标志 文件指针
 _____________________
fd 0:|________|____________|————> 文件表
fd 1:|________|____________|

fd 2:|________|____________|

fd 3:|________|____________|

| ……. |

 |_____________________|

 图1

文件表中包含:文件状态标志、当前文件偏移量、v节点指针,这些不是本文讨论的
重点,我们只需要知道:

每个打开的文件描述符(fd标志)在进程表中都有自己的文件表项,由文件指针指向

2. dup/dup2函数
APUE和man文档都用一句话简明的说出了这两个函数的作用:复制一个现存的文件描述符。
#include <unistd.h>
int dup(int oldfd);
int dup2(int oldfd, int newfd);

从图1来分析这个过程,当调用dup函数时,内核在进程中创建一个新的文件描述符,此
描述符是当前可用文件描述符的最小数值,这个文件描述符指向oldfd所拥有的文件表项。
  进程表项

————————————————

  fd标志 文件指针

 _____________________

fd 0:|________|____________| ______

fd 1:|________|____________|—————-> | |

fd 2:|________|____________| |文件表|

fd 3:|________|____________|—————-> |______|

 | ……. |

 |_____________________|

 图2:调用dup后的示意图
如图2 所示,假如oldfd的值为1, 当前文件描述符的最小值为3, 那么新描述符3指向
描述符1所拥有的文件表项。

dup2和dup的区别就是可以用newfd参数指定新描述符的数值,

如果newfd已经打开,则先将其关闭。

如果newfd等于oldfd,则dup2返回newfd, 而不关闭它。dup2函数返回的新
文件描述符同样与参数oldfd共享同一文件表项。
APUE用另外一个种方法说明了这个问题:
实际上,调用dup(oldfd);
等效与
? fcntl(oldfd, F_DUPFD, 0)
而调用dup2(oldfd, newfd);
等效与
 close(oldfd);
 fcntl(oldfd, F_DUPFD, newfd);

八月 26, 2009

信号屏蔽字

Filed under: C语言 — 标签: — admin @ 4:06 下午

 

四、信号屏蔽字:

有时候我们希望进程正确的执行,而不想进程受到信号的影响,比如我们希望上面那个程序在1秒钟之后不结束。这个时候我们就要进行信号的操作了。

信号操作最常用的方法是信号屏蔽。信号屏蔽要用到下面的几个函数。

sigemptysetsigfillsetsigaddsetsigdelsetsigismembersigprocmask。下面对他们分别进行讲解。

 

8

名称:

sigemptyset/sigfillset/sigaddset/sigdelset/sigismember

功能

处理信号集

头文件

#include <signal.h>

函数原形:

int sigemptyset(sigset_t *set);

int sigfillset(sigset_t *set);

int sigaddset(sigset_t *set,int signum);

int sigdelset(sigset_t *set,int signum);

int sigismember(const sigset_t *set,int signum);

参数:

set 信号集

signum 信号

返回值:

若成功返回0,若出错返回-1

若真返回1,若假返回0,若出错返回-1 sigismember

      

 

 

 

 

 

 

 

 

 我们需要有一个能表示多个信号—信号集的数据类型。我们将在诸如sigprocmask之类的函数中使用这种数据类型,以便告诉内核不允许发生该信号集中的信号。上面的5个函数可以对信号集进行处理。

函数sigemptyset 初始化由set指向的信号集,清除其中所有信号。函数sigfillset初始化由set指向的信号集,使其包含所有信号。所以信号在使用信号集前,要对信号集调用sigemptysetsigfillset一次。

函数sigaddset 将一个信号添加到现有集中,sigdelset则从信号集中删除一个信号。对所有以信号集作为参数的函数,我们总是以信号集地址作为其传送的参数。

       sigismember查询信号是否在信号集合之中。

下面的例子:

/*10_7.c*/

#include <stdio.h>

#include <signal.h>

 

main()

{

sigset_t *set;

set=(sigset_t*)malloc(sizeof(set));

 

sigemptyset(set);/*初始化信号集*/

sigaddset(set,SIGUSR1);/*添加信号SIGUSR1到信号集中*/

sigaddset(set,SIGINT);/*添加信号SIGUSR2到信号集中*/

 

if((sigismember(set,SIGUSR1))==1)/*测试信号SIGUSR1是否在信号集中*/

    printf(“SIGUSR1\n”);

if((sigismember(set,SIGUSR2))==1)

    printf(“SIGUSR2\n”);

if((sigismember(set,SIGINT))==1)

    printf(“SIGINT\n”);

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

下面是执行结果:

# ./10_7

SIGUSR1

SIGINT

程序先初始化信号集,清除其中所有信号,然后把SIGUSR1SIGINT添加到信号集中,然后测试SIGUSR1SIGUSR2SIGINT信号是否在信号集中。因为SIGUSR2不在信号集中,所以程序并不打印SIGUSR2

 

9

名称:

sigprocmask

功能

检测或更改信号屏蔽字

头文件

#include <signal.h>

函数原形

int sigprocmask(int how,const sigsett_t *set,sigset_t *oldset);

参数:

how  操作方式

set   信号集

oldest

返回值:

若成功返回0,若出错返回-1

 

 

 

 

 

 

 

 

 

 

 

 

每个进程都有一个用来描述哪些信号递送到进程时将被阻塞的信号集,该信号集中的所有信号在递送到进程后都将被阻塞。

sigprocmask是最为关键的一个函数。在使用之前要先设置好信号集合set。这个函数的作用是将指定的信号集合set加入到进程的信号阻塞集合之中去,如果提供了oldset那么当前的进程信号阻塞集合将会保存在oldset里面。参数how决定函数的操作方式。

SIG_BLOCK:增加一个信号集合到当前进程的阻塞集合之中。

SIG_UNBLOCK:从当前的阻塞集合之中删除一个信号集合。

SIG_SETMASK:将当前的信号集合设置为信号阻塞集合。

 

我们把10_7.c稍微修改一下,看看sigprocmask函数的功能。

/*10_8.c*/

#include <stdio.h>

#include <signal.h>

 

main()

{

sigset_t *set;

set=(sigset_t*)malloc(sizeof(set));

 

sigemptyset(set);/*定义信号集set*/

sigaddset(set,SIGINT);/*把信号SIGINT添加到信号集中*/

sigprocmask(SIG_SETMASK,set,NULL);/*set设置为信号阻塞集合*/

wile(1);/*死循环*/

}

程序先定义信号集set,然后把信号SIGINT添加到set信号集中,最后把set设置为信号阻塞集合。当我们运行程序时,进程进入死循环。我们按“ctrl+c”系统并没有中断程序,因为我们已经把SIGINT信号屏蔽掉了。我们可以按”ctrl+z”来结束程序。

sigeprocmask函数通常和sigemptyset/sigfillset/sigaddset/sigdelset/sigismember函数配合使用,主要有两种用途:

1.我们不希望某些不太重要的信号来影响我们的进程,我们就可以把这些信号添加到信号屏蔽集中。使它们不打扰进程的执行。

2.如果系统现在很忙,没有时间及时相应信号,进程可以先把信号阻塞掉,等系统有空闲时间在去相应,这也保证了信号的可靠性。下面的函数可以做到这一点。

 

10

名称:

sigpending

功能:

返回信号集

头文件:

#include <signal.h>

函数原形:

int sigpending(sigset_t *set);

参数:

 

返回值:

若成功返回0,若出错返回-1

 

 

 

 

 

 

 

 

 

我们要注意的是,阻塞信号并不是丢弃信号,它们被保存在一个进程的信号阻塞队列里,sigpending可以获得当前已递送到进程,却被阻塞的所有信号,在set指向的信号集中返回这些信号。

 

下面是一个例子:

/*10_9.c*/

#include <stdio.h>

#include <signal.h>

#include <stdlib.h>

 

int main(void)

{

sigset_t newmask,oldmask,pendmask;

 

sigemptyset(&newmask);  /*初始化信号集*/

sigaddset(&newmask,SIGINT);  /*添加信号SIGINT到信号集*/

if(sigprocmask(SIG_BLOCK,&newmask,&oldmask)<0)  /*信号集newmask设置为阻塞信号集*/

    perror(“error”);

sleep(5);

if(sigpending(&pendmask)<0)  /*把当前已递送到进程,却被阻塞的信号保存到进程的信号阻塞队列里*/

    perror(“error”);

if(sigismember(&pendmask,SIGINT))  /*检测进程阻塞队列里是否有SIGINT信号*/

    printf(“\nSIGINT pending\n”);

 

exit(0);

}

 

程序开始运行,如果我们在5秒钟内按”ctrl+c”,SIGINT信号会被传递到进程,但是由于进程设置了信号阻塞集,信号SIGINT在这个集合中,所有这个信号被阻塞。并由sigpend保存到进程的信号阻塞队列pendmask.然后我们用sigismember检测SIGINT是否在信号阻塞队列pendmask里。

 

七月 3, 2009

linux下C 文件操作

Filed under: C语言 — 标签: — admin @ 10:39 上午

前言: 
    我们在这一节将要讨论linux下文件操作的各个函数. 
1.文件的创建和读写 
2.文件的各个属性 
3.目录文件的操作 
4.管道文件 

——————————————————————————–
1。文件的创建和读写 
    我假设你已经知道了标准级的文件操作的各个函数(fopen,fread,fwrite等等).当然如果你不清楚的话也不要着急.我们讨论的系统级的文件操作实际上是为标准级文件操作服务的. 
当我们需要打开一个文件进行读写操作的时候,我们可以使用系统调用函数open.使用完成以后我们调用另外一个close函数进行关闭操作. 
#include 
#include 
#include 
#include 

int open(const char *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);

int close(int fd);

open函数有两个形式.其中pathname是我们要打开的文件名(包含路径名称,缺省是认为在当前路径下面).flags可以去下面的一个值或者是几个值的组合. 
O_RDONLY:以只读的方式打开文件. 
O_WRONLY:以只写的方式打开文件. 
O_RDWR:以读写的方式打开文件. 
O_APPEND:以追加的方式打开文件. 
O_CREAT:创建一个文件. 
O_EXEC:如果使用了O_CREAT而且文件已经存在,就会发生一个错误. 
O_NOBLOCK:以非阻塞的方式打开一个文件. 
O_TRUNC:如果文件已经存在,则删除文件的内容. 
前面三个标志只能使用任意的一个.如果使用了O_CREATE标志,那么我们要使用open的第二种形式.还要指定mode标志,用来表示文件的访问权限.mode可以是以下情况的组合. 
—————————————————————–
S_IRUSR 用户可以读 S_IWUSR 用户可以写
S_IXUSR 用户可以执行 S_IRWXU 用户可以读写执行
—————————————————————–
S_IRGRP 组可以读 S_IWGRP 组可以写
S_IXGRP 组可以执行 S_IRWXG 组可以读写执行
—————————————————————–
S_IROTH         其他人可以读    S_IWOTH         其他人可以写
S_IXOTH         其他人可以执行  S_IRWXO         其他人可以读写执行
—————————————————————–
S_ISUID 设置用户执行ID  S_ISGID 设置组的执行ID
—————————————————————–
我们也可以用数字来代表各个位的标志.Linux总共用5个数字来表示文件的各种权限.
00000.第一位表示设置用户ID.第二位表示设置组ID,第三位表示用户自己的权限位,第四位表示组的权限,最后一位表示其他人的权限.
每个数字可以取1(执行权限),2(写权限),4(读权限),0(什么也没有)或者是这几个值的和.
比如我们要创建一个用户读写执行,组没有权限,其他人读执行的文件.设置用户ID位那么我们可以使用的模式是–1(设置用户ID)0(组没有设置)7(1+2+4)0(没有权限,使用缺省)5(1+4)即10705:
open(“temp”,O_CREAT,10705);
如果我们打开文件成功,open会返回一个文件描述符.我们以后对文件的所有操作就可以对这个文件描述符进行操作了.
当我们操作完成以后,我们要关闭文件了,只要调用close就可以了,其中fd是我们要关闭的文件描述符.
文件打开了以后,我们就要对文件进行读写了.我们可以调用函数read和write进行文件的读写.
#include 

ssize_t  read(int fd, void *buffer,size_t count);
ssize_t write(int fd, const void *buffer,size_t count);

fd是我们要进行读写操作的文件描述符,buffer是我们要写入文件内容或读出文件内容的内存地址.count是我们要读写的字节数.
对于普通的文件read从指定的文件(fd)中读取count字节到buffer缓冲区中(记住我们必须提供一个足够大的缓冲区),同时返回count.
如果read读到了文件的结尾或者被一个信号所中断,返回值会小于count.如果是由信号中断引起返回,而且没有返回数据,read会返回-1,且设置errno为EINTR.当程序读到了文件结尾的时候,read会返回0.
write从buffer中写count字节到文件fd中,成功时返回实际所写的字节数.
下面我们学习一个实例,这个实例用来拷贝文件.

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUFFER_SIZE 1024

int main(int argc,char **argv)
{
 
 int from_fd,to_fd;
 int bytes_read,bytes_write;
 char buffer[BUFFER_SIZE];
 char *ptr;

 if(argc!=3)
  {
fprintf(stderr,”Usage:%s fromfile tofile\n\a”,argv[0]);
exit(1);
  }

/* 打开源文件 */

 if((from_fd=open(argv[1],O_RDONLY))==-1)
  {
fprintf(stderr,”Open %s Error:%s\n”,argv[1],strerror(errno));
exit(1);
 }

/* 创建目的文件 */

 if((to_fd=open(argv[2],O_WRONLY|O_CREAT,S_IRUSR|S_IWUSR))==-1)
  {
        fprintf(stderr,”Open %s Error:%s\n”,argv[2],strerror(errno));
        exit(1);
 }
 
/* 以下代码是一个经典的拷贝文件的代码 */

 while(bytes_read=read(from_fd,buffer,BUFFER_SIZE))
 {
/* 一个致命的错误发生了 */
   if((bytes_read==-1)&&(errno!=EINTR)) break;
   else if(bytes_read>0)
       {
  ptr=buffer;
  while(bytes_write=write(to_fd,ptr,bytes_read))
   {
/* 一个致命错误发生了 */
     if((bytes_write==-1)&&(errno!=EINTR))break;
/* 写完了所有读的字节 */
     else if(bytes_write==bytes_read) break;
/* 只写了一部分,继续写 */
     else if(bytes_write>0)
           {
      ptr+=bytes_write;
   bytes_read-=bytes_write;
          }
          }
/* 写的时候发生的致命错误 */
         if(bytes_write==-1)break;

       }
  }
 close(from_fd);
 close(to_fd);
 exit(0);
}

2。文件的各个属性
    文件具有各种各样的属性,除了我们上面所知道的文件权限以外,文件还有创建时间,大小等等属性.
有时侯我们要判断文件是否可以进行某种操作(读,写等等).这个时候我们可以使用access函数.
#include 

int access(const char *pathname,int mode);

pathname:是文件名称,mode是我们要判断的属性.可以取以下值或者是他们的组合.
R_OK文件可以读,W_OK文件可以写,X_OK文件可以执行,F_OK文件存在.当我们测试成功时,函数返回0,否则如果有一个条件不符时,返回-1.
如果我们要获得文件的其他属性,我们可以使用函数stat或者fstat.
#include 
#include 

int stat(const char *file_name,struct stat *buf);
int fstat(int filedes,struct stat *buf);

struct stat {
dev_t st_dev; /* 设备   */
ino_t st_ino; /* 节点   */
mode_t st_mode; /* 模式   */
nlink_t st_nlink; /* 硬连接 */
uid_t st_uid; /* 用户ID */
gid_t st_gid; /* 组ID   */
dev_t st_rdev; /* 设备类型 */
off_t st_off; /* 文件字节数 */
unsigned long  st_blksize; /* 块大小 */
unsigned long st_blocks; /* 块数   */
time_t st_atime; /* 最后一次访问时间 */
time_t st_mtime; /* 最后一次修改时间 */
time_t st_ctime; /* 最后一次改变时间(指属性) */
};

stat用来判断没有打开的文件,而fstat用来判断打开的文件.我们使用最多的属性是st_mode.通过着属性我们可以判断给定的文件是一个普通文件还是一个目录,连接等等.可以使用下面几个宏来判断.
S_ISLNK(st_mode):是否是一个连接.S_ISREG是否是一个常规文件.S_ISDIR是否是一个目录S_ISCHR是否是一个字符设备.S_ISBLK是否是一个块设备S_ISFIFO是否 是一个FIFO文件.S_ISSOCK是否是一个SOCKET文件. 我们会在下面说明如何使用这几个宏的.
3。目录文件的操作
    在我们编写程序的时候,有时候会要得到我们当前的工作路径。C库函数提供了getcwd来解决这个问题。
#include 

char *getcwd(char *buffer,size_t size);

我们提供一个size大小的buffer,getcwd会把我们当前的路径考到buffer中.如果buffer太小,函数会返回-1和一个错误号.
Linux提供了大量的目录操作函数,我们学习几个比较简单和常用的函数.
#include 
#include 
#include 
#include 
#include 

int mkdir(const char *path,mode_t mode);
DIR *opendir(const char *path);
struct dirent *readdir(DIR *dir);
void rewinddir(DIR *dir);
off_t telldir(DIR *dir);
void  seekdir(DIR *dir,off_t off);
int closedir(DIR *dir);

struct dirent {
long  d_ino;
off_t  d_off;
unsigned short d_reclen;
char  d_name[NAME_MAX+1]; /* 文件名称 */

mkdir很容易就是我们创建一个目录,opendir打开一个目录为以后读做准备.readdir读一个打开的目录.rewinddir是用来重读目录的和我们学的rewind函数一样.closedir是关闭一个目录.telldir和seekdir类似与ftee和fseek函数.
下面我们开发一个小程序,这个程序有一个参数.如果这个参数是一个文件名,我们输出这个文件的大小和最后修改的时间,如果是一个目录我们输出这个目录下所有文件的大小和修改时间.

#include 
#include 
#include 
#include 
#include 
#include 
#include 

static int get_file_size_time(const char *filename)
{
 struct stat statbuf;
 
 if(stat(filename,&statbuf)==-1)
  {
printf(“Get stat on %s Error:%s\n”,
filename,strerror(errno));
return(-1);
  }
  
 if(S_ISDIR(statbuf.st_mode))return(1);
 if(S_ISREG(statbuf.st_mode))
printf(“%s size:%ld bytes\tmodified at %s”,
filename,statbuf.st_size,ctime(&statbuf.st_mtime)); 

 return(0);
}

int main(int argc,char **argv)
{
 DIR *dirp;
 struct dirent *direntp; 
 int stats;

 if(argc!=2)
  {
printf(“Usage:%s filename\n\a”,argv[0]);
exit(1);
  }

 if(((stats=get_file_size_time(argv[1]))==0)||(stats==-1))exit(1);
 
 if((dirp=opendir(argv[1]))==NULL)
 {
printf(“Open Directory %s Error:%s\n”,
argv[1],strerror(errno));
exit(1);
 }

 while((direntp=readdir(dirp))!=NULL)
   if(get_file_size_time(direntp- closedir(dirp);
 exit(1);
}

4。管道文件
    Linux提供了许多的过滤和重定向程序,比如more cat
等等.还提供了< > | <<等等重定向操作符.在这些过滤和重 定向程序当中,都用到了管道这种特殊的文件.系统调用pipe可以创建一个管道.
#include

int pipe(int fildes[2]);

pipe调用可以创建一个管道(通信缓冲区).当调用成功时,我们可以访问文件描述符fildes[0],fildes[1].其中fildes[0]是用来读的文件描述符,而fildes[1]是用来写的文件描述符.
在实际使用中我们是通过创建一个子进程,然后一个进程写,一个进程读来使用的.
关于进程通信的详细情况请查看进程通信

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define  BUFFER 255

int main(int argc,char **argv)
{
  char buffer[BUFFER+1];
  int fd[2];

  if(argc!=2)
  {
fprintf(stderr,”Usage:%s string\n\a”,argv[0]);
exit(1);
  }

  if(pipe(fd)!=0)
  {
fprintf(stderr,”Pipe Error:%s\n\a”,strerror(errno));
exit(1);
  }
  if(fork()==0)
   {
close(fd[0]);
printf(“Child[%d] Write to pipe\n\a”,getpid());
snprintf(buffer,BUFFER,”%s”,argv[1]);
write(fd[1],buffer,strlen(buffer));
printf(“Child[%d] Quit\n\a”,getpid());
exit(0);
   }
 else
  {
close(fd[1]);
printf(“Parent[%d] Read from pipe\n\a”,getpid());
memset(buffer,’\0′,BUFFER+1);
read(fd[0],buffer,BUFFER);
printf(“Parent[%d] Read:%s\n”,getpid(),buffer);
   exit(1);
  }
}

为了实现重定向操作,我们需要调用另外一个函数dup2.
#include 

int dup2(int oldfd,int newfd);

dup2将用oldfd文件描述符来代替newfd文件描述符,同时关闭newfd文件描述符.也就是说,
所有向newfd操作都转到oldfd上面.下面我们学习一个例子,这个例子将标准输出重定向到一个文件.

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define  BUFFER_SIZE 1024

int main(int argc,char **argv)
{
 int fd;
 char buffer[BUFFER_SIZE];

 if(argc!=2)
  {
fprintf(stderr,”Usage:%s outfilename\n\a”,argv[0]);
exit(1);
  }

 if((fd=open(argv[1],O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR))==-1)
  {
  fprintf(stderr,”Open %s Error:%s\n\a”,argv[1],strerror(errno));
exit(1);
  }

 if(dup2(fd,STDOUT_FILENO)==-1)
  {
fprintf(stderr,”Redirect Standard Out Error:%s\n\a”,strerror(errno));
exit(1);
  }

 fprintf(stderr,”Now,please input string”);
 fprintf(stderr,”(To quit use CTRL+D)\n”);  
 while(1)
  {
    fgets(buffer,BUFFER_SIZE,stdin); 
    if(feof(stdin))break;
    write(STDOUT_FILENO,buffer,strlen(buffer));
 }
 exit(0);
}

好了,文件一章我们就暂时先讨论到这里,学习好了文件的操作我们其实已经可以写出一些比较有用的程序了.我们可以编写一个实现例如dir,mkdir,cp,mv等等常用的文件操作命令了.
想不想自己写几个试一试呢?

六月 15, 2009

fprintf函数

Filed under: C语言 — 标签: — admin @ 10:27 上午

查了一下man手册,fprintf函数的原型如下:
     int fprintf(FILE *stream, const char *format, …);
      FILE *fp=NULL;
     fp=fopen(HTTP_CONF_FILE,”w”);
     if (fp==NULL){
         err(“fopen() error,file:%s!!!\n”,HTTP_CONF_FILE);
         return FAILURE;
     }
     fprintf(fp,”ServerRoot \”%s\”\r\n”,HTTP_SERVER_ROOT);
     fprintf(fp,”Listen %u\r\n”,http_setup->net.http_port);
     fprintf(fp,”\r\n”);
首先是生命一个FILE类型的流文件指针,调用fopen打开文件并执行写的操作, 然后调用fprintf将配置文件按照Appweb规定的格式写入。

六月 14, 2009

文件I/O函数(fcntl)

Filed under: C语言 — 标签: — admin @ 7:43 下午

fcntl函数:int
fcntl(int filedes, int cmd, …/*int arg */);
返回:若成功则依赖于cmd,若出错为-1。
作用:可以改变已打开的文件的性质
下列三个命令有特定的返回值:F_DUPFD,F_GETFD以及F_GETOWN。第一个返回新的文件描述符,第二个返回相应标志,最后一个返回一个正的进程ID或负的进程组ID。
第三个参数总是一个整数,当然在作为记录锁用时,第三个参数则是指向一个结构的指针。
fcntl函数有五种功能:
(1)复制一个现存的描述符(cmd=F_DUPFD)
(2)获得/设置文件描述符标志(cmd=F_GETFD或F_SETFD)
(3)获得/设置文件状态标志(cmd=F_GETFL或F_SETFL)
(4)获得/设置异步I/O有权(cmd=F_GETOWN或F_SETOWN)
(5)获得/设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW)
F_DUPFD:复制文件描述符filedes,新文件描述符作为函数值返回。它是尚未打开的各描述符中大于或等于第三个参数值中各值的最小值。新描述符与filedes共享同一文件表项。但是新描述符有它自己的一套文件描述符标志,其FD_CLOEXEC文件描述符标志被清除。
F_GETFD:对应于filedes的文件描述符标志作为函数值返回。当前只定义了一个文件描述符标志FD_CLOEXEC。
F_SETFD:对于filedes设置文件描述符标志。新标志值按第三个参数设置。
F_GETFL:对应于filedes的文件状态标志作为函数返回。在说明open函数时,已说明了文件状态标志。
F_SETFL:将文件状态标志设置为第三个参数的值(取整数值),可以更改的几个标志:O_APPEND,O_NONBLOCK,O_SYNC和O_ASYNC。
F_GETOWN:取当前接受SIGIO和SIGURG信号的进程ID或进程组ID。
F_SETOWN:设置接受SIGIO和SIGURG信号的进程ID或进程组ID。正的arg指定一个进程ID,负的arg表示等于arg绝对值的一个进程组ID。
范例:
#include

#include

#include

#include

int
main(int argc, char **argv)
{
int
fd;
int
var;
if(argc!=2)
{
printf(“please
input filename and one arg!\n”);
exit(1);
}

if((var=fcntl(atoi(argv[1]),F_GETFL,0))==-1)
{
printf(“fcntl
file error!\n”);
exit(1);
}
printf(“%d\n”,var);
switch(var
& O_ACCMODE)
{
case
O_RDONLY:printf(“Read only.\n”);
break;
case
O_WRONLY:printf(“Write only.\n”);
break;
case
O_RDWR: printf(“Read Write.\n”);
break;
default:break;
}
exit(0);
}

Linux下的管道编程技术-dup函数和dup2函数

Filed under: C语言 — 标签: — admin @ 5:25 下午

       dup和dup2也是两个非常有用的调用,它们的作用都是用来复制一个文件的描述符。它们经常用来重定向进程的stdin、stdout和stderr。这两个函数的原型如下所示:
#include
int dup( int oldfd );
int dup2( int oldfd, int targetfd )
利用函数dup,我们可以复制一个描述符。传给该函数一个既有的描述符,它就会返回一个新的描述符,这个新的描述符是传给它的描述符的拷贝。这意味着,这两个描述符共享同一个
数据结构
。例如,如果我们对一个文件描述符执行lseek操作,得到的第一个文件的位置和第二个是一样的。下面是用来说明dup函数使用方法的代码片段:
int fd1, fd2;

fd2 = dup( fd1 );
需要注意的是,我们可以在调用fork之前建立一个描述符,这与调用dup建立描述符的效果是一样的,子进程也同样会收到一个复制出来的描述符。

dup2函数跟dup函数相似,但dup2函数允许调用者规定一个有效描述符和目标描述符的id。dup2函数成功返回时,目标描述符(dup2函数的第
二个参数)将变成源描述符(dup2函数的第一个参数)的复制品,换句话说,两个文件描述符现在都指向同一个文件,并且是函数第一个参数指向的文件。下面
我们用一段代码加以说明:
    int oldfd;
oldfd = open(“app_log”, (O_RDWR | O_CREATE), 0644 );
dup2( oldfd, 1 );
close( oldfd );

本例中,我们打开了一个新文件,称为“app_log”,并收到一个文件描述符,该描述符叫做fd1。我们调用dup2函数,参数为oldfd和1,这会
导致用我们新打开的文件描述符替换掉由1代表的文件描述符(即stdout,因为标准输出文件的id为1)。任何写到stdout的东西,现在都将改为写
入名为“app_log”的文件中。需要注意的是,dup2函数在复制了oldfd之后,会立即将其关闭,但不会关掉新近打开的文件描述符,因为文件描述
符1现在也指向它。
下面我们介绍一个更加深入的示例代码。回忆一下本文前面讲的命令行管道,在那里,我们将ls –1命令的标准输出作为标准输入连接到wc –l命令。接下来,我们就用一个C程序来加以说明这个过程的实现。代码如下面的示例代码3所示。

在示例代码3中,首先在第9行代码中建立一个管道,然后将应用程序分成两个进程:一个子进程(第13–16行)和一个父进程(第20–23行)。接下来,
在子进程中首先关闭stdout描述符(第13行),然后提供了ls
–1命令功能,不过它不是写到stdout(第13行),而是写到我们建立的管道的输入端,这是通过dup函数来完成重定向的。在第14行,使用dup2
函数把stdout重定向到管道(pfds[1])。之后,马上关掉管道的输入端。然后,使用execlp函数把子进程的映像替换为命令ls
–1的进程映像,一旦该命令执行,它的任何输出都将发给管道的输入端。

现在来研究一下管道的接收端。从代码中可以看出,管道的接收端是由父进程来担当的。首先关闭stdin描述符(第20行),因为我们不会从机器的键盘等标
准设备文件来接收数据的输入,而是从其它程序的输出中接收数据。然后,再一次用到dup2函数(第21行),让stdin变成管道的输出端,这是通过让文
件描述符0(即常规的stdin)等于pfds[0]来实现的。关闭管道的stdout端(pfds[1]),因为在这里用不到它。最后,使用
execlp函数把父进程的映像替换为命令wc -1的进程映像,命令wc -1把管道的内容作为它的输入(第23行)。
示例代码3:利用C实现命令的流水线操作的代码
    1:    #include
    2:    #include
    3:    #include
    4:
    5:    int main()
    6:    …{
    7:       int pfds[2];
    8:
    9:       if ( pipe(pfds) == 0 ) …{
    10:
    11:           if ( fork() == 0 ) …{
    12:
    13:          close(1);
    14:          dup2( pfds[1], 1 );
    15:          close( pfds[0] );
    16:          execlp( “ls”, “ls”, “-1″, NULL );
    17:
    18:           } else …{
    19:
    20:          close(0);
    21:          dup2( pfds[0], 0 );
    22:          close( pfds[1] );
    23:          execlp( “wc”, “wc”, “-l”, NULL );
    24:
    25:           }
    26:
    27:       }
    28:
    29:       return 0;
    30:    }
    在该程序中,需要格外关注的是,我们的子进程把它的输出重定向的管道的输入,然后,父进程将它的输入重定向到管道的输出。这在实际的应用程序开发中是非常有用的一种技术。
1. 文件描述符在内核中数据结构
在具体说dup/dup2之前, 我认为有必要先了解一下文件描述符在内核中的形态。
一个进程在此存在期间,会有一些文件被打开,从而会返回一些文件描述符,从shell
中运行一个进程,默认会有3个文件描述符存在(0、1、2), 0与进程的标准输入相关联,
1与进程的标准输出相关联,2与进程的标准错误输出相关联,一个进程当前有哪些打开
的文件描述符可以通过/proc/进程ID/fd目录查看。 下图可以清楚的说明问题:
  进程表项
————————————————
   fd标志 文件指针
   _____________________
fd 0:|________|____________|————> 文件表
fd 1:|________|____________|
fd 2:|________|____________|
fd 3:|________|____________|
    |     …….       |
    |_____________________|
            图1
       
文件表中包含:文件状态标志、当前文件偏移量、v节点指针,这些不是本文讨论的
重点,我们只需要知道每个打开的文件描述符(fd标志)在进程表中都有自己的文件表
项,由文件指针指向。
2. dup/dup2函数
APUE和man文档都用一句话简明的说出了这两个函数的作用:复制一个现存的文件描述符。
#include
int dup(int oldfd);
int dup2(int oldfd, int newfd);
从图1来分析这个过程,当调用dup函数时,内核在进程中创建一个新的文件描述符,此
描述符是当前可用文件描述符的最小数值,这个文件描述符指向oldfd所拥有的文件表项。
  进程表项
————————————————
   fd标志 文件指针
   _____________________
fd 0:|________|____________|                ______
fd 1:|________|____________|—————-> |    |
fd 2:|________|____________|                |文件表|
fd 3:|________|____________|—————-> |______|
    |     …….       |
    |_____________________|
            图2:调用dup后的示意图
如图2 所示,假如oldfd的值为1, 当前文件描述符的最小值为3, 那么新描述符3指向
描述符1所拥有的文件表项。
dup2和dup的区别就是可以用newfd参数指定新描述符的数值,如果newfd已经打开,则
先将其关闭。如果newfd等于oldfd,则dup2返回newfd, 而不关闭它。dup2函数返回的新
文件描述符同样与参数oldfd共享同一文件表项。
APUE用另外一个种方法说明了这个问题:
实际上,调用dup(oldfd);
等效与
       fcntl(oldfd, F_DUPFD, 0)
而调用dup2(oldfd, newfd);
等效与
       close(oldfd);
       fcntl(oldfd, F_DUPFD, newfd);
3. CGI中dup2
写过CGI程序的人都清楚,当浏览器使用post方法提交表单数据时,CGI读数据是从标准
输入stdin, 写数据是写到标准输出stdout(c语言利用printf函数)。按照我们正常的理
解,printf的输出应该在终端显示,原来CGI程序使用dup2函数将STDOUT_FINLENO(这个
宏在unitstd.h定义,为1)这个文件描述符重定向到了连接套接字。
dup2(connfd, STDOUT_FILENO); /*实际情况还涉及到了管道,不是本文的重点*/
如第一节所说, 一个进程默认的文件描述符1(STDOUT_FILENO)是和标准输出stdout相
关联的,对于内核而言,所有打开的文件都通过文件描述符引用,而内核并不知道流的
存在(比如stdin、stdout),所以printf函数输出到stdout的数据最后都写到了文件描述
符1里面。至于文件描述符0、1、2与标准输入、标准输出、标准错误输出相关联,这
只是shell以及很多应用程序的惯例,而与内核无关。
用下面的流图可以说明问题:(ps: 虽然不是流图关系,但是还是有助于理解)
printf -> stdout -> STDOUT_FILENO(1) -> 终端(tty)
printf最后的输出到了终端设备,文件描述符1指向当前的终端可以这么理解:
STDOUT_FILENO = open(“/dev/tty”, O_RDWR);
使用dup2之后STDOUT_FILENO不再指向终端设备, 而是指向connfd, 所以printf的
输出最后写到了connfd。是不是很优美?:)
4. 如何在CGI程序的fork子进程中还原STDOUT_FILENO
如果你能看到这里,感谢你的耐心, 我知道很多人可能感觉有点复杂, 其实
复杂的问题就是一个个小问题的集合。所以弄清楚每个小问题就OK了,第三节中
说道,STDOUT_FILENO被重定向到了connfd套接字, 有时候我们可能想在CGI程序
中调用后台脚本执行,而这些脚本中难免会有一些输入输出, 我们知道fork之后,
子进程继承了父进程的所有文件描述符,所以这些脚本的输入输出并不会如我们愿
输出到终端设备,而是和connfd想关联了,这个显然会扰乱网页的输出。那么如何
恢复STDOUT_FILENO和终端关联呢?
方法1:在dup2之前保存原有的文件描述符,然后恢复。
代码实现如下:
savefd = dup(STDOUT_FILENO); /*savefd此时指向终端*/
dup2(connfd, STDOUT_FILENO); /*STDOUT_FILENO(1) 被重新指向connfd*/
…..   /*处理一些事情*/
dup2(savefd, STDOUT_FILENO);   /*STDOUT_FILENO(1) 恢复指向savefd*/
很遗憾CGI程序无法使用这种方法, 因为dup2这些不是在CGI程序中完成的,而是在
web server中实现的,修改web server并不是个好主意。
方法2: 追本溯源,打开当前终端恢复STDOUT_FILENO。
分析第三节的流图, STDOUT_FILENO是如何和终端关联的? 我们重头做一遍不就行
了, 代码实现如下:
ttyfd = open(“/dev/tty”, O_RDWR);
dup2(ttyfd, STDOUT_FILENO);
close(ttyfd);
/dev/tty是程序运行所在的终端, 这个应该通过一种方法获得。实践证明这种方法
是可行的,但是我总感觉有些不妥,不知道为什么,可能一些潜在的问题还没出现。
目前我就想到这两种方法, 不知道你有什么好的想法? 有的话希望告诉我:)

五月 21, 2009

C 指针和数组地址笔记

Filed under: C语言 — 标签: — admin @ 11:44 上午

#include<stdio.h>
 int main()
    {
      int a[5]={1,2,3,4,5];
      int *ptr=(int *)(&a+1)
      printf(“%d,%d\n”,*(a+1),*(prt-1);
}
~
一定很绕吧,我也糊涂了 琢磨了一早上

C语言里面规定a是数组的首地址是代表整个数组 但&a+1不等价于&a[0]+1, &a是首地址 &a+1就是取a 的地址在加1直接指向下一个内存区域  也就是指向到了ptr[0]的地址是地址上面    然后在把&a+1 的地址复制给ptr指针 这时候ptr变指向了a[5] ,ptr-1=a[4]          最后结果2,5

四月 15, 2009

C语言笔记 指针类型转换

Filed under: C语言 — 标签: — admin @ 11:08 上午

我们初始化一个指针或给一个指针赋值时,赋值号的左边是一个指针,赋
值号的右边是一个指针表达式。在我们前面所举的例子中,绝大多数情况下,指
针的类型和指针表达式的类型是一样的,指针所指向的类型和指针表达式所指向
的类型是一样的。
例十四:
1。 float f=12.3;
2。 float *fptr=&f;
3。 int *p;
在上面的例子中,假如我们想让指针p指向实数f,应该怎么搞?是用下面的
语句吗?
p=&f;
不对。因为指针p的类型是int*,它指向的类型是int。表达式&f的结果是一
个指针,指针的类型是float*,它指向的类型是float。两者不一致,直接赋值的
方法是不行的。至少在我的MSVC++6.0上,对指针的赋值语句要求赋值号两边的类
型一致,所指向的类型也一致,其它的编译器上我没试过,大家可以试试。为了
实现我们的目的,需要进行“强制类型转换”:
p=(int*)&f;
如果有一个指针p,我们需要把它的类型和所指向的类型改为TYEP*和TYPE,
那么语法格式是:
(TYPE*)p;
这样强制类型转换的结果是一个新指针,该新指针的类型是TYPE*,它指向的
类型是TYPE,它指向的地址就是原指针指向的地址。而原来的指针p的一切属性都
没有被修改。一个函数如果使用了指针作为形参,那么在函数调用语句的实参和形参的结
合过程中,也会发生指针类型的转换。
例十五:
void fun(char*);
int a=125,b;
fun((char*)&a);


void fun(char*s)
{
char c;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
}
注意这是一个32位程序,故int类型占了四个字节,char类型占一个字节。函
数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗?在函数调用
语句中,实参&a的结果是一个指针,它的类型是int *,它指向的类型是int。形
参这个指针的类型是char*,它指向的类型是char。这样,在实参和形参的结合过
程中,我们必须进行一次从int*类型到char*类型的转换。结合这个例子,我们可
以这样来想象编译器进行转换的过程:编译器先构造一个临时指针 char*temp,
然后执行temp=(char*)&a,最后再把temp的值传递给s。所以最后的结果是:s的
类型是char*,它指向的类型是char,它指向的地址就是a的首地址。

我们已经知道,指针的值就是指针指向的地址,在32位程序中,指针的值其
实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢?就象
下面的语句:
unsigned int a;
TYPE *ptr;//TYPE是int,char或结构类型等等类型。


a=20345686;
ptr=20345686;//我们的目的是要使指针ptr指向地址20345686(十进制

ptr=a;//我们的目的是要使指针ptr指向地址20345686(十进制)
编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就不能达到
了吗?不,还有办法:
unsigned int a;
TYPE *ptr;//TYPE是int,char或结构类型等等类型。


a=某个数,这个数必须代表一个合法的地址;
ptr=(TYPE*)a;//呵呵,这就可以了。
严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这里的(TYP
E*)的意思是把无符号整数a的值当作一个地址来看待。
上面强调了a的值必须代表一个合法的地址,否则的话,在你使用ptr的时候
,就会出现非法操作错误。

想想能不能反过来,把指针指向的地址即指针的值当作一个整数取出来。完
全可以。下面的例子演示了把一个指针的值当作一个整数取出来,然后再把这个
整数当作一个地址赋给一个指针:
例十六:
int a=123,b;
int *ptr=&a;
char *str;
b=(int)ptr;//把指针ptr的值当作一个整数取出来。
str=(char*)b;//把这个整数的值当作一个地址赋给指针str。

好了,现在我们已经知道了,可以把指针的值当作一个整数取出来,也可以
把一个整数值当作地址赋给一个指针。

 

其他相关资料:

#pragma src

#i nclude <reg51.H>
f(){}
f1(){}
f2(){}

main()
{
    {
        int x;
        int *px;

        //下面这些表示虽然很烦,但是生成的代码却及其简洁:

        //将 xdata 型指针 0×4000 赋给 px
        px=(int xdata *)0×4000;

        //表示从 xdata 0×4000处取一个 char 给x
        x=*((char xdata *)0×4000);

        // 表示从 code 0×4000处取一个 word 作为 xdata 型的指针 给
px
        px=*((int xdata * xdata *)0×4000);

        //表示从 code 0×4000处取一个 word 作为 xdata 型的指针,
        //再把这个指针指向的char数据赋给x
        x=**((char xdata * code *)0×4000);

        //表示把函数f()入口地址当作xdata型指针,再把指向的xdata
        //中的int型数据作为code型指针,把指向的code字节
        //赋给x(晕,这样有意义吗?)
        x=**(int code * xdata *)f;

        //把f()入口地址处的ROM中两个code型字节,
        //赋给堆栈指针SP指向的字节(想干什么?编操作系统?)
        *(unsigned int idata *)SP=*(unsigned int code *)&f;

        //表示把f()入口地址处的ROM中两个code型字节,
        //作为一个xdata指针寻址,
        //把指向的数据作为pdata指针寻址,
        //再把把指向的数据作为idata指针寻址,
        //把该地址处的一个字节赋给x (我靠,累死了)
        x= ****(unsigned int data * idata * pdata * xdata * code
*)&f;
       
        //总之,一个括号里面外面的”*”一样多就表示指向的是数据。
    }

    {
        //数组函数
        code void (*ArrFn[])(void) =
        {    &f1,
            &f2,
        };
        //可以像引用数组一样调用函数啦:
        (*ArrFn[0])();
        (*ArrFn[1])();
    }

    {
        //这样将使函数调用0000H处:
        void (*reset) (void);
        reset=0×0;
        (*reset)();
        reset();

        //或者直接这样,仅仅生成一条指令LCALL 1234H
        ((void (code *)(void))0×1234)();
    }

    {
        //这样可以调用RETI指令:
        #define  INT_NUM  30    //空闲中断号
        ((void (code *)(void))(INT_NUM*8+3))();
        //当然需要在外面声明   int_rpt()interrupt INT_NUM {}
    }
    {
        //这样调用RETI指令太变态:
        code unsigned char ret_i=0×32;
        ((void (code *)(void))(&ret_i))();
    }
}
int_rpt()interrupt INT_NUM {}

 

字节对齐

Filed under: C语言 — 标签: — admin @ 12:47 上午

VC字节对齐全攻略

VC中下面几个结构体大小分别是多少呢
struct MyStruct
{
    double m4;
    char m1;
    int  m3;
};

struct MyStruct {
    char m1;
    double m4;
    int m3;
};

#pragma pack(push)//保存对齐状态
#pragma pack(16)  //设置为16字节对齐
struct test
{
   char m1;
   int m3; 
   double m4;    
};
#pragma pack(pop)//恢复对齐状态
如果你的答案不是16,24和16,相信下面的内容对你很有帮助。

1、 sizeof应用在结构上的情况
请看下面的结构:
struct MyStruct
{
double dda1;
char dda;
int type
};
对结构MyStruct采用sizeof会出现什么结果呢?sizeof(MyStruct)为多少呢?也许你
会这样求:
sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13
但是当在VC中测试上面结构的大小时,你会发现sizeof(MyStruct)为16。你知道为什
么在VC中会得出这样一个结果吗?
其实,这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度,VC对一些变量的
起始地址做了“对齐”处理。在默认情况下,VC规定各成员变量存放的起始地址相对于结
构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的
对齐方式(vc6.0,32位系统)。
类型      对齐方式(变量存放的起始地址相对于结构的起始地址的偏移量)
Char      偏移量必须为sizeof(char)即1的倍数
Short     偏移量必须为sizeof(short)即2的倍数
int   偏移量必须为sizeof(int)即4的倍数
float 偏移量必须为sizeof(float)即4的倍数
double 偏移量必须为sizeof(double)即8的倍数
各成员变量在存放的时候根据在结构中出现的顺序依次申请空间,同时按照上面的对
齐方式调整位置,空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边
界数(即该结构中占用最大空间的类型所占用的字节数)的倍数,所以在为最后一个成员
变量申请空间后,还会根据需要自动填充空缺的字节。
下面用前面的例子来说明VC到底怎么样来存放结构的。
struct MyStruct
{
double dda1;
char dda;
int type
};
为上面的结构分配空间的时候,VC根据成员变量出现的顺序和对齐方式,先为第一个
成员dda1分配空间,其起始地址跟结构的起始地址相同(刚好偏移量0刚好为sizeof(doub
le)的倍数),该成员变量占用sizeof(double)=8个字节;接下来为第二个成员dda分配空
间,这时下一个可以分配的地址对于结构的起始地址的偏移量为8,是sizeof(char)的倍数
,所以把dda存放在偏移量为8的地方满足对齐方式,该成员变量占用 sizeof(char)=1个字
节;接下来为第三个成员type分配空间,这时下一个可以分配的地址对于结构的起始地址
的偏移量为9,不是sizeof (int)=4的倍数,为了满足对齐方式对偏移量的约束问题,VC自
动填充3个字节(这三个字节没有放什么东西),这时下一个可以分配的地址对于结构的起
始地址的偏移量为12,刚好是sizeof(int)=4的倍数,所以把type存放在偏移量为12的地方
,该成员变量占用sizeof(int)=4个字节;这时整个结构的成员变量已经都分配了空间,总
的占用的空间大小为:8+1+3+4=16,刚好为结构的字节边界数(即结构中占用最大空间的
类型所占用的字节数sizeof(double)=8)的倍数,所以没有空缺的字节需要填充。所以整
个结构的大小为:sizeof(MyStruct)=8+1+ 3+4=16,其中有3个字节是VC自动填充的,没有
放任何有意义的东西。
下面再举个例子,交换一下上面的MyStruct的成员变量的位置,使它变成下面的情况

struct MyStruct
{
char dda;
double dda1;
int type
};
这个结构占用的空间为多大呢?在VC6.0环境下,可以得到sizeof(MyStruc)为24。结
合上面提到的分配空间的一些原则,分析下VC怎么样为上面的结构分配空间的。(简单说
明)
struct MyStruct
{
char dda;//偏移量为0,满足对齐方式,dda占用1个字节;
double dda1;//下一个可用的地址的偏移量为1,不是sizeof(double)=8
//的倍数,需要补足7个字节才能使偏移量变为8(满足对齐
//方式),因此VC自动填充7个字节,dda1存放在偏移量为8
//的地址上,它占用8个字节。
int type;//下一个可用的地址的偏移量为16,是sizeof(int)=4的倍
//数,满足int的对齐方式,所以不需要VC自动填充,type存
//放在偏移量为16的地址上,它占用4个字节。
};//所有成员变量都分配了空间,空间总的大小为1+7+8+4=20,不是结构
//的节边界数(即结构中占用最大空间的类型所占用的字节数sizeof
//(double)=8)的倍数,所以需要填充4个字节,以满足结构的大小为
//sizeof(double)=8的倍数。
所以该结构总的大小为:sizeof(MyStruc)为1+7+8+4+4=24。其中总的有7+4=11个字节
是VC自动填充的,没有放任何有意义的东西。
VC对结构的存储的特殊处理确实提高CPU存储变量的速度,但是有时候也带来了一些麻
烦,我们也屏蔽掉变量默认的对齐方式,自己可以设定变量的对齐方式。
VC 中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存
放的起始地址的偏移量有两种情况:第一、如果n大于等于该变量所占用的字节数,那么偏
移量必须满足默认的对齐方式,第二、如果n小于该变量的类型所占用的字节数,那么偏移
量为n的倍数,不用满足默认的对齐方式。结构的总大小也有个约束条件,分下面两种情况
:如果n大于所有成员变量类型所占用的字节数,那么结构的总大小必须为占用空间最大的
变量占用的空间数的倍数;

否则必须为n的倍数。下面举例说明其用法。
#pragma pack(push) //保存对齐状态
#pragma pack(4)//设定为4字节对齐
struct test
{
char m1;
double m4;
int m3;
};
#pragma pack(pop)//恢复对齐状态

以上结构的大小为16,下面分析其存储情况,首先为m1分配空间,其偏移量为0,满足
我们自己设定的对齐方式(4字节对齐),m1占用1个字节。接着开始为 m4分配空间,这时
其偏移量为1,需要补足3个字节,这样使偏移量满足为n=4的倍数(因为sizeof(double)大
于n),m4占用8个字节。接着为m3分配空间,这时其偏移量为12,满足为4的倍数,m3占用
4个字节。这时已经为所有成员变量分配了空间,共分配了16个字节,满足为n的倍数。如
果把上面的#pragma pack(4)改为#pragma pack(16),那么我们可以得到结构的大小为24。
(请读者自己分析)

2、 sizeof用法总结

在VC中,sizeof有着许多的用法,而且很容易引起一些错误。下面根据sizeof后面的
参数对sizeof的用法做个总结。
A.参数为数据类型或者为一般变量。例如sizeof(int),sizeof(long)等等。这种情
况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。例如int类型在16位
系统中占2个字节,在32位系统中占4个字节。
B. 参数为数组或指针。下面举例说明.
int a[50]; //sizeof(a)=4*50=200; 求数组所占的空间大小
int *a=new int[50];// sizeof(a)=4; a为一个指针,sizeof(a)是求指针
//的大小,在32位系统中,当然是占4个字节。
C.参数为结构或类。Sizeof应用在类和结构的处理情况是相同的。但有两点需要注
意,第一、结构或者类中的静态成员不对结构或者类的大小产生影响,因为静态变量的存
储位置与结构或者类的实例地址无关。
第二、没有成员变量的结构或类的大小为1,因为必须保证结构或类的每一
个实例在内存中都有唯一的地址。
下面举例说明,
Class Test{int a;static double c};//sizeof(Test)=4.
Test *s;//sizeof(s)=4,s为一个指针。
Class test1{ };//sizeof(test1)=1;
D. 参数为其他。下面举例说明。
int func(char s[5]);
{
cout< //数的参数在传递的时候系统处理为一个指针,所
//以sizeof(s)实际上为求指针的大小。
return 1;
}
sizeof(func(“1234”))=4//因为func的返回类型为int,所以相当于
//求sizeof(int).
以上为sizeof的基本用法,在实际的使用中要注意分析VC的分配变量的分配策略,这
样的话可以避免一些错误

三月 31, 2009

文件描述符

Filed under: C语言 — 标签: — admin @ 10:09 下午

文件描述符就是一个表示 内核可以根据这个文件描述符 操作你需要操作的文件!用文件描述符可以方便的操作文件。

文件描述符是   Unix   系统内核中用于表示特定进程打开的特定文件的方式,通常是一个   int   类型的变量。当进程打开一个文件的时候,内核生成一个文件描述符,传递给调用进程;当进程需要操作这个文件的时候只要向内核传递这个描述符,内核就可以找到对应的文件执行响应操作

Older Posts »

Powered by LINUXQQ   ICP 10203065