错误处理的基石：errno全面解析

原创 于 2025-10-09 22:35:21 发布 · 849 阅读 · 24 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C #错误处理 #C++

《错误处理的基石：errno全面解析》内容框架

第一章：初识errno——程序员的错误信使

  • 从一个简单的文件打开失败案例引入
  • errno的基本概念与历史沿革
  • 错误处理的演进历程时间轴

第二章：深入errno内部机制

  • errno的实现原理与线程安全性
  • 系统调用与errno的关联机制
  • errno的存储结构与访问方式

第三章：errno错误代码全解析

  • 错误分类体系与标准错误代码
  • 重要错误代码详解及应用场景
  • 平台相关错误代码差异对比

第四章：errno在实际开发中的应用

  • 案例一：文件系统操作错误处理
  • 案例二：网络编程中的错误处理
  • 案例三：内存管理与进程控制错误

第五章：errno的最佳实践与陷阱规避

  • 正确的errno使用模式
  • 常见误用场景分析
  • 现代C++中的错误处理替代方案

第六章：errno的调试与工具支持

  • 调试技巧与错误信息转换
  • 相关工具库函数详解
  • 性能考量与优化建议

附录：完整错误代码参考表

错误处理的基石：errno全面解析

第一章：初识errno——程序员的错误信使

1.1 从一个现实案例开始

想象这样的场景：你正在开发一个文件处理程序，用户尝试打开一个不存在的文件。程序没有崩溃，但也没有给出有用的错误信息。这时，errno就扮演了关键角色。

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main() {
    FILE *file = fopen("nonexistent_file.txt", "r");
    if (file == NULL) {
        printf("错误代码: %d\n", errno);
        printf("错误描述: %s\n", strerror(errno));
        perror("fopen失败");
    }
    return 0;
}

运行结果可能显示：

错误代码: 2
错误描述: No such file or directory
fopen失败: No such file or directory

这个简单的例子展示了errno的核心价值：在系统调用失败时，提供具体的错误信息。

1.2 errno的历史演进

errno的概念可以追溯到Unix的早期版本。让我们通过时间轴了解其发展历程：

timeline
    title errno演进历程
    1970s : 早期Unix<br>简单的错误代码
    1980s : System V Unix<br>标准化错误代码
    1990s : POSIX标准<br>线程安全的errno
    2000s : C99/C++11<br>跨平台标准化
    2010s-现在 : 现代系统<br>扩展错误代码

1.3 errno的基本概念

定义：errno是一个全局整型变量，用于存储最近一次系统调用或库函数调用产生的错误代码。

关键特性：

  • 成功调用不重置errno（除非明确说明）
  • 每个线程有独立的errno副本
  • 错误代码是正整数，0表示成功

第二章：深入errno内部机制

2.1 errno的实现原理

在现代操作系统中，errno不再是简单的全局变量。让我们深入了解其实现机制：

线程安全的errno实现
// 传统实现（单线程时代）
extern int errno;

// 现代实现（多线程环境）
#define errno (*__errno_location())

// Linux下的典型实现
static __thread int errno_value;
int *__errno_location(void) {
    return &errno_value;
}
errno在系统调用中的角色
应用程序标准库内核调用fopen("file", "r")执行open系统调用返回-1 (失败)设置errno=ENOENT返回NULL检查errno值应用程序标准库内核

2.2 errno的存储结构

不同平台下errno的存储方式有所差异：

平台存储方式线程安全
Linux线程局部存储(TLS)是
WindowsTLS索引是
传统Unix全局变量否

2.3 错误代码的定义体系

errno值在标准头文件中定义：

// 在errno.h中的典型定义
#define EPERM        1  /* Operation not permitted */
#define ENOENT       2  /* No such file or directory */
#define ESRCH        3  /* No such process */
#define EINTR        4  /* Interrupted system call */
#define EIO          5  /* I/O error */
// ... 更多定义

