高级I/O

最新推荐文章于 2024-02-11 22:19:42 发布
最新推荐文章于 2024-02-11 22:19:42 发布
阅读量768 收藏
点赞数
分类专栏： Linux C编程 文章标签： struct null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuhai8702/article/details/5923427
版权

高级I/O

 

一、主要函数：select,poll,epoll,readv,writev

二、

1 、select,poll,epoll 的作用就是监视多个I/O. 如果不希望被某些信号打断可用pselect,ppoll.

2 、select

每次用select 之前都要构造一下。当监视读一个写端关闭的进程时，select 总是能返回。

 

3 、poll

POLLIN 读，POLLOUT 写

struct pollfd fds[2];

nfds = 2;

fds[0].fd = 0;

fds[0].events = POLLIN;

fds[1].fd = fd[0];

fds[1].events = POLLIN;

ret = poll(fds, 2, -1);//-1 表示永远等待

......

如果第三个参数用了timeout ，那么当超时的时候返回0.

每执行一次poll ，fds 都要被拷到内核处理，所以select 和poll 效率低。

4 、epoll

第一步：epoll_create();

epfd=epoll_create(1), 创建一个event poll, 返回一个指向这个池的文件描述符，它里面的参数只要大于0 就行，如果为-1 的话就会死掉。

第二步：epoll_ctl();

epoll_ctl(epfd,EPOLL_CTL_ADD,fd[i][0],&event); 用 EPOLL_CTL_ADD 添加关心的事件到池中

第三步：epoll_wait();

struct epoll_event event[2];

while(1)

{

    epoll_wait(epfd,event,2,-1);// 最后一个参数用-1 表示永远等待

    ....// 如果返回来的不只2 两个，通过while 循环下一次过来再取

}

5 、readv,writev 分散读，聚集写

ssize_t readv(int fd, const struct iovec *iov, int iovcnt) ；

第二个参数iov 和第三个参数iovcnt 组成一个结构体数组iov[iovcnt];

int main(void)

{

    int fd, i;

    char *ptr[3] = {

    struct iovec iov[3];

    for (i = 0; i < 3; i++) {

        iov[i].iov_base = ptr[i];

        iov[i].iov_len = 6;

    }

    writev(1, iov, 3);

    exit(0);

}

6 、SIGIO 信号  F_SETOWN, O_ASYNC

1)fcntl(fd,F_SETOWN,getpid())

2)fcntl(fd,F_SETFL,ret|O_ASYNC)  其中ret=fcntl(fd,F_GETFL)

3)sigaction(SIGIO,&act,NULL)

三、例程

1 、/*select.c*//*监视多个I/O*/
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

void con_fds(fd_set *set, int fd)
{
    FD_ZERO(set);
    FD_SET(0, set);    
    FD_SET(fd, set);    
}

int main(void)
{
    int ret, nfds, cnt;
    char buf[88];
    fd_set readfds;
    int fd[2];
    pid_t pid;
    
    ret = pipe(fd);
    if (ret == -1) {
        perror("pipe");
        exit(1);
    }
    
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    }
    if (pid == 0) {
        close(fd[0]);
        srand(time(NULL));
        sleep(rand()%5 + 5);
        write(fd[1], "Hello!", 6);
        //while(1)
            sleep(1);
        close(fd[1]);
        exit(0);
    }

    close(fd[1]);

    nfds = fd[0]+1;

    while (1) {
        con_fds(&readfds, fd[0]);
        ret = select(nfds, &readfds, NULL,
            NULL, NULL);
        if (ret > 0) {
            printf("ret=%d/n", ret);
            if (FD_ISSET(0, &readfds)) {
                cnt = read(0, buf, 88);
                buf[cnt] = '/0';
                printf("%s/n", buf);
            }
            if (FD_ISSET(fd[0], &readfds)) {
                cnt = read(fd[0], buf, 88);
                buf[cnt] = '/0';
                printf("%s/n", buf);
            }
        }
        if (ret == -1) {
            perror("select");
            exit(1);
        }
    }
    
}
/*1、本程序有两个关心的fd:   0和fd[0],监视这两个I/O,哪个有数据就了都要读
  2、select:在每次调用select之前要构造，con_fds,构造所关心的fd。
  3、声明一个描述符集之后，必须用FD_ZERO清除其所有们，然后在其中设置我们关心的各个位。
  4、select的第一个参数是所关心的fd中"最大的描述符加1".一般我们不关心后三个参数，
所以都置为NULL
*/

