std::perrorだけじゃない！C++エラー報告の代替手段を徹底比較

2025-05-27

`std::perror` とは何か

std::perror は、C++ (厳密にはC言語から継承された標準ライブラリ関数) において、最後のエラー状態に関する説明メッセージを標準エラー出力 (stderr) に出力するために使用される関数です。主にファイル操作やシステムコールなど、エラーが発生しうる操作の後にそのエラーの原因をユーザーに知らせる際に役立ちます。

使い方

std::perror は <cstdio> ヘッダ（C言語の <stdio.h> に相当）に含まれています。

基本的な書式は以下の通りです。

void std::perror(const char* s);

引数 s には、エラーメッセージの前に表示させたい文字列（プレフィックス）を指定します。この文字列の後に、コロンとスペース (:) が自動的に追加され、その後にエラーの説明が続きます。

`std::perror` が出力する内容

std::perror は、グローバル変数である errno の値に基づいてエラーメッセージを生成します。

エラー説明メッセージ: std::perror は、現在の errno の値に対応するシステム固有のエラー説明（例: "No such file or directory" や "Permission denied" など）を取得し、表示します。
errno: errno は、ほとんどの標準ライブラリ関数がエラーを報告する際に設定する整数型の変数です。エラーが発生すると、errno に特定のエラーコードが格納されます。

使用例

ファイルを開く際にエラーが発生した場合の例を見てみましょう。

#include <cstdio> // std::perror, fopen, fclose
#include <cerrno> // errno

int main() {
    FILE* file = fopen("nonexistent_file.txt", "r"); // 存在しないファイルを読み込みモードで開こうとする

    if (file == nullptr) { // ファイルが開けなかった場合
        // errno の値を確認してみる (通常は直接 errno を参照する必要はない)
        // printf("errno value: %d\n", errno);

        // std::perror を使用してエラーメッセージを出力
        std::perror("ファイルを開く際にエラーが発生");
        // 出力例: ファイルを開く際にエラーが発生: No such file or directory
    } else {
        printf("ファイルは正常に開かれました。\n");
        fclose(file);
    }

    // 存在しないファイルに書き込もうとする場合
    file = fopen("/root/restricted_file.txt", "w"); // アクセス権のないディレクトリに書き込もうとする (Linux/Unix系の場合)
    if (file == nullptr) {
        std::perror("制限されたファイルに書き込みエラー");
        // 出力例: 制限されたファイルに書き込みエラー: Permission denied
    } else {
        printf("ファイルは正常に開かれました。\n");
        fclose(file);
    }

    return 0;
}

利点

システム依存のエラー説明: OS や環境に依存する具体的なエラーメッセージが表示されるため、デバッグや問題特定に役立ちます。
簡単なエラー報告: errno の値を自分で調べて対応するエラーメッセージを構築する手間が省けます。

より詳細なエラーハンドリング: std::perror は単純なエラーメッセージの表示には便利ですが、プログラムのロジックに基づいてより複雑なエラーハンドリング（例えば、エラーの種類に応じた再試行やログ記録など）を行う場合には、strerror 関数を使って errno からエラー文字列を取得し、それを加工する方が柔軟性があります。
スレッドセーフティ: 多くの環境では errno はスレッドローカルストレージとして実装されており、スレッドセーフです。しかし、古いシステムや特殊な環境では異なる場合があるため、注意が必要です。
errno のクリア: ほとんどの標準ライブラリ関数はエラーが発生しない限り errno の値を変更しません。そのため、エラーが発生した直後に std::perror を呼び出す必要があります。別の関数呼び出しによって errno の値が上書きされてしまう可能性があるためです。

std::perror は非常に便利な関数ですが、その性質上、誤解や誤用によって期待通りの動作をしないことがあります。ここでは、よくある問題とその解決策を説明します。

perror を呼び出すタイミングが遅すぎる

これは最もよくある間違いです。std::perror はグローバル変数 errno の値に依存してエラーメッセージを生成します。errno の値は、エラーを報告する標準ライブラリ関数がエラーを検出したときに設定されます。しかし、その後に呼び出された別の関数が成功した場合でも、errno の値がリセットされたり、別のエラーコードで上書きされたりする可能性があります。