第三章：errno错误代码全解析

3.1 错误分类体系

errno错误可以分为几个主要类别：

主要错误类别
errno错误分类
文件系统错误
内存错误
进程错误
网络错误
参数错误
资源错误
ENOENT
EACCES
EEXIST
ENOMEM
EFAULT
ESRCH
ECHILD
ECONNREFUSED
ETIMEDOUT
EINVAL
ERANGE
EAGAIN
ENOSPC

3.2 关键错误代码详解

3.2.1 文件系统相关错误

ENOENT (错误代码2)

  • 含义：文件或目录不存在
  • 常见场景：
    FILE *fp = fopen("nonexistent.txt", "r");
if (fp == NULL && errno == ENOENT) {
    // 处理文件不存在的情况
}

EACCES (错误代码13)

  • 含义：权限不足
  • 解决方案：
    if (errno == EACCES) {
    // 检查文件权限或尝试以其他用户身份运行
    printf("权限不足，请检查文件权限或使用sudo\n");
}
3.2.2 内存相关错误

ENOMEM (错误代码12)

  • 含义：内存不足
  • 处理策略：
    void *ptr = malloc(huge_size);
if (ptr == NULL && errno == ENOMEM) {
    // 实现内存分配失败的回退策略
    fprintf(stderr, "内存不足，尝试较小的分配\n");
    ptr = malloc(fallback_size);
}
3.2.3 网络相关错误

ECONNREFUSED (错误代码111)

  • 含义：连接被拒绝
  • 网络编程应用：
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
// ... 设置地址
if (connect(sockfd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
    if (errno == ECONNREFUSED) {
        printf("目标服务器拒绝连接\n");
    }
}

3.3 平台差异对比

不同操作系统对errno的扩展：

错误代码LinuxWindowsmacOS说明
EWOULDBLOCK✓✓✓操作将阻塞
EAGAIN✓✓✓重试操作
ENOSYS✓✓✓功能未实现
ECANCELED✓✗✓操作已取消
EADV✓✗✗Linux特有错误

第四章：errno在实际开发中的应用

4.1 案例一：健壮的文件系统操作

让我们构建一个完整的文件操作错误处理示例：

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

#define MAX_RETRIES 3

int safe_file_copy(const char *src, const char *dst) {
    FILE *src_file, *dst_file;
    char buffer[4096];
    size_t bytes_read;
    int retries = 0;
    
    // 尝试打开源文件
    while ((src_file = fopen(src, "rb")) == NULL) {
        switch (errno) {
            case ENOENT:
                fprintf(stderr, "错误: 源文件 '%s' 不存在\n", src);
                return -1;
            case EACCES:
                fprintf(stderr, "错误: 没有读取 '%s' 的权限\n", src);
                return -1;
            case EINTR:
                if (++retries >= MAX_RETRIES) {
                    fprintf(stderr, "错误: 打开源文件被多次中断\n");
                    return -1;
                }
                sleep(1); // 等待后重试
                break;
            default:
                fprintf(stderr, "错误: 无法打开源文件 '%s': %s\n", 
                       src, strerror(errno));
                return -1;
        }
    }
    
    // 类似逻辑处理目标文件...
    // [为简洁省略部分代码]
    
    fclose(src_file);
    return 0;
}

这个示例展示了如何：

  • 根据不同的errno值采取不同的恢复策略
  • 对可恢复错误（如EINTR）实现重试机制
  • 提供用户友好的错误信息

4.2 案例二：网络服务器的错误处理

在网络编程中，errno处理尤为重要：

#include <sys/socket.h>
#include <netinet/in.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>

#define MAX_CLIENTS 10

void handle_client_connection(int server_fd) {
    struct sockaddr_in client_addr;
    socklen_t addr_len = sizeof(client_addr);
    int client_fd;
    
    while (1) {
        client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &addr_len);
        
        if (client_fd == -1) {
            switch (errno) {
                case EAGAIN:
                case EWOULDBLOCK:
                    // 非阻塞socket，没有待处理的连接
                    usleep(100000); // 等待100ms
                    continue;
                case EINTR:
                    // 系统调用被信号中断
                    continue;
                case ECONNABORTED:
                    fprintf(stderr, "警告: 连接已中止\n");
                    continue;
                case EMFILE:
                case ENFILE:
                    fprintf(stderr, "错误: 文件描述符耗尽\n");
                    sleep(1); // 等待资源释放
                    continue;
                default:
                    fprintf(stderr, "严重错误: accept失败: %s\n", 
                           strerror(errno));
                    return;
            }
        }
        
        // 处理客户端连接
        process_client(client_fd);
    }
}

