【汇总】C语言函数

 

http://see.xidian.edu.cn/cpp/u/hanshu/   C语言函数手册

 

http://blog.csdn.net/wallwind/article/category/906727   UNIX环境高级编程

 

 

================ open

头文件：#include <sys/types.h>    #include <sys/stat.h>    #include <fcntl.h>

定义函数：
    int open(const char * pathname, int flags);
    int open(const char * pathname, int flags, mode_t mode);

函数说明：

参数 pathname 指向欲打开的文件路径字符串. 下列是参数flags 所能使用的旗标:
O_RDONLY 以只读方式打开文件
O_WRONLY 以只写方式打开文件
O_RDWR 以可读写方式打开文件. 上述三种旗标是互斥的, 也就是不可同时使用, 但可与下列的旗标利用OR(|)运算符组合.
O_CREAT 若欲打开的文件不存在则自动建立该文件.
O_EXCL 如果O_CREAT 也被设置, 此指令会去检查文件是否存在. 文件若不存在则建立该文件, 否则将导致打开文件错误. 此外, 若O_CREAT 与O_EXCL 同时设置, 并且欲打开的文件为符号连接, 则会打开文件失败.
O_NOCTTY 如果欲打开的文件为终端机设备时, 则不会将该终端机当成进程控制终端机.
O_TRUNC 若文件存在并且以可写的方式打开时, 此旗标会令文件长度清为0, 而原来存于该文件的资料也会消失.
O_APPEND 当读写文件时会从文件尾开始移动, 也就是所写入的数据会以附加的方式加入到文件后面.
O_NONBLOCK 以不可阻断的方式打开文件, 也就是无论有无数据读取或等待, 都会立即返回进程之中.
O_NDELAY 同O_NONBLOCK.
O_SYNC 以同步的方式打开文件.
O_NOFOLLOW 如果参数pathname 所指的文件为一符号连接, 则会令打开文件失败.
O_DIRECTORY 如果参数pathname 所指的文件并非为一目录, 则会令打开文件失败。注：此为Linux2. 2 以后特有的旗标, 以避免一些系统安全问题.

参数mode 则有下列数种组合, 只有在建立新文件时才会生效, 此外真正建文件时的权限会受到umask 值所影响, 因此该文件权限应该为 (mode-umaks).
S_IRWXU00700 权限, 代表该文件所有者具有可读、可写及可执行的权限.
S_IRUSR 或S_IREAD, 00400 权限, 代表该文件所有者具有可读取的权限.
S_IWUSR 或S_IWRITE, 00200 权限, 代表该文件所有者具有可写入的权限.
S_IXUSR 或S_IEXEC, 00100 权限, 代表该文件所有者具有可执行的权限.
S_IRWXG 00070 权限, 代表该文件用户组具有可读、可写及可执行的权限.
S_IRGRP 00040 权限, 代表该文件用户组具有可读的权限.
S_IWGRP 00020 权限, 代表该文件用户组具有可写入的权限.
S_IXGRP 00010 权限, 代表该文件用户组具有可执行的权限.
S_IRWXO 00007 权限, 代表其他用户具有可读、可写及可执行的权限.
S_IROTH 00004 权限, 代表其他用户具有可读的权限
S_IWOTH 00002 权限, 代表其他用户具有可写入的权限.
S_IXOTH 00001 权限, 代表其他用户具有可执行的权限.

返回值：若所有欲核查的权限都通过了检查则返回0 值, 表示成功, 只要有一个权限被禁止则返回-1.

错误代码：
EEXIST 参数pathname 所指的文件已存在, 却使用了O_CREAT 和O_EXCL 旗标.
EACCESS 参数pathname 所指的文件不符合所要求测试的权限.
EROFS 欲测试写入权限的文件存在于只读文件系统内.
EFAULT 参数pathname 指针超出可存取内存空间.
EINVAL 参数mode 不正确.
ENAMETOOLONG 参数 pathname 太长.
ENOTDIR 参数pathname 不是目录.
ENOMEM 核心内存不足.
ELOOP 参数pathname 有过多符号连接问题.
EIO I/O 存取错误.

