UNP函数笔记十三: 非阻塞式I/O

最新推荐文章于 2020-12-30 19:16:06 发布
最新推荐文章于 2020-12-30 19:16:06 发布
阅读量780 收藏
点赞数
分类专栏： 笔记 c unix 文章标签： socket file struct null descriptor server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxxmaker/article/details/7482709
版权
笔记 同时被 3 个专栏收录
82 篇文章 0 订阅
订阅专栏
c
58 篇文章 0 订阅
订阅专栏
unix
49 篇文章 0 订阅
订阅专栏

第十六章  非阻塞式I/O:


示例:

#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/socket.h>

#include "err_exit.h"

#define MAXLINE 4096

char * 
gf_time(void)
{
    struct timeval   tv;
    time_t           t;
    static char      str[30];
    char           * ptr;

    if (gettimeofday(&tv, NULL) != 0) {  /* should always return 0 */
        err_exit("gettimeofday error");
    }

    t = tv.tv_sec; /* POSIX says tv.tv_sec is time_t; some BSDs don't agree */
    ptr = ctime(&t);
    strcpy(str, &ptr[11]);
    /* Fri Sep 13 00:00:00 1986\n\0 */
    /* 0123456789012345678901234 5  */
    snprintf(str+8, sizeof(str)-8, ".%06ld", tv.tv_usec);

    return(str);
}

void 
str_cli(FILE * fp, int sockfd)
{
    int       maxfdp1; 
    int       val;
    int       stdineof;
    ssize_t   n;
    ssize_t   nwritten;
    fd_set    rset;
    fd_set    wset;
    char      to[MAXLINE];
    char      fr[MAXLINE];
    char    * toiptr;
    char    * tooptr;
    char    * friptr;
    char    * froptr;

    if ((val = fcntl(sockfd, F_GETFL, 0)) == -1) {
        err_exit("fcntl error");
    }
    if (fcntl(sockfd, F_SETFL, val | O_NONBLOCK) == -1) {
        err_exit("fcntl error");
    }

    if ((val = fcntl(STDIN_FILENO, F_GETFL, 0)) == -1) {
        err_exit("fcntl error");
    }
    if (fcntl(STDIN_FILENO, F_SETFL, val | O_NONBLOCK) == -1) {
        err_exit("fcntl error");
    }

    if ((val = fcntl(STDOUT_FILENO, F_GETFL, 0)) == -1) {
        err_exit("fcntl error");
    }
    if (fcntl(STDOUT_FILENO, F_SETFL, val | O_NONBLOCK) == -1) {
        err_exit("fcntl error");
    }

    /* initialize buffer pointers */
    toiptr = tooptr = to;  
    friptr = froptr = fr;
    stdineof = 0;

    maxfdp1 = max(STDIN_FILENO, STDOUT_FILENO);
    maxfdp1 = max(maxfdp1, sockfd) + 1;
    for ( ; ; ) {
        FD_ZERO(&rset);
        FD_ZERO(&wset);
        if (stdineof == 0 && toiptr < &to[MAXLINE]) {
            FD_SET(STDIN_FILENO, &rset);  /* read from stdin */
        }
        if (friptr < &fr[MAXLINE]) {
            FD_SET(sockfd, &rset);  /* read from socket */
        }
        if (tooptr != toiptr) {
            FD_SET(sockfd, &wset);  /* data to write to socket */
        }
        if (froptr != friptr) {
            FD_SET(STDOUT_FILENO, &wset);  /* data to write to stdout */
        }

        if (select(maxfdp1, &rset, &wset, NULL, NULL) == -1) {
            err_exit("select error");
        }

        if (FD_ISSET(STDIN_FILENO, &rset)) {
            if ((n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("read error on stdin\n");
                    exit(1);
                }
            } 
            else if (n == 0) {
                fprintf(stderr, "%s: EOF on stdin\n", gf_time());
                stdineof = 1;  /* all done with stdin */
                if (tooptr == toiptr) {
                    if (shutdown(sockfd, SHUT_WR) == -1) {  /* send FIN */
                        err_exit("shutdown error");
                    }
                }
            }
            else {
                fprintf(stderr, "%s: read %d bytes from stdin\n", gf_time(), n);
                toiptr += n;  /* just read */
                FD_SET(sockfd, &wset);  /* try and write to socket below */
            }
        }

        if (FD_ISSET(sockfd, &rset)) {
            if ((n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("read error on socket\n");
                    exit(1);
                }
            }
            else if (n == 0) {
                fprintf(stderr, "%s: EOF on socket\n", gf_time());
                if (stdineof) {
                    return;  /* normal termination */
                }
                else {
                    printf("str_cli: server terminated prematurely");
                    exit(1);
                }
            }
            else {
                fprintf(stderr, "%s: read %d bytes from socket\n", 
                        gf_time(), n);
                friptr += n;  /* just read */
                FD_SET(STDOUT_FILENO, &wset);  /* try and write below */
            }
        }

        if (FD_ISSET(STDOUT_FILENO, &wset) && ((n = friptr - froptr) > 0)) {
            if ((nwritten = write(STDOUT_FILENO, froptr, n)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("write error to stdout\n");
                    exit(1);
                }
            }
            else {
                fprintf(stderr, "%s: wrote %d bytes to stdout\n",
                        gf_time(), nwritten);
                froptr += nwritten;  /* just written */
                if (froptr == friptr) {
                    froptr = friptr = fr;  /* back to beginning of buffer */
                }
            }
        }

        if (FD_ISSET(sockfd, &wset) && ((n = toiptr - tooptr) > 0)) {
            if ((nwritten = write(sockfd, tooptr, n)) < 0) {
                if (errno != EWOULDBLOCK) {
                    printf("write error to socket\n");
                    exit(1);
                }
            }
            else {
                fprintf(stderr, "%s: wrote %d bytes to socket\n",
                        gf_time(), nwritten);
                tooptr += nwritten;  /* just written */
                if (tooptr == toiptr) {
                    toiptr = tooptr = to;  /* back to beginning of buffer */
                    if (stdineof) {
                        if (shutdown(sockfd, SHUT_WR) == -1) {  /* send FIN */
                            err_exit("shutdown error");
                        }
                    }
                }
            }
        }
    }
}