void process_client(int client_fd) {
    char buffer[1024];
    ssize_t bytes_read;
    
    while ((bytes_read = read(client_fd, buffer, sizeof(buffer))) > 0) {
        // 处理接收到的数据
        if (write(client_fd, buffer, bytes_read) == -1) {
            if (errno == EPIPE) {
                fprintf(stderr, "客户端断开连接\n");
                break;
            }
        }
    }
    
    if (bytes_read == -1 && errno != EAGAIN) {
        fprintf(stderr, "读取错误: %s\n", strerror(errno));
    }
    
    close(client_fd);
}

4.3 案例三：内存分配与进程管理

#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

// 安全内存分配器
void* safe_malloc(size_t size) {
    void *ptr = malloc(size);
    if (ptr == NULL) {
        if (errno == ENOMEM) {
            fprintf(stderr, "严重: 系统内存不足\n");
            // 这里可以触发紧急回收机制或优雅降级
        }
        exit(EXIT_FAILURE);
    }
    return ptr;
}

// 进程创建与错误处理
pid_t safe_fork(void) {
    pid_t pid = fork();
    
    if (pid == -1) {
        switch (errno) {
            case EAGAIN:
                fprintf(stderr, "错误: 无法创建新进程，系统进程数达到限制\n");
                break;
            case ENOMEM:
                fprintf(stderr, "错误: 内存不足，无法创建新进程\n");
                break;
            default:
                fprintf(stderr, "错误: fork失败: %s\n", strerror(errno));
        }
    }
    
    return pid;
}

// 等待子进程的健壮实现
int safe_waitpid(pid_t pid, int *status, int options) {
    int result;
    
    while ((result = waitpid(pid, status, options)) == -1) {
        if (errno != EINTR) {
            if (errno == ECHILD) {
                fprintf(stderr, "错误: 指定的子进程不存在\n");
            } else {
                fprintf(stderr, "错误: waitpid失败: %s\n", strerror(errno));
            }
            return -1;
        }
        // EINTR时继续等待
    }
    
    return result;
}

第五章：errno的最佳实践与陷阱规避

5.1 正确的errno使用模式

模式一：立即保存errno值
#include <errno.h>

int some_system_call() {
    int saved_errno;
    
    // 在调用可能修改errno的函数前保存当前值
    saved_errno = errno;
    
    // 执行可能失败的操作
    if (some_operation() == -1) {
        // 处理错误
        if (errno == EEXIST) {
            // 特殊处理
        }
    }
    
    // 恢复errno
    errno = saved_errno;
    return 0;
}
模式二：使用errno的完整检查流程
#include <errno.h>

int robust_operation() {
    // 首先清除之前的错误
    errno = 0;
    
    // 执行操作
    int result = some_library_call();
    
    // 完整的错误检查
    if (result == -1) {
        // 明确的错误
        return handle_error(errno);
    } else if (errno != 0) {
        // 某些库函数在成功时也可能设置errno
        return handle_success_with_errno(errno);
    }
    
    return result;
}

5.2 常见陷阱与解决方案