附加说明：使用 access()作用户认证方面的判断要特别小心, 例如在access()后再作open()空文件可能会造成系统安全上的问题.

范例
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
    int fd, size;
    char s[] = "Linux Programmer!\n", buffer[80];
    fd = open ("/tmp/temp", O_WRONLY|O_CREAT);
    write(fd, s, sizeof(s));
    close(fd);
    fd = open("/tmp/temp", O_RDONLY);
    size = read (fd, buffer, sizeof(buffer));
    close(fd);
    printf("%s", buffer);
}

执行
Linux Programmer!

 

=============== creat

头文件：#include <sys/types.h>   #include <sys/stat.h>   #include <fcntl.h>

定义函数：int creat(const char * pathname, mode_tmode);

函数说明：
1、参数 pathname 指向欲建立的文件路径字符串。
2、Creat()相当于使用下列的调用方式调用open()
    open(const char * pathname, (O_CREAT|O_WRONLY|O_TRUNC ));

错误代码：关于参数 mode 请参考open()函数.

返回值：
creat()会返回新的文件描述词, 若有错误发生则会返回-1, 并把错误代码设给errno.
EEXIST参数：pathname 所指的文件已存在.
EACCESS参数：pathname 所指定的文件不符合所要求测试的权限
EROFS：欲打开写入权限的文件存在于只读文件系统内
EFAULT参数：pathname 指针超出可存取的内存空间
EINVAL参数：mode 不正确.
ENAMETOOLONG参数：pathname 太长.
ENOTDIR 参数：pathname 为一目录
ENOMEM ：核心内存不足
ELOOP 参数：pathname 有过多符号连接问题.
EMFILE：已达到进程可同时打开的文件数上限
ENFILE：已达到系统可同时打开的文件数上限

附加说明：creat()无法建立特别的装置文件, 如果需要请使用mknod().

 

 

================ lseek()—移动文件的读写位置

 

头文件：#include <sys/types.h>    #include <unistd.h>

定义函数：off_t lseek(int fildes, off_t offset, int whence);

函数说明：
每一个已打开的文件都有一个读写位置, 当打开文件时通常其读写位置是指向文件开头, 若是以附加的方式打开文件(如O_APPEND), 则读写位置会指向文件尾. 当read()或write()时, 读写位置会随之增加,lseek()便是用来控制该文件的读写位置. 参数fildes 为已打开的文件描述词, 参数offset 为根据参数whence来移动读写位置的位移数.

参数 whence 为下列其中一种:
    SEEK_SET 参数offset 即为新的读写位置.
    SEEK_CUR 以目前的读写位置往后增加offset 个位移量.
    SEEK_END 将读写位置指向文件尾后再增加offset 个位移量. 当whence 值为SEEK_CUR 或
    SEEK_END 时, 参数offet 允许负值的出现.

下列是教特别的使用方式:
1) 欲将读写位置移到文件开头时:lseek(int fildes, 0, SEEK_SET);
2) 欲将读写位置移到文件尾时:lseek(int fildes, 0, SEEK_END);
3) 想要取得目前文件位置时:lseek(int fildes, 0, SEEK_CUR);

返回值：当调用成功时则返回目前的读写位置, 也就是距离文件开头多少个字节 . 若有错误则返回-1, errno 会存放错误代码.

附加说明：Linux 系统不允许lseek()对tty 装置作用, 此项动作会令lseek()返回ESPIPE.

 

================ read() —读取指定的字节数 ，读文件函数(由已打开的文件读取数据)

不带缓冲是指每个read和write都调用内核中的一个系统调用

头文件：#include <unistd.h>

定义函数：ssize_t read(int fd, void * buf, size_t count);

函数说明：read()会把参数fd 所指的文件传送count 个字节到buf 指针所指的内存中. 若参数count 为0 , 则read()不会有作用并返回0. 返回值为实际读取到的字节数, 如果返回0, 表示已到达文件尾或是无可读取的数据,此外文件读写位置会随读取到的字节移动.