2 、

/*poll.c*/
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <poll.h>


int main(void)
{
    int ret, nfds, cnt;
    char buf[88];
    int fd[2];
    pid_t pid;
    struct pollfd fds[2];
    
    ret = pipe(fd);
    if (ret == -1) {
        perror("pipe");
        exit(1);
    }
    
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    }
    if (pid == 0) {
        close(fd[0]);
        srand(time(NULL));
        sleep(rand()%5 + 5);
        write(fd[1], "Hello!", 6);
        while(1)
            sleep(1);
        close(fd[1]);
        exit(0);
    }

    close(fd[1]);

    nfds = 2;//2是所关心描述符的个数
    fds[0].fd = 0;
    fds[0].events = POLLIN;//关心输入，也就是关心"写"
    fds[1].fd = fd[0];
    fds[1].events = POLLIN;
    
    while (1) {
        ret = poll(fds, 2, -1);
        if (ret > 0) {
            printf("ret=%d/n", ret);
            if (fds[0].revents & POLLIN) {
                cnt = read(fds[0].fd,
                    buf, 88);
                buf[cnt] = '/0';
                printf("%s/n", buf);
            }
            if (fds[1].revents & POLLIN) {
                cnt = read(fds[1].fd,
                    buf, 88);
                buf[cnt] = '/0';
                printf("%s/n", buf);
            }
        }
        if (ret == -1) {
            perror("poll");
            exit(1);
        }
    }
    
}

/*1、poll比select略胜一点，不用在每次调用之前都构造一次
  2、    struct pollfd fds[2];
  3、if (fds[0].revents & POLLIN)
 */

3 、

/*epoll.c*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/select.h>
#include <string.h>
#include <poll.h>
#include <sys/epoll.h>

#define PIPENUM 5

int fd[PIPENUM][2];

int creat_pipe(void)//创建5个管道
{
    int i, ret;

    for (i = 0; i < PIPENUM; i++) {
        ret = pipe(fd[i]);
        if (ret == -1) {
            perror("pipe");
            return -1;
        }
    }
    return 0;
}

int con_readfds(void)//构造事件池
{
    int i, epfd;
    struct epoll_event event;
    epfd = epoll_create(1);
    if (epfd == -1) {
        perror("epoll_create");
        return epfd;
    }

    for (i = 0; i < PIPENUM; i++) {
        event.events = EPOLLIN;
        event.data.fd = fd[i][0];
        epoll_ctl(epfd, EPOLL_CTL_ADD, fd[i][0],
            &event);
    }
    return epfd;    
}


void father_close_fds(void)
{
    int i;
    for (i = 0; i < PIPENUM; i++) {
        close(fd[i][1]);
    }
}

void child_close_fds(int index)
{
    int i;

    for (i = 0; i < PIPENUM; i++) {
        close(fd[i][0]);
        if (i != index) {
            close(fd[i][1]);
        }
    }
}

void child_work(int i)
{
    char buf[100];
    child_close_fds(i);
    srand(getpid());
    bzero(buf, 100);
    sprintf(buf, "I am pid %d!", getpid());

    while (1) {
        sleep(rand() % (PIPENUM) + 6);
        write(fd[i][1], buf, strlen(buf));
    }
}

static void father_actual_work(struct epoll_event *event)
{
    int i, ret;
    char buf[100];    
    for (i = 0; i < 2; i++) {
        if (event[i].events & EPOLLIN) {
            ret = read(event[i].data.fd, buf, 100);
            buf[ret] = '/0';
            printf("%s/n", buf);
        }
    }
}

void father_work()
{
    int nfds, ret, epfd;
    struct epoll_event event[2];
    father_close_fds();    
    epfd = con_readfds();    

    while (1) {
        ret = epoll_wait(epfd, event, 2, -1);
        if (ret > 0) {
            father_actual_work(event);
        }
        if (ret == -1) {
            perror("select");
            return;
        }
    }

}

int main(void)
{
    int ret, i;
    pid_t pid;

    ret = creat_pipe();
    if (ret == -1)
        exit(1);

    for (i = 0; i < PIPENUM; i++) {
        pid = fork();
        if (pid == 0) {
            child_work(i);
            exit(0);
        }
    }

    father_work();
    exit(0);
}
/*1、epoll_create(1)创建event poll;
 2、epoll_ctl(epfd, EPOLL_CTL_ADD, fd[i][0],&event);*/