陷阱一：假设errno在成功时被清零
// 错误的做法
errno = 0;
printf("Hello World\n");  // 某些实现可能设置errno
if (errno != 0) {         // 这里可能错误地检测到"错误"
    perror("printf失败");
}

// 正确的做法
if (printf("Hello World\n") < 0) {
    perror("printf失败");
}
陷阱二：在多线程中错误使用errno
#include <pthread.h>
#include <errno.h>

// 错误的做法
void* thread_func_bad(void* arg) {
    if (some_call() == -1) {
        // 这里可能读取到其他线程设置的errno
        printf("错误: %s\n", strerror(errno));
    }
    return NULL;
}

// 正确的做法
void* thread_func_good(void* arg) {
    int local_errno;
    
    if (some_call() == -1) {
        local_errno = errno;  // 立即保存到局部变量
        printf("错误: %s\n", strerror(local_errno));
    }
    return NULL;
}

5.3 现代C++中的替代方案

虽然errno是C的传统，但现代C++提供了更好的选择：

#include <system_error>
#include <filesystem>
#include <iostream>

// 使用C++17的std::filesystem进行错误处理
void modern_file_operation(const std::filesystem::path& file_path) {
    std::error_code ec;  // 不会抛出异常
    
    // 使用error_code而不是errno
    auto file_size = std::filesystem::file_size(file_path, ec);
    
    if (ec) {
        // 类型安全的错误处理
        std::cout << "错误: " << ec.message() 
                  << " (代码: " << ec.value() << ")\n";
        return;
    }
    
    std::cout << "文件大小: " << file_size << " bytes\n";
}

// 自定义错误类别
class my_error_category : public std::error_category {
public:
    const char* name() const noexcept override {
        return "my_category";
    }
    
    std::string message(int ev) const override {
        switch (ev) {
            case 1: return "自定义错误1";
            case 2: return "自定义错误2";
            default: return "未知错误";
        }
    }
};

// 使用系统错误
void system_error_example() {
    try {
        // 可能抛出std::system_error
        std::filesystem::space_info info = 
            std::filesystem::space("/some/path");
    } catch (const std::system_error& e) {
        std::cout << "系统错误: " << e.what() << '\n'
                  << "错误代码: " << e.code().value() << '\n'
                  << "错误类别: " << e.code().category().name() << '\n';
    }
}

第六章：errno的调试与工具支持

6.1 调试技巧与策略

实时errno监控
#include <errno.h>
#include <stdio.h>

// 调试宏定义
#ifdef DEBUG
#define CHECK_ERRNO(operation) do { \
    errno = 0; \
    operation; \
    if (errno != 0) { \
        fprintf(stderr, "[DEBUG] %s 设置 errno=%d (%s) at %s:%d\n", \
               #operation, errno, strerror(errno), __FILE__, __LINE__); \
    } \
} while(0)
#else
#define CHECK_ERRNO(operation) operation
#endif

// 使用示例
void debug_example() {
    FILE *fp;
    CHECK_ERRNO(fp = fopen("test.txt", "r"));
    
    // 其他操作...
}
errno跟踪工具函数
#include <execinfo.h>
#include <errno.h>
#include <stdio.h>

#define MAX_STACK_DEPTH 10

void print_errno_with_backtrace(const char* context) {
    void *buffer[MAX_STACK_DEPTH];
    int size = backtrace(buffer, MAX_STACK_DEPTH);
    char **strings = backtrace_symbols(buffer, size);
    
    fprintf(stderr, "错误上下文: %s\n", context);
    fprintf(stderr, "errno=%d: %s\n", errno, strerror(errno));
    fprintf(stderr, "调用栈:\n");
    
    for (int i = 0; i < size; i++) {
        fprintf(stderr, "  %s\n", strings[i]);
    }
    
    free(strings);
}

6.2 相关工具函数详解

完整的错误处理工具集
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>