#include <signal.h>
#include <sys/socket.h>

#include "err_exit.h"

#define MAXLINE 4096

void 
str_cli(FILE * fp, int sockfd)
{
    int    n;
    pid_t  pid;
    char   sendline[MAXLINE];
    char   recvline[MAXLINE];

    if ((pid = fork()) < 0) {
        err_exit("fork error");
    }
    else if (pid == 0) {  /* child: server -> stdout */
        while ((n = readline(sockfd, recvline, MAXLINE)) > 0) {
            if (fputs(recvline, stdout) == EOF) {
                err_exit("fputs error");
            }
        }
        if (n < 0) {
            err_exit("readline error");
        }
        
        if (getppid() != 1) {
            kill(getppid(), SIGTERM);  /* in case parent still running */
        }
        exit(0);
    }
    else {  /* parent: stdin -> server */
        while (fgets(sendline, MAXLINE, fp) != NULL) {
            n = strlen(sendline);
            if (writen(sockfd, sendline, n) != n) {
                err_exit("writen error");
            }
        }
        if (ferror(fp)) {
            err_exit("fgets error");
        }

        if (shutdown(sockfd, SHUT_WR) == -1) {  /* EOF on stdin, send FIN */
            err_exit("shutdown error");
        }

        pause();
        return;
    }
}

#include <fcntl.h>
#include <sys/socket.h>

#include "err_exit.h"