4 、

/*select and pipe*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/select.h>

#include <string.h>

#define PIPENUM 5

int fd[PIPENUM][2];

fd_set readfds;

int creat_pipe(void) // 产生5 个管道

{

    int i, ret;

    for (i = 0; i < PIPENUM; i++) {

        ret = pipe(fd[i]);

        if (ret == -1) {

            perror("pipe");

            return -1;

        }

    }

    return 0;

}

void con_readfds(void )// 构造

{

    int i;

    FD_ZERO(&readfds);

    for (i = 0; i < PIPENUM; i++) {

        FD_SET(fd[i][0], &readfds); // 关心的是fd[i][0]         

    }

    return;

}

int get_max_fds(void )// 取最大描述符加1

{

    int i, max = 0;

    for (i = 0; i < PIPENUM; i++) {

        if (max < fd[i][0])

            max = fd[i][0];

    }

    return max+1;

}

void father_close_fds(void)

// 父进程关闭5 个管道的写端

{

    int i;

    for (i = 0; i < PIPENUM; i++) {

        close(fd[i][1]);

    }

}

void child_close_fds(int index)

// 子进程关闭除自己以外的写端

{

    int i;

    for (i = 0; i < PIPENUM; i++) {

        close(fd[i][0]);

        if (i != index) {

            close(fd[i][1]);

        }

    }

}

void child_work(int i)

{

    char buf[100];

    child_close_fds(i);

    srand(getpid());

    bzero(buf, 100);

    sprintf(buf, "I am pid %d!", getpid());

    while (1) {

        sleep(rand() % (PIPENUM) + 6);

        write(fd[i][1], buf, strlen(buf));

    }

}

static void father_actual_work(void)

{

    int i, ret;

    char buf[100]; 

    for (i = 0; i < PIPENUM; i++) {

        if (FD_ISSET(fd[i][0], &readfds)) { // 不能写成fd[i][1]!

            ret = read(fd[i][0], buf, 100);

            buf[ret] = '/0';

            printf("%s/n", buf);

        }

    }

}

void father_work()

{

    int nfds, ret;

    father_close_fds();

    nfds = get_max_fds();

    while (1) {

        con_readfds();  // 每次用select 之前都要构造一下，设置你关心的描述符

        ret = select(nfds, &readfds, NULL,

            NULL, NULL);

        if (ret > 0) {

            father_actual_work();

        }

        if (ret == -1) {

            perror("select");

            return;

        }

    }

}

int main(void)

{

    int ret, i;

    pid_t pid;

    ret = creat_pipe();

    if (ret == -1)

        exit(1);

    for (i = 0; i < PIPENUM; i++) {

        pid = fork();

        if (pid == 0) {

            child_work(i);

            exit(0);

        }

    }

    father_work();

    exit(0);

}

/*select和pipe，监视5个管道,子进程写，父进程读*/

5 、