// 增强的perror版本
void perror_ex(const char *format, ...) {
    va_list args;
    va_start(args, format);
    
    // 打印自定义前缀
    vfprintf(stderr, format, args);
    va_end(args);
    
    // 打印错误描述
    fprintf(stderr, ": %s\n", strerror(errno));
}

// 错误代码到字符串的转换
const char* errno_to_string(int err_num) {
    switch (err_num) {
        case EPERM: return "操作不允许";
        case ENOENT: return "文件或目录不存在";
        case EINTR: return "系统调用被中断";
        case EIO: return "输入输出错误";
        case EBADF: return "错误的文件描述符";
        case EAGAIN: return "资源暂时不可用";
        case ENOMEM: return "内存不足";
        case EACCES: return "权限不足";
        case EFAULT: return "错误的地址";
        case EEXIST: return "文件已存在";
        case ENOTDIR: return "不是目录";
        case EISDIR: return "是目录";
        case EINVAL: return "无效参数";
        case ENFILE: return "系统打开文件数达到限制";
        case EMFILE: return "进程打开文件数达到限制";
        case ENOSPC: return "设备没有剩余空间";
        case ESPIPE: return "非法搜索";
        case EROFS: return "只读文件系统";
        case EMLINK: return "链接数过多";
        case EPIPE: return "管道破裂";
        case EDOM: return "数学参数超出定义域";
        case ERANGE: return "数学结果不可表示";
        default: return "未知错误";
    }
}

// 检查错误是否可恢复
int is_recoverable_error(int err_num) {
    switch (err_num) {
        case EINTR:    // 中断，可重试
        case EAGAIN:   // 资源暂时不可用
        case EWOULDBLOCK: // 操作将阻塞
        case ENOMEM:   // 内存不足（有时可恢复）
            return 1;
        default:
            return 0;
    }
}

6.3 性能优化建议

减少strerror调用
// 低效的做法
for (int i = 0; i < 1000; i++) {
    if (operation_failed(i)) {
        log_error(strerror(errno));  // 每次调用strerror
    }
}

// 高效的做法
for (int i = 0; i < 1000; i++) {
    if (operation_failed(i)) {
        static __thread char err_buf[256];
        int saved_errno = errno;
        
        // 只在错误消息变化时调用strerror
        if (saved_errno != last_errno) {
            strerror_r(saved_errno, err_buf, sizeof(err_buf));
            last_errno = saved_errno;
        }
        
        log_error(err_buf);
    }
}

附录：完整错误代码参考表

标准POSIX错误代码

错误代码值描述常见原因
EPERM1操作不允许权限不足
ENOENT2文件或目录不存在路径错误
ESRCH3进程不存在错误的PID
EINTR4系统调用被中断信号处理
EIO5I/O错误硬件故障
ENXIO6设备或地址不存在设备未就绪
E2BIG7参数列表过长参数太多
ENOEXEC8执行格式错误错误的二进制格式
EBADF9错误的文件号文件描述符无效
ECHILD10无子进程wait调用错误
EAGAIN11资源暂时不可用非阻塞操作
ENOMEM12内存不足内存分配失败
EACCES13权限不足文件权限错误
EFAULT14错误的地址指针错误
ENOTBLK15需要块设备设备类型错误
EBUSY16设备或资源忙资源被占用
EEXIST17文件已存在创建已存在的文件
EXDEV18跨设备链接跨文件系统硬链接
ENODEV19设备不存在设备未找到
ENOTDIR20不是目录路径组件不是目录
EISDIR21是目录对目录进行文件操作
EINVAL22无效参数函数参数错误
ENFILE23系统文件表溢出系统级文件描述符耗尽
EMFILE24进程文件表溢出进程级文件描述符耗尽
ENOTTY25不是终端对非终端进行终端操作
ETXTBSY26文本文件忙执行中的文件被写入
EFBIG27文件过大文件大小超限
ENOSPC28设备没有空间磁盘空间不足
ESPIPE29非法搜索对管道进行lseek
EROFS30只读文件系统写只读文件系统
EMLINK31链接过多文件链接数超限
EPIPE32管道破裂读端关闭的管道写入
EDOM33数学参数超出定义域数学函数域错误
ERANGE34数学结果不可表示数学函数范围错误

