C언어에서 커스텀 에러 코드와 에러 메시지 정의하는 방법

typedef enum {
    SUCCESS = 0,          // 성공
    FILE_NOT_FOUND = 1001, // 파일을 찾을 수 없음
    INVALID_INPUT = 1002,  // 잘못된 입력
    MEMORY_ALLOCATION_FAIL = 1003 // 메모리 할당 실패
} ErrorCode;

#define SUCCESS 0                  // 성공
#define FILE_NOT_FOUND 1001        // 파일을 찾을 수 없음
#define INVALID_INPUT 1002         // 잘못된 입력
#define MEMORY_ALLOCATION_FAIL 1003 // 메모리 할당 실패

typedef enum {
    FILE_ERROR_BASE = 1000,
    FILE_NOT_FOUND = FILE_ERROR_BASE + 1,
    FILE_READ_ERROR = FILE_ERROR_BASE + 2,

    NETWORK_ERROR_BASE = 2000,
    NETWORK_TIMEOUT = NETWORK_ERROR_BASE + 1,
    NETWORK_DISCONNECTED = NETWORK_ERROR_BASE + 2
} ErrorCode;

const char *errorMessages[] = {
    "Success",                           // SUCCESS
    "File not found",                    // FILE_NOT_FOUND
    "Invalid input",                     // INVALID_INPUT
    "Memory allocation failed"           // MEMORY_ALLOCATION_FAIL
};

const char* getErrorMessage(ErrorCode code) {
    switch (code) {
        case SUCCESS: 
            return "Success";
        case FILE_NOT_FOUND: 
            return "File not found";
        case INVALID_INPUT: 
            return "Invalid input";
        case MEMORY_ALLOCATION_FAIL: 
            return "Memory allocation failed";
        default: 
            return "Unknown error";
    }
}

#define SUCCESS_MESSAGE "Success"
#define FILE_NOT_FOUND_MESSAGE "File not found"
#define INVALID_INPUT_MESSAGE "Invalid input"
#define MEMORY_ALLOCATION_FAIL_MESSAGE "Memory allocation failed"

#include "errors.h"

const char* getErrorMessage(ErrorCode code) {
    switch (code) {
        case SUCCESS: 
            return SUCCESS_MESSAGE;
        case FILE_NOT_FOUND: 
            return FILE_NOT_FOUND_MESSAGE;
        case INVALID_INPUT: 
            return INVALID_INPUT_MESSAGE;
        case MEMORY_ALLOCATION_FAIL: 
            return MEMORY_ALLOCATION_FAIL_MESSAGE;
        default: 
            return "Unknown error";
    }
}

#include <stdio.h>

typedef enum {
    SUCCESS = 0,
    FILE_NOT_FOUND = 1001,
    INVALID_INPUT = 1002,
    MEMORY_ALLOCATION_FAIL = 1003
} ErrorCode;

const char* getErrorMessage(ErrorCode code) {
    switch (code) {
        case SUCCESS: 
            return "Success";
        case FILE_NOT_FOUND: 
            return "File not found";
        case INVALID_INPUT: 
            return "Invalid input";
        case MEMORY_ALLOCATION_FAIL: 
            return "Memory allocation failed";
        default: 
            return "Unknown error";
    }
}

void handleError(ErrorCode code) {
    const char* message = getErrorMessage(code);
    // 콘솔에 에러 메시지 출력
    fprintf(stderr, "Error [%d]: %s\n", code, message);

    // 에러 로그 파일에 기록
    FILE* logFile = fopen("error_log.txt", "a");
    if (logFile) {
        fprintf(logFile, "Error [%d]: %s\n", code, message);
        fclose(logFile);
    }
}

#include <stdlib.h>

void handleFatalError(ErrorCode code) {
    const char* message = getErrorMessage(code);
    fprintf(stderr, "Fatal Error [%d]: %s\n", code, message);

    // 프로그램 종료
    exit(EXIT_FAILURE);
}