/*poll and pipe*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/select.h>

#include <string.h>

#include <poll.h>

#define PIPENUM 5

int fd[PIPENUM][2];

struct pollfd fds[PIPENUM];

int creat_pipe(void)

{

    int i, ret;

    for (i = 0; i < PIPENUM; i++) {

        ret = pipe(fd[i]);

        if (ret == -1) {

            perror("pipe");

            return -1;

        }

    }

    return 0;

}

void con_readfds(void)

{

    int i;

    for (i = 0; i < PIPENUM; i++) {

        fds[i].fd = fd[i][0];

        fds[i].events = POLLIN;

    }

    return;

}

 

void father_close_fds(void)

{

    int i;

    for (i = 0; i < PIPENUM; i++) {

        close(fd[i][1]);

    }

}

void child_close_fds(int index)

{

    int i;

    for (i = 0; i < PIPENUM; i++) {

        close(fd[i][0]);

        if (i != index) {

            close(fd[i][1]);

        }

    }

}

 

void child_work(int i)

{

    char buf[100];

    child_close_fds(i);

    srand(getpid());

    bzero(buf, 100);

    sprintf(buf, "I am pid %d!", getpid());

    while (1) {

        sleep(rand() % (PIPENUM) + 6);

        write(fd[i][1], buf, strlen(buf));

    }

}

static void father_actual_work(void)

{

    int i, ret;

    char buf[100]; 

    for (i = 0; i < PIPENUM; i++) {

        if (fds[i].revents & POLLIN) {

            ret = read(fds[i].fd, buf, 100);

            buf[ret] = '/0';

            printf("%s/n", buf);

        }

    }

}

void father_work()

{

    int nfds, ret;

    father_close_fds();

    con_readfds(); 

    while (1) {

        ret = poll(fds, PIPENUM, -1);

        if (ret > 0) {

            father_actual_work();

        }

        if (ret == -1) {

            perror("select");

            return;

        }

    }

}

int main(void)

{

    int ret, i;

    pid_t pid;

    ret = creat_pipe();

    if (ret == -1)

        exit(1);

    for (i = 0; i < PIPENUM; i++) {

        pid = fork();

        if (pid == 0) {

            child_work(i);

            exit(0);

        }

    }

    father_work();

    exit(0);

}

/*poll 和pipe ，监视5 个管道, 子进程写，父进程读*/

6 、

/*writev.c*/
#include <sys/uio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    int fd, i;
    char *ptr[3] = {
        "china:",
        "korea:",
        "japan1"
    };

    struct iovec iov[3];
    for (i = 0; i < 3; i++) {
        iov[i].iov_base = ptr[i];
        iov[i].iov_len = 6;
    }
   
    writev(1, iov, 3);
    printf("/n");
    exit(0);
}

7 、

/*readv.c*/
#include <sys/uio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    int fd, i;

    struct iovec iov[3];
    for (i = 0; i < 3; i++) {
        iov[i].iov_base = malloc(32);
        iov[i].iov_len = 32;
    }
    

    fd = open("/etc/passwd", O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(1);
    }

    readv(fd, iov, 3);
    for (i = 0; i < 3; i++) {
        printf("%s/n", (char *)iov[i].iov_base);
    }
    close(fd);
    exit(0);
}

8 、

/*sigio.c*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
int fd[2];

void async_read(int s)
{
    char buf[32];
    int ret = read(fd[0], buf, 32);
    write(1, buf, ret);
    printf("/n");
}

int main(void)
{
    struct sigaction act;
    int ret;

    act.sa_handler = async_read;
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_RESTART;

    sigaction(SIGIO,&act, NULL);
    
    ret = pipe(fd);
    if (ret == -1) {
        perror("pipe");
        exit(1);
    }

    fcntl(fd[0], F_SETOWN, getpid());
    ret = fcntl(fd[0], F_GETFL);
    fcntl(fd[0], F_SETFL, O_ASYNC);//???fcntl(fd[0], F_SETFL,ret | O_ASYNC)

    while (1) {
        sleep(3+rand()%3);
        write(fd[1], "Hello", 5);
    }
}
/*
  SIGIO信号：这个信号可以通知某种事件已发生
  为了接收SIGIO信号，需执行下列几步：
  1、sigaction(SIGIO,&act, NULL);为SIGIO信号建立信号处理程序
  2、fcntl(fd[0], F_SETOWN, getpid());以F_SETOWN调用fcntl来设置进程ID和进程组ID，它们将接收对于该描述符的信号。
  3、fcntl(fd[0], F_SETFL,ret | O_ASYNC);以 F_SETFL调用fcntl设置O_ASYNC文件状态标志，使在该描述符上可以进行异步I/O.
*/