問題の例

#include <cstdio>
#include <cerrno> // errno を使うため

int main() {
    FILE* file = fopen("nonexistent_file.txt", "r"); // エラー発生 (errnoが設定される)

    // ここで何か別の関数を呼び出す (例: printf)
    printf("ファイルオープンを試行しました。\n"); // この関数が errno を変更する可能性は低いが、
                                                // 別のI/O関数やシステムコールなどが変更する可能性は十分にある

    if (file == nullptr) {
        std::perror("ファイルエラー"); // ここでは既に errno が期待する値ではないかもしれない
    }
    return 0;
}

トラブルシューティング

エラーが発生した直後に perror を呼び出すこと。 他の処理を挟まず、エラーチェックの if 文の直下で呼び出すのがベストプラクティスです。

#include <cstdio>
#include <cerrno>

int main() {
    FILE* file = fopen("nonexistent_file.txt", "r");

    if (file == nullptr) {
        std::perror("ファイルエラー"); // エラー発生直後に呼び出す
        return 1; // エラー終了
    }
    printf("ファイルは正常に開かれました。\n");
    fclose(file);
    return 0;
}

errno が設定されない関数に対して perror を使用している

すべての関数がエラー時に errno を設定するわけではありません。特に、C++ の標準ライブラリ（STLコンテナ、アルゴリズムなど）の多くは例外をスローすることでエラーを報告します。std::perror は errno の値に依存するため、errno を設定しない関数に適用しても意味がありません。

問題の例

#include <iostream>
#include <vector>
#include <cstdio> // std::perror

int main() {
    std::vector<int> v;
    try {
        v.at(10); // 範囲外アクセス。これは例外をスローする。errno は設定されない。
    } catch (const std::out_of_range& e) {
        std::cerr << "例外をキャッチ: " << e.what() << std::endl;
        std::perror("ベクトルエラー"); // ここで perror を呼び出しても意味がない (errnoは関係ない)
    }
    return 0;
}

トラブルシューティング

C++らしいエラーハンドリング（例外処理など）を用いる場合は、std::perror ではなく、例外メッセージなどを適切に処理するようにしましょう。
std::perror は、C言語由来の関数（fopen, read, write, socket など）や、errno を設定すると明示的にドキュメントに記載されているC++の関数に対してのみ使用する。

errno を明示的にリセットしていない（特にデバッグ時）

通常、errno はエラーが発生したときにのみ設定されるため、明示的に0にリセットする必要はありません。しかし、デバッグ目的で特定のエラーをシミュレートしたり、非常に厳密なエラーチェックを行いたい場合には、関数の呼び出し前に errno を0に設定することが推奨されることがあります。これは、一部の関数がエラー時にのみ errno を設定し、成功時にはその値を変更しない（つまり、以前のエラー値が残ってしまう）ことがあるためです。

問題の例

#include <cstdio>
#include <cerrno>
#include <string> // for std::string

int main() {
    // 最初に存在しないファイルを開こうとする (errnoが設定される)
    FILE* file1 = fopen("nonexistent_file_a.txt", "r");
    if (file1 == nullptr) {
        std::perror("ファイルAエラー");
    }

    // 次に、別の（成功するかもしれない）操作を行う
    // しかし、errno がリセットされていないと、前のエラー情報が残ってしまう可能性がある
    // (この例では errno が再設定される可能性が高いが、一般的な注意点として)
    FILE* file2 = fopen("existing_file.txt", "w"); // 仮に existing_file.txt が存在し、書き込みに成功すると仮定
    if (file2 == nullptr) {
        // ここに到達した場合、file2 のエラーが原因だが、
        // 意図しない古い errno の値が原因でメッセージが混乱する可能性もゼロではない
        std::perror("ファイルBエラー");
    } else {
        printf("ファイルBは正常に開かれました。\n");
        fclose(file2);
    }

    return 0;
}

トラブルシューティング

特にエラーを厳密にチェックしたい場合や、関数の戻り値だけでは不十分な場合に、関数呼び出しの直前に errno = 0; と設定することで、その関数のエラーのみを正確に捉えることができます。