int 
connect_nonb(int sockfd, const struct sockaddr * saptr, 
             socklen_t salen, int nsec)
{
    int             flags;
    int             n;
    int             error;
    socklen_t       len;
    fd_set          rset;
    fd_set          wset;
    struct timeval  tval;

    if ((flags = fcntl(sockfd, F_GETFL, 0)) == -1) {
        err_exit("fcntl error");
    }
    if (fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) == -1) {
        err_exit("fcntl error");
    }

    error = 0;
    if ((n = connect(sockfd, saptr, salen)) == -1) {
        if (errno != EINPROGRESS) {
            return(-1);
        }
    }

    /* Do whatever we want while the connect is taking place. */

    if (n == 0) {
        goto done;  /* connect completed immediately */
    }

    FD_ZERO(&rset);
    FD_SET(sockfd, &rset);
    wset = rset;
    tval.tv_sec = nsec;
    tval.tv_usec = 0;

    if ((n = select(sockfd+1, &rset, &wset, NULL,
                    nsec ? &tval : NULL)) == -1) {
        err_exit("select error");
    }
    else if (n == 0) {
        close(sockfd);  /* timeout */
        errno = ETIMEDOUT;
        return(-1);
    }

    if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
        len = sizeof(error);
        if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) == -1) {
            return(-1);  /* Solaris pending error */
        }
    }
    else {
        printf("select error: sockfd not set\n");
        exit(1);
    }

done:
    /* restore file status flags */
    if (fcntl(sockfd, F_SETFL, flags) == -1) {
        err_exit("fcntl error");
    }

    if (error) {
        close(sockfd);        /* just in case */
        errno = error;
        return(-1);
    }
    return(0);
}

#include <fcntl.h>
#include <sys/select.h>

#include "myio.h"
#include "err_exit.h"
#include "host_serv.h"
#include "tcp_connect.h"

#define MAXFILES  20
#define SERV      "80"  /* port number or service name */

struct file {
    char * f_name;   /* filename */
    char * f_host;   /* hostname or IPv4/IPv6 address */
    int    f_fd;     /* descriptor */
    int    f_flags;  /* F_xxx below */
} file[MAXFILES];

#define F_CONNECTING   1  /* connect() in progress */
#define F_READING      2  /* connect() complete; now reading */
#define F_DONE         4  /* all done */

#define GET_CMD        "GET %s HTTP/1.0\r\n\r\n"

#define min(a, b) ((a) < (b) ? (a) : (b))

int     nconn;
int     nfiles;
int     nlefttoconn;
int     nlefttoread;
int     maxfd;
fd_set  rset;
fd_set  wset;

void 
home_page(const char * host, const char * fname)
{
    int   fd;
    int   n;
    char  line[MAXLINE];

    fd = tcp_connect(host, SERV);  /* blocking connect() */

    n = snprintf(line, sizeof(line), GET_CMD, fname);
    if (writen(fd, line, n) != n) {
        err_exit("writen error");
    }

    for ( ; ; ) {
        if ((n = read(fd, line, MAXLINE)) < 0) {
            err_exit("read error");
        }
        else if (n == 0) {
            break;  /* server closed connection */
        }

        printf("read %d bytes of home page\n", n);
        /* do whatever with data */
    }
    printf("end-of-file on home page\n");
    if (close(fd) == -1) {
        err_exit("close error");
    }
}

void 
write_get_cmd(struct file * fptr)
{
    int   n;
    char  line[MAXLINE];

    n = snprintf(line, sizeof(line), GET_CMD, fptr->f_name);
    if (writen(fptr->f_fd, line, n) != n) {
        err_exit("writen error");
    }
    printf("wrote %d bytes for %s\n", n, fptr->f_name);

    fptr->f_flags = F_READING;  /* clears F_CONNECTING */

    FD_SET(fptr->f_fd, &rset);  /* will read server's reply */
    if (fptr->f_fd > maxfd) {
        maxfd = fptr->f_fd;
    }
}