Linux扩展错误代码

错误代码值描述
EDEADLK35资源死锁避免
ENAMETOOLONG36文件名过长
ENOLCK37没有可用锁
ENOSYS38功能未实现
ENOTEMPTY39目录非空
ELOOP40符号链接循环
EWOULDBLOCK11操作将阻塞
ENOMSG42无期望类型的消息
EIDRM43标识符已移除
ECHRNG44通道号超出范围
EL2NSYNC45级别2未同步
EL3HLT46级别3暂停
EL3RST47级别3重置
ELNRNG48链接号超出范围
EUNATCH49协议驱动未连接

通过这份全面的errno解析，我们深入探讨了从基础概念到高级用法的所有方面。errno作为C/C++编程中错误处理的基石，理解其工作原理和最佳实践对于编写健壮、可靠的系统软件至关重要。无论您是初学者还是经验丰富的开发者，掌握errno都将显著提升您的错误处理能力和调试效率。

errno错误码含义及使用
2301_80105928的博客
12-26 4764
包含头文件#include <stdio.h>～每天进步一点点，加油！
errno详解
tissar的博客
02-27 7446
errno 详解作用相关函数多线程 作用 errno 是 error number 的缩写，意味系统调用错误码。 如果系统调用返回成功，errno 有可能但不一定会置0；而系统调用出错时，errno 必定会被设为对应的错误编号。因此，强迫症患者可以在调用系统调用之前，手动将 errno 置0。不过，如果系统调用返回成功，谁会闲着没事去看 errno 呢？ 相关函数 一般来说，我们是不是需要了解每个...
Linux errno详解
k916631305的博客
11-11 1万+
1. 错误码 / errno Linux中系统调用的错误都存储于 errno中，errno由操作系统维护，存储就近发生的错误，即下一次的错误码会覆盖掉上一次的错误。 PS: 只有当系统调用或者调用lib函数时出错，才会置位errno！ 查看系统中所有的errno所代表的含义，可以采用如下的代码： /* Function: obtain the errno string * char *strerror(int errno) */ #include <stdio.h> #inc
errno 介绍
随便写些什么
12-30 6903
errno简介 Linux中系统调用的错误都存储于errno中，errno由操作系统维护，存储就近发生的错误，即下一次的错误码会覆盖掉上一次的错误。 errno是一个包含在<errno.h>中的预定义的外部int变量，用于表示最近一个函数调用是否产生了错误。若为0，则无错误，其它值均表示一类错误。 Linux中系统调用的错误都存储于errno中，errno由操作系统维护，存储就近发生的错误，即下一次的错误码会覆盖掉上一次的错误。 编程时需要包含#include ...
错误码errno和perror函数
weixin_45897952的博客
03-15 5839
1.错误码errno 1.1作用： errno是系统中的一个错误码，当我们调用一个函数出错的时候，如果该函数出错了就会将errno赋值成为相应的错误码（整型）。一个错误码对应一个错误信息errno->error msg,但是通过这个错误码我们肯定也无法知道该错误信息，所以它一般由perror函数获取，进行打印错误信息。 2.perror函数 2.1作用： 将error msg打印出来，会直接拿errno...
【Python错误处理揭秘】：errno模块的10个使用技巧
[【Python错误处理揭秘】：errno模块的10个使用技巧](https://www.delftstack.com/img/Python/feature-image---python-oserror-errno-2-no-such-file-or-directory.webp) # 1. Python错误处理基础 在进行高效的软件...
C语言错误处理艺术：正确运用errno和strerror解码错误信息
本文全面介绍了C语言中的错误处理机制，重点阐述了errno的定义、功能、类型、取值范围以及使用注意事项，深入探讨了strerror函数的使用方法和技巧，以及与其他错误处理函数的结合方式。通过对典型C库函数以及自定义...
【C_C++库错误处理】：异常处理与错误报告机制的完善指南
![【C/C++技术教学】动态库静态库开发！...# 1. C/C++中库错误处理的重要性 在软件开发过程中，错误处理是确保代码健壮性和稳定性的重要环节。C/C++作为两大主流的...本章将探索C/C++中库错误处理的重要性，以及它如何
NAND Flash存储原理深度剖析：全面解析内部工作机制
NAND Flash存储技术是现代数据存储领域不可或缺的一部分，本文对NAND Flash的基本结构、工作原理、可靠性问题、错误处理、接口协议、驱动开发以及性能优化进行了全面的探讨。文章首先概述了NAND Flash的技术发展和...
libgpg-error：GnuPG错误代码库解析
libgpg-error 是 GNU 项目中一个关键的基础性开源库，主要用于为 GnuPG（GNU Privacy Guard）、Libgcrypt、GPGME 等一系列与密码学相关的软件提供统一的错误代码定义和错误处理机制。其核心目标是建立一套标准化、可...
errno错误码及含义(中文)
dp__mcu的专栏
07-25 1万+
https://www.cnblogs.com/pengdonglin137/p/3326460.html
Linux系统错误码errno详解
最新发布
2401_86544677的博客
11-21 2598
​在Linux系统编程中， errno是一个关键的概念 ，它是一个由操作系统维护的全局变量，专门用于存储最近发生的错误代码。这个变量通常被定义为一个整型，在头文件中声明。它的主要作用是在系统调用或库函数失败时提供详细的错误信息，帮助开发者快速定位和解决问题。 值得注意的是，errno的值可能会被后续的系统调用覆盖，因此在使用时需要及时读取和处理。这种机制使得errno成为了一个动态更新的错误记录器，能够实时反映系统中最近遇到的问题。
c语言 — errno 错误信息
weixin_46158019的博客
10-24 1669
一、错误标号errno 本质上是一个 int 类型的变量，用于存储错误编号，但是需要注意的是，并不是执行所有的系统调用或 C 库函数出错时，操作系统都会设置 errno。官方介绍：The <errno.h> header file defines the integer variable errno, which is setbysystemcallsandsome...
【Linux】Linux系统错误码errno详解
萧邯编程笔记
06-26 3722
在嵌入式Linux开发中，使用errno进行错误处理是非常常见和必要的。嵌入式系统通常需要处理各种硬件和软件的交互，错误处理和调试是确保系统稳定性和可靠性的关键部分。errno在嵌入式Linux开发中是一个重要的工具，通过合理使用errno，可以有效地捕获和处理各种错误情况，确保系统的稳定性和可靠性。在Linux系统中，errno是一个全局变量，用于表示最近一次系统调用或库函数调用出错时的错误码。每个错误码对应一个特定的错误类型。了解这些错误码有助于调试和处理错误情况。
errno --详解
热门推荐
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
01-18 2万+
写在前面： 当linux中的 api函数发生异常时,一般会将errno变量(需include errno.h)赋一个整数值,不同的值表示不同的含义,可以通过查看该值推测出错的原因，在实际编程中用这一招解决了不少原本看来莫名其妙的问题。但是errno是一个数字，代表的具体含义还要到errno.h中去阅读宏定义，而每次查阅是一件很繁琐的事情。有下面几种方法可以方便的得到错误信息 (1)void per...
C语言——错误处理机制errno
鲸落博客
09-16 1589
在 C 语言中，errno 是一个全局变量，用于存储最近发生的错误的编号。通过检查 errno 的值以及使用相关的错误处理函数（如 perror(), strerror()），可以有效地进行错误处理和调试。合理的错误处理机制能够提高程序的健壮性和用户的体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青草地溪水旁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值