#include <cstdio>
#include <cerrno>

int main() {
    errno = 0; // errno をリセット
    FILE* file = fopen("nonexistent_file.txt", "r");
    if (file == nullptr) {
        std::perror("ファイルエラー");
    } else {
        printf("ファイルは正常に開かれました。\n");
        fclose(file);
    }

    // 別の操作の前にもリセット
    errno = 0;
    FILE* another_file = fopen("another_nonexistent.txt", "r");
    if (another_file == nullptr) {
        std::perror("別のファイルエラー");
    } else {
        printf("別のファイルは正常に開かれました。\n");
        fclose(another_file);
    }
    return 0;
}

ただし、通常のアプリケーションではそこまで厳密に毎回リセットする必要はありません。エラーを返す可能性のある関数の戻り値を適切にチェックし、その直後に perror を呼び出すのが一般的です。

std::perror の出力先

std::perror はエラーメッセージを標準エラー出力 (stderr) に書き込みます。これは通常、コンソールやターミナルに表示されますが、リダイレクトされている場合はファイルなどに出力されることもあります。

問題の例

プログラムの標準出力だけをリダイレクトしていて、エラーメッセージが見えない。

トラブルシューティング

std::perror の引数（文字列 s）が nullptr または意味不明

std::perror の引数 s は const char* 型であり、NULL終端された文字列へのポインタを期待します。nullptr を渡すと未定義動作になる可能性があります。また、意味のない文字列を渡しても、エラーメッセージの意図が伝わりにくくなります。

問題の例

// NG: 未定義動作になる可能性がある
std::perror(nullptr);

// NG: 状況がわかりにくい
std::perror("エラー");

トラブルシューティング

エラーが発生した具体的な状況を示す、意味のあるプレフィックス文字列を指定してください。
```
// OK
std::perror("ファイルの読み込み中にエラー");
std::perror("ソケット接続に失敗");
```
必ず有効な文字列リテラルまたは char 配列へのポインタを渡してください。

ヘッダファイルのインクルード忘れ

std::perror は <cstdio> ヘッダに含まれています。また、errno を直接参照する場合は <cerrno> も必要です。

問題の例

// #include <cstdio> を忘れた場合
int main() {
    FILE* file = fopen("nonexistent.txt", "r");
    if (file == nullptr) {
        perror("ファイルオープンエラー"); // コンパイルエラー: 'perror' が宣言されていません
    }
    return 0;
}

トラブルシューティング

errno を直接利用する場合は、#include <cerrno> も追加してください。
std::perror を使用するファイルには、必ず #include <cstdio> を追加してください。

std::perror は、主にC標準ライブラリ（C++では <cstdio> や <cstdlib> などに相当）の関数が返すエラーを報告するために使われます。errno グローバル変数に格納されたエラーコードに基づいて、システムが理解しやすいメッセージを標準エラー出力に表示します。

例1：ファイル操作のエラーハンドリング

最も一般的な使用例は、ファイルを開く際にエラーが発生した場合です。

#include <iostream> // std::cout, std::cerr
#include <cstdio>   // std::fopen, std::fclose, std::perror
#include <string>   // std::string
#include <cerrno>   // errno (errnoの値を直接見たい場合に便利)