附加说明：
如果顺利 read()会返回实际读到的字节数 , 最好能将返回值与参数count 作比较, 若返回的字节数比要求读取的字节数少, 则有可能读到了文件尾、从管道(pipe)或终端机被信号中断了读取动作.

当有错误发生时则返回-1, 错误代码存入errno 中, 而文件读写位置则无法预期.

错误代码：
EINTR 此调用被信号所中断.
EAGAIN 当使用不可阻断I/O 时(O_NONBLOCK), 若无数据可读取则返回此值.
EBADF 参数fd 非有效的文件描述词, 或该文件已关闭.

 

 

 

 

 

================= write()—写文件函数

 

 

头文件：#include <unistd.h>

定义函数：ssize_t write (int fd, const void * buf, size_t count);

函数说明：write()会把参数buf 所指的内存写入count 个字节到参数fd 所指的文件内 . 当然, 文件读写位置也会随之移动.

返回值：如果顺利write()会返回实际写入的字节数. 当有错误发生时则返回-1 , 错误代码存入errno 中.

错误代码：
EINTR 此调用被信号所中断.
EAGAIN 当使用不可阻断I/O 时 (O_NONBLOCK), 若无数据可读取则返回此值.
EADF 参数fd 非有效的文件描述词, 或该文件已关闭.

 

 

实例：将标准输入复制到标准输出

函数open,read,write,lseek,close提供了不用缓冲的IO，这些函数都使用文件描述符

 

#define BUFFSIZE 4096

 

int

main(void)

{

    char  buf[BUFFSIZE ]

    while ((n = read(STDIN_FILENO, buf, BUFFSIZE )) >0 ) #读取的字节书赋指给n

        if(write(STDOUT_FILEON,buf, n) != n )

            printf("write error");

 

    if (n <0)

        printf("read error");

 

    exit(0);

}

 

 

 

 

================ getc() —读文件函数(由文件中读取一个字符 )

头文件：#include <stdio.h>

定义函数：int getc(FILE * stream);

函数说明：getc()用来从参数stream 所指的文件中读取一个字符. 若读到文件尾而无数据时便返回EOF. 虽然getc()与fgetc()作用相同, 但getc()为宏定义, 非真正的函数调用.

返回值：getc()会返回读取到的字符, 若返回EOF 则表示到了文件尾.

 

 

 

================== putc() —写文件函数(将一个指定字符写入文件中 )

 

 

 

头文件：#include <stdio.h>

定义函数：int putc(int c, FILE * stream);

函数说明：putc()会将参数c 转为unsigned char 后写入参数stream 指定的文件中. 虽然putc()与fputc()作用相同, 但putc()为宏定义, 非真正的函数调用.

返回值：putc()会返回写入成功的字符, 即参数c. 若返回EOF 则代表写入失败.

 

 

实例：用标准IO将标准输入复制到标准输出

标准IO函数提供一种对用缓冲IO函数的带缓冲的接口

 

 

 

int

main(void)