void 
start_connect(struct file * fptr)
{
    int               fd;
    int               flags;
    int               n;
    struct addrinfo * ai;

    ai = host_serv(fptr->f_host, SERV, 0, SOCK_STREAM);

    if ((fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) {
        err_exit("socket error");
    }
    fptr->f_fd = fd;
    printf("start_connect for %s, fd %d\n", fptr->f_name, fd);

    /* Set socket nonblocking */
    if ((flags = fcntl(fd, F_GETFL, 0)) == -1) {
        err_exit("fcntl error");
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        err_exit("fcntl error");
    }

    /* Initiate nonblocking connect to the server. */
    if ((n = connect(fd, ai->ai_addr, ai->ai_addrlen)) == -1) {
        if (errno != EINPROGRESS) {
            printf("nonblocking connect error\n");
            exit(1);
        }
        fptr->f_flags = F_CONNECTING;
        FD_SET(fd, &rset);  /* select for reading and writing */
        FD_SET(fd, &wset);
        if (fd > maxfd) {
            maxfd = fd;
        }
    }
    else {  /* connect is already done */ 
        write_get_cmd(fptr);  /* write() the GET command */
    }
}

int 
main(int argc, char ** argv)
{
    int     i;
    int     fd;
    int     n;
    int     maxnconn;
    int     flags;
    int     error;
    char    buf[MAXLINE];
    fd_set  rs;
    fd_set  ws;

    if (argc < 5) {
        printf("usage: web <#conns> <hostname> <homepage> <file1> ...\n");
        exit(1);
    }
    maxnconn = atoi(argv[1]);

    nfiles = min(argc - 4, MAXFILES);
    for (i = 0; i < nfiles; i++) {
        file[i].f_name = argv[i + 4];
        file[i].f_host = argv[2];
        file[i].f_flags = 0;
    }
    printf("nfiles = %d\n", nfiles);

    home_page(argv[2], argv[3]);

    FD_ZERO(&rset);
    FD_ZERO(&wset);
    maxfd = -1;
    nlefttoread = nlefttoconn = nfiles;
    nconn = 0;

    while (nlefttoread > 0) {
        while (nconn < maxnconn && nlefttoconn > 0) {
            /* find a file to read */
            for (i = 0 ; i < nfiles; i++) {
                if (file[i].f_flags == 0) {
                    break;
                }
            }
            if (i == nfiles) {
                printf("nlefttoconn = %d but nothing found\n", nlefttoconn);
            }
            start_connect(&file[i]);
            nconn++;
            nlefttoconn--;
        }

        rs = rset;
        ws = wset;
        if ((n = select(maxfd+1, &rs, &ws, NULL, NULL)) == -1) {
            err_exit("select error");
        }

        for (i = 0; i < nfiles; i++) {
            flags = file[i].f_flags;
            if (flags == 0 || flags & F_DONE) {
                continue;
            }
            fd = file[i].f_fd;
            if (flags & F_CONNECTING &&
                (FD_ISSET(fd, &rs) || FD_ISSET(fd, &ws))) {
                n = sizeof(error);
                if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &n) < 0 ||
                    error != 0) {
                    printf("nonblocking connect failed for %s\n", 
                            file[i].f_name);
                }
                else {  /* connection established */
                    printf("connection established for %s\n", file[i].f_name);
                    FD_CLR(fd, &wset);  /* no more writeability test */
                    write_get_cmd(&file[i]);  /* write() the GET command */
                }
            }
            else if (flags & F_READING && FD_ISSET(fd, &rs)) {
                if ((n = read(fd, buf, sizeof(buf))) < 0) {
                    err_exit("read error");
                }
                else if (n == 0) {
                    printf("end-of-file on %s\n", file[i].f_name);
                    if (close(fd) == -1) {
                        err_exit("close error");
                    }
                    file[i].f_flags = F_DONE;  /* clears F_READING */
                    FD_CLR(fd, &rset);
                    nconn--;
                    nlefttoread--;
                }
                else {
                    printf("read %d bytes from %s\n", n, file[i].f_name);
                }
            }
        }
    }
    exit(0);
}