int main() {
    // ----------------------------------------------------
    // 1. 存在しないファイルを読み込みモードで開こうとする
    // ----------------------------------------------------
    const std::string nonExistentFile = "nonexistent_file.txt";
    FILE* file1 = std::fopen(nonExistentFile.c_str(), "r");

    if (file1 == nullptr) { // fopen が失敗した場合、nullptr を返す
        std::cerr << "エラー発生！ファイル名: " << nonExistentFile << std::endl;
        // エラー発生直後に std::perror を呼び出す
        // 引数には、エラーメッセージの前に表示させたい文字列を指定する
        std::perror("ファイルオープン失敗");
        // この時点で errno の値を確認することもできる (通常は perror がやってくれる)
        // std::cerr << "errno の値: " << errno << std::endl;
    } else {
        std::cout << "ファイル '" << nonExistentFile << "' は正常に開かれました。" << std::endl;
        std::fclose(file1);
    }

    std::cout << "----------------------------------------" << std::endl;

    // ----------------------------------------------------
    // 2. 権限のない場所に書き込もうとする (Linux/Unix系の場合)
    //    Windowsでは、管理者権限がないとシステムディレクトリに書き込めない場合など
    // ----------------------------------------------------
    const std::string restrictedPath = "/root/new_file.txt"; // 通常ユーザーは /root に書き込めない
    // errno を確実にその操作のエラーにしたい場合、事前にリセットする
    errno = 0; 
    FILE* file2 = std::fopen(restrictedPath.c_str(), "w");

    if (file2 == nullptr) {
        std::cerr << "エラー発生！パス: " << restrictedPath << std::endl;
        std::perror("ファイル書き込み失敗 (権限問題の可能性)");
        // std::cerr << "errno の値: " << errno << std::endl; // Permission denied などに対応する値
    } else {
        std::cout << "ファイル '" << restrictedPath << "' は正常に開かれました。" << std::endl;
        std::fclose(file2);
    }

    std::cout << "----------------------------------------" << std::endl;

    // ----------------------------------------------------
    // 3. 正常にファイルを開く例
    // ----------------------------------------------------
    const std::string existingFile = "example.txt";
    // テスト用にファイルを作成
    FILE* tempFile = std::fopen(existingFile.c_str(), "w");
    if (tempFile != nullptr) {
        std::fprintf(tempFile, "これはテストファイルです。\n");
        std::fclose(tempFile);
    } else {
        // ここでエラーが出たら、テストファイルの作成自体に問題がある
        std::perror("テストファイル作成失敗");
        return 1;
    }

    FILE* file3 = std::fopen(existingFile.c_str(), "r");
    if (file3 == nullptr) {
        // ここには通常到達しないはず
        std::perror("既存ファイルのオープン失敗 (予期せぬエラー)");
    } else {
        std::cout << "ファイル '" << existingFile << "' は正常に開かれました。" << std::endl;
        std::fclose(file3);
    }

    // テストファイルを削除 (オプション)
    std::remove(existingFile.c_str());

    return 0;
}

この例の出力（環境によってメッセージは異なります）

エラー発生！ファイル名: nonexistent_file.txt
ファイルオープン失敗: No such file or directory
----------------------------------------
エラー発生！パス: /root/new_file.txt
ファイル書き込み失敗 (権限問題の可能性): Permission denied
----------------------------------------
ファイル 'example.txt' は正常に開かれました。

解説

errno = 0; は、特定の操作のエラーを厳密にチェックしたい場合に、その操作の前に errno をリセットするために使われることがあります。これにより、以前の操作で設定された errno の値が誤って読み取られるのを防ぎます。
std::perror は、"ファイルオープン失敗: " の後に、errno の値に対応するシステム固有のエラーメッセージ（例: No such file or directory や Permission denied）を自動的に追加して出力します。
if (file1 == nullptr) の条件でエラーを検出し、その直後に std::perror("..."); を呼び出しています。
fopen はファイル操作のC言語標準ライブラリ関数です。ファイルを開くのに失敗すると nullptr を返します。

例2：ネットワークソケットのエラーハンドリング (擬似コード)

ネットワークプログラミングでも std::perror は非常に役立ちます。ただし、ソケットAPIはプラットフォームに依存するため、ここでは概念的な擬似コードで示します。実際には、適切なヘッダ（Linux/Unixなら <sys/socket.h>, Windowsなら <winsock2.h> など）とリンクが必要です。

#include <iostream>
#include <cstdio> // std::perror
#include <string>

// 実際のソケット関数はプラットフォーム依存なので、ここでは仮の関数を定義
// 実際のソケット関数は戻り値でエラーを示すことが多い
// 例: socket() -> -1 on error, connect() -> -1 on error
// Windowsの場合は WSAGetLastError() を使うことが一般的
// Linux/Unixでは errno を使う