yuhai8702
关注
专栏目录
《unix高级环境编程》高级 I/O——非阻塞 I/O
关注校招求职，微信号：job_campus
11-15 1277
非阻塞I/O使我们可以调用 open、write和read 这样的I/O操作，并使这些操作不会永远阻塞。如果这种操作不能完成，则立即出错返回，表示该操作若继续执行将阻塞。 对于一个给定的文件描述符由以下两种方法可以对其指定非阻塞I/O： 若调用open 获得描述符，则可指定O_NONBLOCK标志； 对已打开的描述符，可以使用fcntl，由该函数打开O_NONBLOCK文件状态标志； 测试
高级I/O函数
qq_43807092的博客
10-05 103
创建文件描述符的函数 pipe函数 #include <unistd.h> int pipe(int pipefd[2]); 成功：返回0 失败：返回-1，并设置errno。 功能：pipe创建两个文件描述符pipefd[0]，pipefd[1]。pipefd[0]负责读管道，pipifd[1]负责写管道。默认情况下是这一对文件描述符是阻塞的。 用read系统调用读取空管道，read将会被阻塞，直到有数据写入。 用write系统调用写满的管道，write将会被阻塞，直到有数据读出。 将文件
I/O系统
sermonlizhi的博客
09-12 1720
一、I/O硬件 1.1 I/O设备 在计算机的主板上，CPU以及各类设备之间的数据传输都是通过总线来完成 总线：一组线路和通过线路传输信息的一个协议 以CPU和内存为例，它们之间的数据传输，一条线路一次只能传输一个bit，如果想要一次传输多个bit，就需要多条线路，多条线路为一组，称为总线，这种多条线路同时传输的方式称为并行，单条线路传输的方式称为串行。 如果设备与设备之间都是并行传输，以为这需要太多的总线，计算机的体积也会复杂起来，同时碍于线路的密度太高，彼此之间的传输也会收到影响，而从传输效率上，假设并
计算机组成原理 I/O方式
最新发布
个人博客，记录了本人学习的各种有趣的技术。
02-11 2840
在可以响应中断的条件下，CPU暂时中止正在执行的程序，转去执行中断服务程序为外设服务，在中断服务程序中完成一次主机与外设之间的数据传送，传送完成后，CPU返回原来的程序。中断:由于系统中某些突发事件或异常情况的发生，而强迫CPU暂停(或中断)正在执行的程序转去执行相应的服务，当中断服务结束之后再回到原来被中断的地方继续执行原来的程序。注意:中断向量是中断服务程序的入口地址，中断向量地址是指中断服务程序的入口地址的地址。硬件判优: 指利用专门的硬件电路或中断控制器来安排冬中断源的优先级。
四、高级文件I/O
代码的键盘手。。。
09-03 381
总览散布/聚集I/O：I/O在单次调用中同时对多个缓冲区做读取或者写入操作，适合于聚集多个不同数据结构进行统一的I/O操作。 epoll：poll()和select()的改进版，在一个程序需要处理数百个文件描述符的时候很有用。 内存映射I/O：将文件映射到内存，可以用简单的内存管理方式来处理文件，适合有特殊要求的I/O。 文件I/O提示：语序进程将文件I/O使用上的一些提示信息提供给内核；能提
Unix I/O 小结
06-27
Unix I/O系统是操作系统的核心部分，它...总之，Unix的I/O机制涉及从底层的系统调用到高级的缓冲机制，提供了丰富的功能和优化手段，以适应不同场景的需求。理解和掌握这些知识对于进行高效和可靠的Unix编程至关重要。
I/O数据寄存器及其应用
11-12
在微控制器和嵌入式系统的设计中，I/O（Input/Output）数据寄存器扮演着至关重要的角色。这些寄存器是系统与外部世界交互的桥梁，允许我们控制和监测设备的状态。本文将深入探讨I/O数据寄存器的工作原理、应用以及...
Small-OS智能卡的I/O管理器
11-14
I/O管理器不仅处理常规的数据传输，而且承担了高级任务，如命令的成功或失败处理，以及遵循特定的通信协议。特别是对于ATR（Answer To Reset）和T=1传输协议，它们都在I/O管理器内部得以完全实现。T=1协议是一个复杂...
(myls)模拟" ls "命令
yuhai8702的专栏
09-16 3996
/*2010-09-16*//*模拟" ls "命令*//*myls*/#include #include #include #include #include #include #include #include void myls(const char* path){    const char* savepath=path;    char BUF[500];    struct stat buf;    int ret;    bzero(BUF,500);    ret=lstat(path,&b
mycp
yuhai8702的专栏
09-14 1055
/*2010-09-14*//*1 实现一个mycp,功能如同cp 例如： ./mycp /etc/passwd /tmp/passwd*//* *打开要被复制的文件1，同时创建一个新的文件2，读文件1到BUF，然后将BUF的内 *容写到文件2 * */#include #include #include #include int main(int argc,char** argv){    if(argc!=3)    {        perror("argc");        exit(1);   
进程间通信
yuhai8702的专栏
10-05 985
进程间通信一、主要函数：pipe();msgsnd();msgrcv();二、1、管道:pipe()一切设备皆文件管道属于内核，是内核的一片内存，fork不会有这样的内存管道没有数据时会阻塞。一旦数据被从管道里读出来，那么管道里就没有这个数据了。管道的数据，读完了就没有了，不像文件。管道pipe要在fork之前2、fifo1)用mkfifo创建一个fifo文件"saif"  fifo也是有大小限制的，最大为65536，如果没有数据也会阻塞  注：尽量少用fifo2)/*如果写端已关闭，那么读端不再阻塞，会跟
信号
yuhai8702的专栏
10-05 779
信号一、主要函数：signal();alarm();pause();setitimer();sigprocmask();sigaction();二、kill -l 列出当前支持的信号不存在编号为0的信号普通信号不排队，实时信号排队(但一般我们用不着)  异种信号允许嵌套，那一个未完也可嵌入另一个；  同种信号不允许嵌套，同种信号不排队，所以为了防止信号丢失，信号处理一定要快。1、signal对信号的处理有三种方式：1)捕捉信号,signal(SIGINT,sig_handler);   void sig_h
文件锁
yuhai8702的专栏
10-06 778
文件锁 一、主要函数：fcntl 二、 读锁是共享锁，读排斥写 F_SETLKW是F_SETLK的一个阻塞版本 (SEEK_SET,0,0)锁整个文件 l_len要么是0，要么大于0 l_type 只能由自己修改 F_GETLK测试一把锁 注意：子进程不继承文件锁 用锁的时候，不要用标准I/O(fread,fwrite),应用read,write 死锁： 系统遇见死锁，它会选择一个进程退出，退出的这个进程一般是最后一次加锁失败引起死锁的那个进程 kill(pid,SIGINT)
时间和日期
yuhai8702的专栏
10-05 731
时间和日期一、主要函数：time();ctime();strftime();localtime();gettimeofday();二、/*2010-09-18*//*时间和日期*//*time()返回值是以秒为单位的，ctime()以固定的格式输出时间日期，strftime()可以按照某种格式打印，也就是自定义打印格式。localtime()返回符合认知的时间，gettimeofday()可以精确到微秒。*/#include #include #include #include typedef long l
文件I/O
yuhai8702的专栏
10-05 683
文件I/O一、主要函数：open(),creat(),read(),write(),close(),fcntl(),lseek()二、open,creat,read,write,close等函数的操作与文件描述符fd有关。1、对于open函数而言，仅当创建新文件时才使用第三个参数，由open返回的文件描述符一定是最小的未用描述符数值，常用的常量有O_CREAT,O_TRUNC,O_NONBLOCK,常用open函数代替creat2、lseek成功执行，返回新的文件偏移量(相对于文件头0所偏移的量);比较ls
网络编程
yuhai8702的专栏
10-18 648
<br />1、端口号是用来区分用户程序的。<br />2、其实，只要撑握了UNIX域的编程，那么网络编程就显得简单了。<br />3、UNIX域：UDP  和  TCP<br />      网络：      UDP  和  TCP<br />4、下面是相关的例程：<br />一、首先是UNIX域的编程：<br />1、C<br />/*UNIX域：UDP_client*/<br /> #include <sys/socket.h><br /> #include <sys/types.h><br />
加密
yuhai8702的专栏
10-05 551
加密 一、主要函数：crypt(); 二、 1、注意：crypt加密，GCC编译时要加上参数-lcrypt 2、char *res = (char *)crypt(argv[1], "abc"); 三、例程： 1、 /*crypt.c*/ #include #include int main(int argc, char **argv) { char *res = (char *)crypt(argv[1], "abc"); printf("%s/n", res);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值