{

    int c;

    while (( c = getc(stdin) != EOF)

        if(putc(c, stdout) == EOF)

            printf("output error");

 

    if(ferror(stdin))

        printf(input error);

    exit(0);

}

 

 

================= getpid() —获取进程识别码

 

 

 

头文件：#include <unistd.h>

定义函数：pid_t getpid(void);

函数说明：getpid ()用来取得目前进程的进程识别码，许多程序利用取到的此值来建立临时文件， 以避免临时文件相同带来的问题。

返回值：目前进程的进程识别码

范例
#include <unistd.h>
main()
{
    printf("pid=%d\n", getpid());
}

执行：
pid=1494 /*每次执行结果都不一定相同 */

 

 

http://zhengdl126.iteye.com/admin/blogs/1739405/edit

 

=============== fgets()—读取文件字符串

 

头文件：include<stdio.h>

定义函数：har * fgets(char * s, int size, FILE * stream);

函数说明：fgets()用来从参数stream 所指的文件内读入字符并存到参数s 所指的内存空间, 直到出现换行字符、读到文件尾或是已读了size-1 个字符为止, 最后会加上NULL 作为字符串结束 .

返回值：gets()若成功则返回s 指针, 返回NULL 则表示有错误发生.

范例
#include <stdio.h>
main()
{
    char s[80];
    fputs(fgets(s, 80, stdin), stdout);
}

执行
this is a test //输入
this is a test //输出

 

 

================== fork

 

 

int main ()

　　{

　　pid_t pid;

　　int count = 0;

　　pid = fork ();

　　if (pid != 0) {

　　printf ("我是孩儿他爹\n\n");

　　count += 1;

　　}

　　else {

　　printf ("我是我爹的儿子\n\n");

　　count += 1;

　　}

　　printf("统计结果是：%d\n", count);

　　return 0;

　　}

　　编译-- gcc fork.c -o fork

　　运行，结果如下：

　　我是我爹的儿子

　　统计结果是：1

　　我是孩儿他爹

　　统计结果是：1

　　从中我们可以看出，在执行了fork函数后，子进程首先执行，然后是父进程，同时通过计数器可以看出，

　　两个进程不共享内存区域（不共享count这个变量），形成了两个相对独立的进程 。

 

=================== execlp()—从PATH 环境变量中查找文件并执行

 

 

头文件：#include <unistd.h>

定义函数：int execlp(const char * file, const char * arg, ...);

函数说明：execlp()会从PATH 环境变量所指的目录中查找符合参数file 的文件名, 找到后便执行该文件, 然后将第二个以后的参数当做该文件的argv[0], argv[1], ..., 最后一个参数必须用空指针(NULL)作结束.

返回值：如果执行成功则函数不会返回, 执行失败则直接返回-1, 失败原因存于errno 中.

错误代码：参考 execve().

范例
/* 执行ls -al /etc/passwd execlp()会依PATH 变量中的/bin 找到/bin/ls */
#include <unistd.h>
main()
{
    execlp("ls", "ls", "-al", "/etc/passwd", (char *)0 );
}

执行：
-rw-r--r-- 1 root root 705 Sep 3 13 :52 /etc/passwd

 

 

===================== waitpid ()—中断(结束)进程函数(等待子进程中断或结束)

 

头文件：#include <sys/types.h>    #include <sys/wait.h>

定义函数：pid_t waitpid(pid_t pid, int * status, int options);

函数说明：waitpid()会暂时停止目前进程的执行, 直到有信号来到或子进程结束. 如果在调用wait()时子进程已经结束, 则wait()会立即返回子进程结束状态值. 子进程的结束状态值会由参数status 返回 , 而子进程的进程识别码也会一快返回. 如果不在意结束状态值, 则参数status 可以设成NULL. 参数pid 为欲等待的子进程识别码, 其他数值意义如下：

1、pid<-1 等待进程组识别码为pid 绝对值的任何子进程.
2、pid=-1 等待任何子进程, 相当于wait().
3、pid=0 等待进程组识别码与目前进程相同的任何子进程.
4、pid>0 等待任何子进程识别码为pid 的子进程.

参数option 可以为0 或下面的OR 组合 ：

WNOHANG：如果没有任何已经结束的子进程则马上返回, 不予以等待.
WUNTRACED：如果子进程进入暂停执行情况则马上返回, 但结束状态不予以理会. 子进程的结束状态返回后存于status, 底下有几个宏可判别结束情况
WIFEXITED(status)：如果子进程正常结束则为非0 值.
WEXITSTATUS(status)：取得子进程exit()返回的结束代码, 一般会先用WIFEXITED 来判断是否正常结束才能使用此宏.
WIFSIGNALED(status)：如果子进程是因为信号而结束则此宏值为真
WTERMSIG(status)：取得子进程因信号而中止的信号代码, 一般会先用WIFSIGNALED 来判断后才使用此宏.
WIFSTOPPED(status)：如果子进程处于暂停执行情况则此宏值为真. 一般只有使用WUNTRACED时才会有此情况.
WSTOPSIG(status)：取得引发子进程暂停的信号代码, 一般会先用WIFSTOPPED 来判断后才使用此宏.

返回值：如果执行成功则返回子进程识别码(PID), 如果有错误发生则返回-1. 失败原因存于errno 中.

 

 

实例：从标准输入读命令，然后执行这些命令。类shell程序的简化实现

 

#include <sys/wait.h>
#define MAXLINE 1024
int
main(void)
{
    char buf[MAXLINE];
    pid_t pid;
    int status;

   
    printf("%% ");
    while (fgets(buf, MAXLINE, stdin) != null) {
        if (buf[strlen(buf)] -1 == '\n')//用null替换换行符，要求以null结尾
            buf[strlen(buf) -1 ] = 0;
       
        if ((pid = fork()) <0 ){ //fork 创建一个新进程
            printf(fork error");
        } else if(pid ==0 ){
            execlp(buf, buf ,(char *)0);
            err_ret("could not execute ：%s",buf);
            exit(127);
        }
   
        /* parent*/
        if((pid = waitpid(pid, &status, 0) ) <0 )
            printf("waitpid error);
        printf("%% ");
       
    }
    exit(0);
}


输出：
$./a.out
% pwd
/tmp
% ls
Makefile
% ^D
$

 

============== signal()—设置信号处理方式

 

头文件：#include <signal.h>

定义函数：void (*signal(int signum, void(* handler)(int)))(int);

函数说明：signal()会依参数signum 指定的信号编号来设置该信号的处理函数. 当指定的信号到达时就会跳转到参数handler 指定的函数执行. 如果参数handler 不是函数指针, 则必须是下列两个常数之一：
1、SIG_IGN 忽略参数signum 指定的信号.
2、SIG_DFL 将参数signum 指定的信号重设为核心预设的信号处理方式.

关于信号的编号和说明, 请参考附录D

返回值：返回先前的信号处理函数指针 , 如果有错误则返回SIG_ERR(-1).

附加说明：在信号发生跳转到自定的 handler 处理函数执行后, 系统会自动将此处理函数换回原来系统预设的处理方式, 如果要改变此操作请改用sigaction().

 

 

=============== access 检查是否可以读/写某一已存在的文件

 

 

头文件：#include <unistd.h>

定义函数：int access(const char * pathname, int mode);

函数说明：access()会检查是否可以读/写某一已存在的文件。

参数mode 有几种情况组合：
1、R_OK, W_OK, X_OK和F_OK. R_OK, W_OK 与X_OK 用来检查文件是否具有读娶写入和执行的权限。
2、F_OK 则是用来判断该文件是否存在。由于access()只作权限的核查, 并不理会文件形态或文件内容，因此，如果一目录表示为"可写入"，表示可以在该目录中建立新文件等操作，而非意味此目录可以被当做文件处理。例如：你会发现DOS 的文件都具有"可执行"权限，但用execve()执行时则会失败。

返回值：若所有欲查核的权限都通过了检查则返回0 值，表示成功，只要有一权限被禁止则返回-1。

错误代码：
1、EACCESS 参数pathname 所指定的文件不符合所要求测试的权限.
2、EROFS 欲测试写入权限的文件存在于只读文件系统内.
3、EFAULT 参数pathname 指针超出可存取内存空间.
4、EINVAL 参数mode 不正确.
5、ENAMETOOLONG 参数pathname 太长.
6、ENOTDIR 参数pathname 为一目录.
7、ENOMEM 核心内存不足
8、ELOOP 参数pathname 有过多符号连接问题.
9、EIO I/O 存取错误.

附加说明：使用 access()作用户认证方面的判断要特别小心, 例如在access()后再做open()的空文件可能会造成系统安全上的问题.

范例：
/* 判断是否允许读取/etc/passwd */
#include <unistd.h>
int main()
{
    if(access ("/etc/passwd", R_OK) == 0)
    printf("/etc/passwd can be read\n");
}

执行：
/etc/passwd can be read

 

 

说明:下面的例子用来测试指定的文件是否具有可读权限
 
          #include<unistd.h>
          #include<stdio.h>
          #include<stdlib.h>
 
          int main(int argc,char *argv[]){
                   if(argc<2){
                         printf("Usage:%s filename\n",argv[0]);
                         exit(1);}
                   if(access (argv[1],R_OK)==0){
                         printf("File:%s can read\n",argv[1]);}
                   else
                         printf("File:%s can't read\n",argv[1]);
                   return 0;
            }

 

============= umask设置建立新文件时的权限遮罩

 

头文件：#include <sys/types.h>   #include <sys/stat.h>

定义函数：mode_t umask(mode_t mask);

函数说明：umask()会将系统umask值设成参数mask&0777后的值, 然后将先前的umask值返回。在使用open()建立新文件时, 该参数mode 并非真正建立文件的权限, 而是(mode&~umask)的权限值。

 

 

在建立文件时指定文件权限为0666, 通常umask 值默认为022, 则该文件的真正权限则为0666&～022＝0644, 也就是rw-r--r--返回值此调用不会有错误值返回. 返回值为原先系统的umask 值。

 

 

============= chmod 修改文件权限

 

 

chmod 函数在制定的文件进行操作，而fchmod函数则对已经打开的文件进行操作 。

如果一目录具有S_ISUID 位权限，表示在此目录下只有该文件的所有者或root 可以删除该文件。如tmp目录



头文件：#include <sys/types.h>   #include <sys/stat.h>

定义函数：int chmod(const char * path, mode_t mode);

函数说明：chmod()会依参数mode 权限来更改参数path 指定文件的权限。

参数 mode 有下列数种组合：
1、S_ISUID 04000 文件的 (set user-id on execution)位
2、S_ISGID 02000 文件的 (set group-id on execution)位
3、S_ISVTX 01000 文件的sticky 位
4、S_IRUSR (S_IREAD) 00400 文件所有者具可读取权限
5、S_IWUSR (S_IWRITE)00200 文件所有者具可写入权限
6、S_IXUSR (S_IEXEC) 00100 文件所有者具可执行权限
7、S_IRGRP 00040 用户组具可读取权限
8、S_IWGRP 00020 用户组具可写入权限
9、S_IXGRP 00010 用户组具可执行权限
10、S_IROTH 00004 其他用户具可读取权限
11、S_IWOTH 00002 其他用户具可写入权限
12、S_IXOTH 00001 其他用户具可执行权限

注：只有该文件的所有者或有效用户识别码为0，才可以修改该文件权限。

基于系统安全，如果欲将数据写入一执行文件，而该执行文件具有S_ISUID 或S_ISGID 权限，则这两个位会被清除。如果一目录具有S_ISUID 位权限，表示在此目录下只有该文件的所有者或root 可以删除该文件。

返回值：权限改变成功返回0, 失败返回-1, 错误原因存于errno.

错误代码：
1、EPERM 进程的有效用户识别码与欲修改权限的文件拥有者不同, 而且也不具root 权限.
2、EACCESS 参数path 所指定的文件无法存取.
3、EROFS 欲写入权限的文件存在于只读文件系统内.
4、EFAULT 参数path 指针超出可存取内存空间.
5、EINVAL 参数mode 不正确
6、ENAMETOOLONG 参数path 太长
7、ENOENT 指定的文件不存在
8、ENOTDIR 参数path 路径并非一目录
9、ENOMEM 核心内存不足
10、ELOOP 参数path 有过多符号连接问题.
11、EIO I/O 存取错误

范例
/* 将/etc/passwd 文件权限设成S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH */
#include <sys/types.h>
#include <sys/stat.h>
main()
{
    chmod ("/etc/passwd", S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
}

#include "apue.h" 
 
int main(void) 
{ 
        struct stat  statbuf; 
        if(stat("foo",&statbuf)<0) 
          err_sys("stat error for foo"); 
        if(chmod("foo",(statbuf.st_mode&~S_IXGRP)|S_ISGID )<0) 
          err_sys("chmod err for foo"); 
 
        if(chmod ("bar",S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH )<0) 
         err_sys("chmod err for bar"); 
 
        exit(0); 
 
 
}

 

 

 

 

=============== 粘住位

 

如果对一个目录设置了粘住位，则只有对该目录具有写权限的用户在满足下列条件之一的情况下，才能删除或更名该目录下的文件：1.拥有该文件    2. 拥有该目录    3. 是超级用户

 

示例：目录/tmp和/var/spool/uucppublic是设置粘住位的典型候选者 ——任何用户都可在这两个目录中创建文件。任一用户(用户、组 和其他)对这两个目录的权限通常都是读、写和执行。但用户不应删除或更名属于其他人的文件，为此在这两个目录的文件模式中都设置了粘住位。

 

 

 

 

============== chown 改变文件所有者

 

lchown是改变符号链接本身的所有者，而不是该符号链接所指向的文件。

 

 

头文件：#include <sys/types.h>   #include <unistd.h>

定义函数：int chown(const char * path, uid_t owner, gid_t group);

 

函数说明：chown()会将参数path 指定文件的所有者变更为参数owner 代表的用户，而将该文件的组变更为参数group 组。如果参数owner 或group 为-1，对应的所有者或组不会有所改变。root 与文件所有者皆可改变文件组，但所有者必须是参数group 组的成员。当root 用chown()改变文件所有者或组时，该文件若具有S_ISUID或S_ISGID 权限，则会清除此权限位，此外如果具有S_ISGID 权限但不具S_IXGRP 位，则该文件会被强制锁定,文件模式会保留。

返回值：成功则返回0, 失败返回-1, 错误原因存于errno.
范例
/* 将/etc/passwd 的所有者和组都设为root */
#include <sys/types.h>
#include <unistd.h>
main()
{
    chown("/etc/passwd", 0, 0);
}

 

 

-------------- link()—建立文件连接


头文件：#include <unistd.h>

定义函数：int link (const char * oldpath, const char * newpath);

函数说明：link()以参数newpath 指定的名称来建立一个新的连接(硬连接)到参数oldpath 所指定的已存在文件. 如果参数newpath 指定的名称为一已存在的文件则不会建立连接.

返回值：成功则返回0, 失败返回-1, 错误原因存于errno.

附加说明：link()所建立的硬连接无法跨越不同文件系统, 如果需要请改用symlink().


范例：
/* 建立/etc/passwd 的硬连接为pass */
#include <unistd.h>
main()
{
    link("/etc/passwd", "pass");
}


-------------- unlink()—删除文件

头文件：#include <unistd.h>

定义函数：int unlink(const char * pathname);

函数说明：unlink()会删除参数pathname 指定的文件. 如果该文件名为最后连接点, 但有其他进程打开了此文件, 则在所有关于此文件的文件描述词皆关闭后才会删除. 如果参数pathname 为一符号连接, 则此连接会被删除。

返回值：成功则返回0, 失败返回-1, 错误原因存于errno



--------------  remove()—删除文件函数


头文件：#include <stdio.h>

定义函数：int remove(const char * pathname);

函数说明：remove()会删除参数pathname 指定的文件. 如果参数pathname 为一文件, 则调用unlink()处理,若参数pathname 为一目录, 则调用rmdir()来处理. 请参考unlink()与rmdir().

返回值：成功则返回0, 失败则返回-1, 错误原因存于errno.


-------------- rename()—更改文件名称或位置

头文件：#include <stdio.h>

定义函数：int rename(const char * oldpath, const char * newpath);

函数说明：rename()会将参数oldpath 所指定的文件名称改为参数newpath 所指的文件名称. 若newpath 所指定的文件已存在, 则会被删除.

返回值：执行成功则返回0, 失败返回-1, 错误原因存于errno

范例
/* 设计一个DOS 下的rename 指令rename 旧文件名新文件名 */
#include <stdio.h>
void main(int argc, char **argv)
{
    if(argc < 3)
    {
        printf("Usage: %s old_name new_name\n", argv[0]);
        return;
    }
    printf("%s=>%s", argc[1], argv[2]);
    if(rename(argv[1], argv[2]) < 0)
    printf("error!\n");
    else
    printf("ok!\n");
}

-------------- symlink()—建立文件符号连接

头文件：#include <unistd.h>

定义函数：int symlink(const char * oldpath, const char * newpath);

函数说明：symlink()以参数newpath 指定的名称来建立一个新的连接(符号连接)到参数oldpath 所指定的已存在文件. 参数oldpath 指定的文件不一定要存在, 如果参数newpath 指定的名称为一已存在的文件则不会建立连接.

返回值：成功则返回0, 失败返回-1, 错误原因存于errno.

范例
#include <unistd.h>
main()
{
    symlink("/etc/passwd", "pass");
}


-------------- readlink()—取得符号连接所指的文件

头文件：#include <unistd.h>

定义函数：int readlink(const char * path, char * buf, size_t bufsiz);

函数说明：readlink()会将参数path 的符号连接内容存到参数buf 所指的内存空间, 返回的内容不是以NULL作字符串结尾, 但会将字符串的字符数返回. 若参数bufsiz 小于符号连接的内容长度, 过长的内容会被截断.

返回值：执行成功则传符号连接所指的文件路径字符串, 失败则返回-1, 错误代码存于errno.




-------------- chdir()—改变当前的工作目录


头文件：#include <unistd.h>

定义函数：int chdir(const char * path);

函数说明：chdir()用来将当前的工作目录改变成以参数path 所指的目录.

返回值执：行成功则返回0, 失败返回-1, errno 为错误代码.

范例
#include <unistd.h>
main()
{
    chdir("/tmp");
    printf("current working directory: %s\n", getcwd(NULL, NULL));
}

执行：
current working directory :/tmp


-------------- getcwd()—取得当前的工作目录

头文件：#include <unistd.h>

定义函数：char * getcwd(char * buf, size_t size);

函数说明：getcwd()会将当前的工作目录绝对路径复制到参数buf 所指的内存空间，参数size 为buf 的空间大小。

注：
1、在调用此函数时，buf 所指的内存空间要足够大。若工作目录绝对路径的字符串长度超过参数size 大小，则返回NULL，errno 的值则为ERANGE。
2、倘若参数buf 为NULL，getcwd()会依参数size 的大小自动配置内存(使用malloc())，如果参数size 也为0，则getcwd()会依工作目录绝对路径的字符串程度来决定所配置的内存大小，进程可以在使用完次字符串后利用free()来释放此空间。

返回值：执行成功则将结果复制到参数buf 所指的内存空间, 或是返回自动配置的字符串指针. 失败返回NULL,错误代码存于errno.

范例
#include <unistd.h>
main()
{
    char buf[80];
    getcwd(buf, sizeof(buf));
    printf("current working directory : %s\n", buf);
}

执行：
current working directory :/tmp

 

 

 

=========== exit

头文件：#include <stdlib.h>

定义函数：void exit(int status);

函数说明：exit()用来正常终结目前进程的执行, 并把参数status 返回给父进程, 而进程所有的缓冲区数据会自动写回并关闭未关闭的文件.




 
=========== atexit

头文件：#include <stdlib.h>

定义函数：int atexit (void (*function) (void));

函数说明：atexit()用来设置一个程序正常结束前调用的函数. 当程序通过调用exit()或从main 中返回时, 参数function 所指定的函数会先被调用, 然后才真正由exit()结束程序.

返回值：如果执行成功则返回0, 否则返回-1, 失败原因存于errno 中.

范例
#include <stdlib.h>
void my_exit(void)
{
    printf("before exit () !\n");
}
main()
{
    atexit (my_exit);
    printf("main is done\n");
    exit(0);
}

执行：
main is done
before exit()!