// 仮のソケット作成関数
int create_socket_mock(bool succeed) {
    if (succeed) {
        // 成功をシミュレート
        return 100; // 有効なソケットディスクリプタのつもり
    } else {
        // 失敗をシミュレートし、errno を設定
        errno = EAFNOSUPPORT; // 例: アドレスファミリーがサポートされていないエラーコード
        return -1;
    }
}

// 仮の接続関数
int connect_socket_mock(int socket_fd, bool succeed) {
    if (succeed) {
        // 成功をシミュレート
        return 0;
    } else {
        // 失敗をシミュレートし、errno を設定
        // 例えば、ECONNREFUSED (接続拒否) や ETIMEDOUT (タイムアウト) など
        errno = ECONNREFUSED; 
        return -1;
    }
}

int main() {
    std::cout << "--- ソケット作成テスト ---" << std::endl;
    int client_socket = create_socket_mock(false); // 失敗をシミュレート

    if (client_socket == -1) {
        std::perror("ソケット作成エラー");
        // ソケット作成に失敗したら、それ以上進めない
        return 1;
    }
    std::cout << "ソケット作成成功。FD: " << client_socket << std::endl;

    std::cout << "--- 接続テスト ---" << std::endl;
    // 実際に接続を試みる前に errno をリセットする
    errno = 0; 
    int connect_result = connect_socket_mock(client_socket, false); // 接続失敗をシミュレート

    if (connect_result == -1) {
        std::perror("接続エラー");
    } else {
        std::cout << "接続成功。" << std::endl;
    }

    // 実際のソケットでは close() や closesocket() を呼び出す
    // close(client_socket); // 仮
    
    return 0;
}

この例の出力（環境によってメッセージは異なります）

--- ソケット作成テスト ---
ソケット作成エラー: Address family not supported by protocol

（ECONNREFUSED は、create_socket_mock が失敗したため connect_socket_mock は呼ばれず、表示されない）

ネットワークプログラミングでは、errno の値が非常に多様であり、perror を使うことで、具体的なエラー原因（例: Connection refused, Host unreachable など）を把握しやすくなります。
このような関数に対しても、std::perror は非常に効果的なエラー報告手段となります。
多くのシステムコール（socket, connect, read, write など）は、エラーが発生すると -1 を返し、同時に errno を設定します。

std::perror はC言語由来のシンプルなエラー報告メカニズムですが、C++ではより強力で柔軟なエラーハンドリングの選択肢が提供されています。主な代替方法としては、std::strerror の使用、例外処理、そしてロギングライブラリの利用が挙げられます。

std::strerror の利用

std::strerror は、errno の値に対応するエラーメッセージ文字列を返す関数です。std::perror とは異なり、メッセージを直接出力するのではなく、文字列として提供するため、その文字列をプログラム内で自由に加工したり、別の出力ストリームに書き込んだりすることができます。

特徴

メッセージのカスタマイズ
独自のエラーメッセージに組み込んだり、国際化対応（I18n）のために文字列を操作したりできます。
柔軟な出力
標準エラー出力だけでなく、ログファイルやGUI、ネットワーク経由など、任意の場所に出力できます。

使用例

#include <iostream> // std::cout, std::cerr
#include <cstdio>   // std::fopen, std::fclose
#include <cstring>  // std::strerror
#include <cerrno>   // errno
#include <string>   // std::string

int main() {
    const std::string filename = "nonexistent_file_strerror.txt";
    FILE* file = std::fopen(filename.c_str(), "r");

    if (file == nullptr) {
        // errno の現在の値に対応するエラーメッセージを取得
        // strerror の戻り値は const char* であり、内部的に静的なバッファを指すことが多い
        // そのため、すぐに使用するか、別のバッファにコピーする必要がある
        const char* error_message = std::strerror(errno); 

        // 独自の形式でエラーメッセージを出力
        std::cerr << "エラー！ファイル '" << filename << "' を開けませんでした: " 
                  << error_message << " (errno: " << errno << ")" << std::endl;
        
        // 例: ログファイルに書き込む場合 (擬似コード)
        // log_to_file("ファイルオープンエラー: " + std::string(error_message));

        return 1;
    } else {
        std::cout << "ファイル '" << filename << "' は正常に開かれました。" << std::endl;
        std::fclose(file);
    }
    return 0;
}