void processError(ErrorCode code, int isFatal) {
    if (isFatal) {
        handleFatalError(code);
    } else {
        handleError(code);
    }
}

int main() {
    // 예제: 파일 열기 시 에러 처리
    FILE* file = fopen("nonexistent.txt", "r");
    if (!file) {
        processError(FILE_NOT_FOUND, 0); // 치명적이지 않은 에러 처리
    }

    // 심각한 에러 시
    processError(MEMORY_ALLOCATION_FAIL, 1); // 치명적 에러로 종료
    return 0;
}

typedef enum {
    SUCCESS = 0,
    FILE_NOT_FOUND = 1001,
    FILE_READ_ERROR = 1002,
    FILE_WRITE_ERROR = 1003,
    FILE_PERMISSION_DENIED = 1004
} FileErrorCode;

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

FileErrorCode readFile(const char* fileName) {
    FILE* file = fopen(fileName, "r");
    if (!file) {
        if (errno == ENOENT) {
            return FILE_NOT_FOUND;
        } else if (errno == EACCES) {
            return FILE_PERMISSION_DENIED;
        } else {
            return FILE_READ_ERROR;
        }
    }

    // 파일 읽기 작업 (간단한 예제)
    char buffer[256];
    if (fgets(buffer, sizeof(buffer), file) == NULL) {
        fclose(file);
        return FILE_READ_ERROR;
    }

    printf("File Content: %s\n", buffer);
    fclose(file);
    return SUCCESS;
}

void handleFileError(FileErrorCode code) {
    switch (code) {
        case FILE_NOT_FOUND:
            fprintf(stderr, "Error: File not found.\n");
            break;
        case FILE_PERMISSION_DENIED:
            fprintf(stderr, "Error: Permission denied.\n");
            break;
        case FILE_READ_ERROR:
            fprintf(stderr, "Error: Unable to read file.\n");
            break;
        case FILE_WRITE_ERROR:
            fprintf(stderr, "Error: Unable to write to file.\n");
            break;
        default:
            fprintf(stderr, "Error: Unknown file error.\n");
            break;
    }
}

int main() {
    const char* fileName = "example.txt";

    FileErrorCode result = readFile(fileName);
    if (result != SUCCESS) {
        handleFileError(result);
        return result;
    }

    printf("File read successfully.\n");
    return SUCCESS;
}

typedef enum {
    SUCCESS = 0,
    FILE_NOT_FOUND = 1001,
    INVALID_FILE_CONTENT = 1002,
    FILE_READ_ERROR = 1003
} CustomErrorCode;

const char* getCustomErrorMessage(CustomErrorCode code) {
    switch (code) {
        case SUCCESS:
            return "Success";
        case FILE_NOT_FOUND:
            return "Error: File not found.";
        case INVALID_FILE_CONTENT:
            return "Error: Invalid content in file.";
        case FILE_READ_ERROR:
            return "Error: Unable to read file.";
        default:
            return "Error: Unknown error.";
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

CustomErrorCode sumNumbersFromFile(const char* fileName, int* sum) {
    FILE* file = fopen(fileName, "r");
    if (!file) {
        return FILE_NOT_FOUND;
    }

    *sum = 0;
    char buffer[256];
    while (fgets(buffer, sizeof(buffer), file)) {
        char* endPtr;
        int number = strtol(buffer, &endPtr, 10);
        if (*endPtr != '\n' && *endPtr != '\0') {
            fclose(file);
            return INVALID_FILE_CONTENT;
        }
        *sum += number;
    }

    if (ferror(file)) {
        fclose(file);
        return FILE_READ_ERROR;
    }

    fclose(file);
    return SUCCESS;
}

int main() {
    const char* fileName = "numbers.txt";
    int sum;

    CustomErrorCode result = sumNumbersFromFile(fileName, &sum);
    if (result != SUCCESS) {
        printf("%s\n", getCustomErrorMessage(result));
        return result;
    }

    printf("The sum of numbers in the file is: %d\n", sum);
    return SUCCESS;
}