ken_scott
关注
专栏目录
AR502H-CN开发笔记34：socket中的read和write函数
snmplink的博客
08-12 1183
本系列文章将向大家讲述华为网关AR502H的开发方法。 本文介绍socket中read和write函数的使用方法。 本文转载自：浅谈TCP/IP网络编程中socket的行为 我认为，想要熟练掌握Linux下的TCP/IP网络编程，至少有三个层面的知识需要熟悉： 1. TCP/IP协议（如连接的建立和终止、重传和确认、滑动窗口和拥塞控制等等） 2. Socket I/O系统调用（重点如read/write），这是TCP/IP协议在应用层表现出来的行为。 3. 编写Performant, Scal
UNP读书笔记之 非阻塞connect
DrawnBreak
03-03 292
下文实现的程序内容是一个web客户端这个客户端向web一次性请求多个图片这些图片并非串行传输，而是同时建立多个连接，在进行传输。这里利用了非负责的connect， 每次connect并进行三次握手时，先直接返回， 然后一系列设置。在main的for循环中，  用select检测那个链接是否可写或可读， 可写时三次握手结束，需要发送“GET HTTP”请求。可读时，指需要读该文件。而且每次只读一次，...
【实用】SOCKET套接字错误代码(Error)值
u011124317的专栏
06-01 3795
本文描述了可能错误代码， 是由 WSAGetLastError (Wsapiref_2tiq.asp) 函数返回。按字母顺序列出错误由错误宏。 从任何函数不返回 Winsock2.h 中定义一些错误代码。 本文中不包含这些错误代码。做网络编程被报错而真心蛋疼的孩子们有救了。 WSAEINTR (10004) * 转换 ： 中断函数调用。 * 说明 ： 阻塞操作中断由对 WSACan
UNP函数笔记十四: 带外数据
二斗墨汁
04-21 675
第二十四章  带外数据: #include int sockatmark(int sockfd); have oob mark return 1, have not oob mark return 0, error return -1 示例: #include int sockatmark(int fd) { int flag; if (io
week3-unix文件标准输入输出（课本ch02）
chase_2414616363
10-23 3621
Week3-文件标准输入输出（课本ch02） 2.1 Unix 输入输出基本概念 1.打开文件：在任何一种操作系统中，程序开始读写一个文件的内容之前，必须首先在程序与文件之间 建立连接或通信通道，这一过程称为打开文件。 2.打开文件两种方式： 文件描述字：返回一个文件描述字 流：返回一个流 3.系统中关于I/O的函数也分为两大类: 一类针对文件描述字操作，另一类针对流操作。 4.关闭文件：当己完成对文件的读写之后，可以通过关闭文件而终止程序与文件的这种连接。一旦关闭 了一个文件描述字或者一个流，就不能再
【unix网络编程第三版】阅读笔记（五）：I/O复用：select和poll函数
ZeeCoder
07-14 5685
本博文主要针对UNP一书中的第六章内容来聊聊I/O复用技术以及其在网络编程中的实现 1. I/O复用技术I/O多路复用是指内核一旦发现进程指定的一个或者多个I/O条件准备就绪，它就通知该进程。I/O复用适用于以下场合：(1) 当客户处理多个描述符（一般是交互式输入或网络套接字），必须适用I/O复用(2) 当一个客户处理多个套接字时，这种情况很少见，但也可能出现(3) 当一个TCP服务器既要处理监听套
UNP笔记：第三章
Owen Wei的博客
12-30 148
UNIX 网络编程 卷1：套接字联网API 套接字编程简介 1 套接字地址结构 对于一个套接字描述符，需要将它绑定到具体的套接字上，而不同协议的套接字具有不同的结构，它们都以sockaddr_开头，并附加一个后缀用来表示具体的套接字类型。 IPv4的套接字结构 IPv4套接字定义在<netinet/in.h>头文件中，显然对应的套接字名称为sockaddr_in。 注：in是Internet的缩写，而结构中的sin_即为sockaddr_in的缩写。 struct in_addr
UNIX网络编程(UNP) 第三章学习笔记
404lz保留地
11-21 215
首先我们需要了解套接字地址结构到底长啥样，我们可以在<netinet/in.h>中找到下面的结构 /* * Internet address (a structure for historical reasons) */ struct in_addr { in_addr_t s_addr; // 32位的IPV4地址，一般实现方式是uint3...
UNIX网络编程(UNP) 第五章学习笔记
404lz保留地
11-23 279
在本章中，我们将完成一个可以回射的服务器和客户端，并且我们需要理解在每一个环节可能出现什么问题，并且加以预防 代码（带注释） // server #include "../unp.h" int main(int argc, char **argv) { int listenfd,connfd; pid_t child_pid; socklen_t clilen; s...
linux下运行《UNIX环境高级编程》的第一个程序时源码编译出错的处理方法
叶子一哥
01-19 9194
前几天买了《UNIX环境高级编程》这本书，想好好学习下linux的编程。谁知道看到第一个列出指定目录的内容的那个例子，其实就是shell中 ls 的内容，打好代码要运行时一直出问题。后来在网上找了挺多的解决方法，终于解决了。先把方法贴上。 先在终端里面输入 vi ls.c在里面编辑如下代码 #include "apue.h" #include int main(int
unix高级高级环境编程的error.h
baidu_34700419的博客
02-24 379
发现网上有些资源复制下来有编码错误，自己遇到了这个问题并解决了，然后把代码就复制下来，希望对大家有帮助！ #include "apue.h" #include &lt;errno.h&gt;      /* for definition of errno */ #include &lt;stdarg.h&gt;     /* ISO C variable aruments */   static...
linux/err.h
eager7的专栏
01-06 4272
文件的代码 #ifndef _LINUX_ERR_H #define _LINUX_ERR_H #include linux/compiler.h> #include asm/errno.h> /*  * Kernel pointers have redundant information, so we can use a  * scheme wh
errno.h 错误码描述.
weixin_30820077的博客
09-02 538
描述:一般说的Linux源码的目录,默认是基于 /usr/include/ 的. 　　使用 1 char *strerror(int errnum); 　　函数打印错误代码的描述.我简单对比了一下,发现描述大体一致,但有些地方,strerror 函数的描述还稍微详细点. 　　在实际编程中用这一招解决了不少原本看来莫名其妙的问题。比较 麻烦的是每次都要去linux源代码里面查找错...
err.h中的四个常用函数
weixin_34363171的博客
06-01 1887
err.h为GLIBC的一部分，不同与errno.h。也就是说，你没法在WNT上用到这个库。它定义了8个函数，其中有4个函数最为常用，它们分别为warn, warnx, err, errx。它们将可执行文件名(argv[0])和接受的第一个形参(err,errx是第二个)输出到stderr。warn,err函数会额外输出一个": "以及errno的标准错误字符串(一般为"Success")。err...
x86上的那些UNIX——System V篇（Solaris、SCO）
fryer
04-09 7691
上篇BSD篇讲述了开源世界的UNIX，今天我们进入商业UNIX世界——System V的后裔，商业UNIX大都通过了UNIX认证，而且大多并不使用FreeBSD等使用的自由软件桌面 2.Solaris篇       《UNIX环境高级编程》的第二版曾说Solaris是目前（10年前……）唯一有一定市场份额的System V后裔，这个说法现在已经不太适用了，经过21世纪初市值冲到2000亿美
UNIX/Linux程序设计教程之错误处理
路人甲
01-16 1276
UNIX的系统调用和大部分库函数在失败时会返回一特殊值报告出错，这个特殊值通常是–1。这种返回值仅告诉调用遇到了错误而已，为了让应用知道究竟发生了什么错误，系统调用和库函数同时还会在系统定义的变量errno中给出指明错误原因的错误码。 变量errno是系统调用和库函数用来报告错误的一种标准方法。早期的UNIX和C将它实现为外部整型变量，其说明为： extern int errno；
libjpeg:实现jpeg内存压缩暨error_exit错误异常处理和个性化参数设置
10km的专栏
01-20 5622
libjpeg-turbo是与libjpeg接口兼容的一个jpeg编/解码库，其主要的特点就是利用SIMD指令(如X86架构的MMX/SSE/SSE2，ARM架构的NEON)来加速jpeg图像的编/解码,相比被广泛使用的libjpeg，编码和解码性能提高2~4倍左右。 本文介绍的内容适用于libjpeg-turbo和libjpeg(80以上版本) 关于如何用gcc对libjpeg编译,请参考我之
linux c之perror和exit使用总结
码莎拉蒂
02-21 5762
一、perror介绍 perror函数用一种简单统一的方式报告错误。例如，一个程序试读一个不存在的磁盘文件，操作系统除了“出错了！”，这时，库函数首先会将代表操作出错的具体原因的错误代码保存到全局整型变量errono（在errno.h中定义），然后它再将错误提示传给用户程序。perror函数只是将errno代表的特定的错误报告给用户，它的原型在stdio.h中定义下： void per
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值