利点

エラーメッセージをログシステムに統合したり、ユーザーインターフェースに表示したりする際に便利です。
出力の制御が完全にプログラマに委ねられるため、非常に柔軟なエラー報告が可能です。

注意点

strerror が返す文字列は、その後の strerror 呼び出しや他のライブラリ関数の呼び出しによって上書きされる可能性があるため、すぐに使用するかコピーする必要があります。
strerror の戻り値は、スレッドセーフではない可能性があります（C++11以降では strerror_s や strerror_r といったスレッドセーフ版が推奨される）。

例外処理 (Exceptions)

C++では、エラーハンドリングの主要なメカニズムとして例外処理が推奨されます。特に、リカバリ可能なエラーや、プログラムの正常な実行フローを中断するようなエラーに適しています。

特徴

リソース管理の容易さ (RAII)
例外がスローされても、RAII（Resource Acquisition Is Initialization）パターンを用いることで、リソースの解放が保証されます。
エラータイプの明確化
特定のエラー状況を表す独自の例外クラスを定義できます。
エラー伝播の自動化
関数呼び出しスタックを遡ってエラーを伝播させるため、エラーチェックコードが散乱するのを防ぎます。

使用例

#include <iostream>
#include <string>
#include <stdexcept> // std::runtime_error, std::system_error (C++11以降)
#include <cstdio>    // fopen, fclose
#include <cerrno>    // errno
#include <cstring>   // strerror

// C++11以降では std::system_error が推奨される
// std::system_error はエラーコードとカテゴリを持つ
// 古いC++やerrnoを直接扱う場合は std::runtime_error などを使うことも
class FileOpenError : public std::runtime_error {
public:
    FileOpenError(const std::string& filename, int error_code)
        : std::runtime_error("ファイルオープンエラー: '" + filename + "' - " + 
                             std::strerror(error_code)),
          filename_(filename),
          error_code_(error_code) {}

    const std::string& getFilename() const { return filename_; }
    int getErrorCode() const { return error_code_; }

private:
    std::string filename_;
    int error_code_;
};

// ファイルを開く関数
FILE* open_file(const std::string& filename, const std::string& mode) {
    FILE* file = std::fopen(filename.c_str(), mode.c_str());
    if (file == nullptr) {
        // エラーが発生した場合、例外をスロー
        throw FileOpenError(filename, errno);
    }
    return file;
}

int main() {
    try {
        // 存在しないファイルを開こうとする
        FILE* my_file = open_file("nonexistent_file_exception.txt", "r");
        std::cout << "ファイルは正常に開かれました。" << std::endl;
        std::fclose(my_file);
    } catch (const FileOpenError& e) {
        // 独自のエラークラスでキャッチ
        std::cerr << "Caught custom FileOpenError: " << e.what() 
                  << " (Filename: " << e.getFilename() 
                  << ", Code: " << e.getErrorCode() << ")" << std::endl;
    } catch (const std::exception& e) {
        // その他の標準例外をキャッチ
        std::cerr << "Caught std::exception: " << e.what() << std::endl;
    }

    // C++11以降の std::system_error を使う例
    try {
        // errno が設定されるC関数をラップ
        // make_error_code は <system_error> で定義
        std::error_code ec; 
        FILE* test_file = std::fopen("/root/test_file.txt", "w"); // 権限エラーを想定
        if (test_file == nullptr) {
            ec = std::error_code(errno, std::generic_category());
            throw std::system_error(ec, "ファイル書き込みエラー");
        }
        std::fclose(test_file);
    } catch (const std::system_error& e) {
        std::cerr << "Caught std::system_error: " << e.what()
                  << " (Code: " << e.code().value() 
                  << ", Category: " << e.code().category().name() << ")" << std::endl;
    }

    return 0;
}

利点

RAIIと組み合わせることで、リソースリークを防ぎやすくなります。
異なるエラータイプを型で区別し、適切なハンドラで処理できます。
エラー処理ロジックが、通常の実行フローから分離され、コードの可読性が向上します。

注意点

C言語のライブラリ関数は例外をスローしないため、それらのエラーを例外に変換する「ラッパー」関数が必要です。
例外の乱用はパフォーマンスの低下やコードの複雑化を招く可能性があります。

ロギングライブラリの利用

大規模なアプリケーションでは、std::perror のような直接的な出力ではなく、専用のロギングライブラリを使用するのが一般的です。ロギングライブラリは、エラーメッセージにタイムスタンプ、ログレベル（INFO, WARNING, ERRORなど）、ソースファイル名、行番号などの付加情報を自動的に追加し、さまざまな出力先（コンソール、ファイル、ネットワーク、データベースなど）に柔軟に出力できます。

代表的なロギングライブラリ

Boost.Log (Boostライブラリの一部)
spdlog (高速で使いやすいモダンなC++ロギングライブラリ)
Log4cpp (Apache Log4jのC++ポート)

使用例 (spdlog の概念的な使用例)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cerrno>
#include <string>
#include <memory> // for std::shared_ptr

// spdlogのヘッダをインクルード (インストールが必要)
// #include "spdlog/spdlog.h"
// #include "spdlog/sinks/stdout_color_sinks.h" // コンソール出力用

int main() {
    // spdlog の初期化 (実際のコードではもっと複雑)
    // auto console = spdlog::stdout_color_mt("console");
    // console->set_level(spdlog::level::info); // INFOレベル以上のログを出力

    const std::string filename = "nonexistent_file_logging.txt";
    FILE* file = std::fopen(filename.c_str(), "r");

    if (file == nullptr) {
        const char* error_message = std::strerror(errno);
        // ロギングライブラリを使ってエラーを記録
        // console->error("ファイル '{}' を開けませんでした: {} (errno: {})", 
        //                filename, error_message, errno);
        
        // spdlogがない場合の代替出力
        std::cerr << "ERROR: ファイル '" << filename << "' を開けませんでした: " 
                  << error_message << " (errno: " << errno << ")" << std::endl;

        return 1;
    } else {
        // console->info("ファイル '{}' は正常に開かれました。", filename);
        std::cout << "INFO: ファイル '" << filename << "' は正常に開かれました。" << std::endl;
        std::fclose(file);
    }
    return 0;
}

利点

ログレベルによるフィルタリング
デバッグ情報から重大なエラーまで、ログの重要度に応じて出力を制御できます。
柔軟な出力先
コンソール、ファイル、データベース、ネットワークなど、要件に応じて出力先を変更できます。
集中管理
アプリケーション全体のエラーログを一元的に管理できます。
構造化されたログ
タイムスタンプ、ログレベル、モジュール名などの付加情報が含まれ、ログの解析が容易になります。

注意点

シンプルなスクリプトや小規模なツールではオーバーキルになることがあります。
外部ライブラリの追加と学習コストが発生します。

std::perror は、C言語スタイルの簡単なエラー報告には十分ですが、C++の現代的な開発では、以下のような代替方法が推奨されます。

大規模アプリケーションでの堅牢なエラー管理と監視に
専用のロギングライブラリ。
プログラムの実行フローを中断するリカバリ可能なエラーに
例外処理 (特に std::system_error やカスタム例外)。
簡単なエラー報告やC APIのエラーに
std::strerror を使ってメッセージをカスタマイズし、std::cerr に出力。

std::perrorだけじゃない！C++エラー報告の代替手段を徹底比較

std::perror とは何か

使い方

std::perror が出力する内容

使用例

perror を呼び出すタイミングが遅すぎる

errno が設定されない関数に対して perror を使用している

errno を明示的にリセットしていない（特にデバッグ時）

std::perror の出力先

std::perror の引数（文字列 s）が nullptr または意味不明

ヘッダファイルのインクルード忘れ

例1：ファイル操作のエラーハンドリング

例2：ネットワークソケットのエラーハンドリング (擬似コード)

std::strerror の利用

例外処理 (Exceptions)

ロギングライブラリの利用

`std::perror` とは何か

`std::perror` が出力する内容