我一直在研究和尝试 C++ 中各种错误处理范例。

我对强大的错误处理机制的目标是：

• 强制处理错误情况（换句话说，使不处理错误情况变得更加困难）。
  
  • 即，不要result.value()->do_stuff()在没有适当检查的情况下让诸如此类的事情发生，而这些检查*result.value()实际上是存在并且有效的。（我对诸如此类的事情的看法是std::expected，没有什么可以真正阻止你不打电话result.has_value()，而是直接继续result.value()）
  • 关于异常，没有什么可以阻止你不写try和catch。另外，如果不深入研究库的源代码，你根本不知道会引发什么异常。
    
    • 也许 Java 对于检查异常一直以来都是正确的！
  • 我个人喜欢 golang 风格的result, err != nil; if err != nil {...}。虽然与 golang 不同，C++ 并不强制使用变量（在 golang 中，如果你忘记处理err，就会收到编译器错误）。我想你可以打开-Wunused-variable并将警告视为错误。不过，C++ 实际上没有多个返回值，因此你可以将结果打包到单个变量中并跳过处理错误。
• 尝试尽可能地利用编译器，而不是相信一切在运行时能够正确进行。
• 接受用户/客户端错误情况是程序的有效状态，并将其编码到程序中，而不是试图将它们埋在地毯下或将其视为脚注
• 能够通用支持复杂的错误数据类型，支持丰富、定制化的错误数据采集和输出。

目前我仅限于 C++17，因此我将在本演示中使用它。下面是Result我为支持上述范例而提出的一个类：

namespace util {
template<typename Data, typename Error>
class Result {
public:
    Result(Data&& data) : _result(std::move(data)) {}
    Result(Error&& error) : _result(std::move(error)) {}

    using DataFunction = std::function<void(Data&&)>;
    using ErrorFunction = std::function<void(Error&&)>;
    [[nodiscard]] bool handle(DataFunction&& data_func, ErrorFunction&& error_func) {
        if (std::holds_alternative<Error>(_result)) {
            error_func(std::move(std::get<Error>(_result)));
            return false;
        }

        data_func(std::move(std::get<Data>(_result)));
        return true;
    }

private:
    std::variant<Data, Error> _result;
};
}

它本质上是一个包装器std::variant。

您将调用handle()并提供两个 lambda 函数来“解包”变体，以便真正获取真实数据（或错误）。在data_func和 中error_func，您将分别处理Data和Error案例。

handle返回一个布尔值，如果返回了错误状态，则为 false（使用[[nodiscard]]来阻止忽略布尔值）。布尔值的目的是允许编写早期返回逻辑（因为您无法在 内部执行此操作error_func）。

为了测试本Result课程的实用性，我制作了一个小型示例程序，用于解析“假”配置文件格式。该格式只是一堆key=value由换行符分隔的对。我将使用其中的片段进行解释。

Result以下是类用法的一个示例：

    static util::Result<FakeConfig, InitError> init(const std::string& filename) {
        using Reason = InitError::Reason;

        std::ifstream file(filename);
        if (!file.is_open()) {
            return InitError(Reason::INVALID_FILE);
        }

        std::unordered_map<std::string, std::string> dictionary;

        int line_num = 1;
        std::string line;
        while (std::getline(file, line)) {
            if (line.size() > 0) {
                std::string key, value;
                std::unique_ptr<InitError> error;

                if (!split(line, "=").handle(
                    [&key, &value](std::pair<std::string, std::string>&& tokens) {
                        std::tie(key, value) = tokens;
                    },
                    [](SplitError&& split_error) { }
                )) {
                    return InitError::from_line(filename, line_num, Reason::SYNTAX_ERROR);
                }

                if (dictionary.find(key) != dictionary.end()) {
                    return InitError::from_line(filename, line_num, Reason::KEY_ALREADY_DEFINED);
                }
                dictionary[key] = value;
            }

            ++line_num;
        }

        return FakeConfig(std::move(dictionary));
    }

由于Result定义Result(Data&&)和Result(Error&&)构造函数，我们可以直接返回我们想要的任何类型（对象FakeConfig或InitError在本例中）。

以下是调用者如何使用返回类型的函数的示例Result：

    std::unique_ptr<FakeConfig> config;
    if (!FakeConfig::init(filename).handle(
        [&config] (FakeConfig&& fc) { config = std::make_unique<FakeConfig>(std::move(fc)); },
        [&filename] (FakeConfig::InitError&& error) {
            std::cerr << "Error initializing from file: " << filename << std::endl;

            using Reason = FakeConfig::InitError::Reason;
            switch (error.reason) {
                case Reason::INVALID_FILE: {
                    std::cerr << "Invalid file" << std::endl;
                    break;
                }
                case Reason::SYNTAX_ERROR: {
                    std::cerr << "Syntax error on line " << error.line_num << std::endl;
                    std::cerr << "\t\t" << error.line << std::endl;
                    break;
                }
                case Reason::KEY_ALREADY_DEFINED: {
                    std::cerr << "Key already defined on line " << error.line_num << std::endl;
                    std::cerr << "\t\t" << error.line << std::endl;
                    break;
                }
            }
        }
    )) {
        // early return logic
        return -1;
    }
    
    // continue main program logic with *config ...

我们必须handle()返回类型FakeConfig::init()。我们通过提供data_func成功案例（这里，我们将FakeConfig返回类型移到指针中config）和提供error_func（这里我们只是根据InitError返回类型的内容打印出实际的错误消息）来实现这一点。

如果handle()为假，那么我们就提前返回。否则，我们可以继续*config。

这是完整代码。使用g++macOS-std=c++17进行编译。

#include <cctype>
#include <fstream>
#include <functional>
#include <iostream>
#include <string>
#include <unordered_map>
#include <variant>

namespace util {
template<typename Data, typename Error>
class Result {
public:
    Result(Data&& data) : _result(std::move(data)) {}
    Result(Error&& error) : _result(std::move(error)) {}

    using DataFunction = std::function<void(Data&&)>;
    using ErrorFunction = std::function<void(Error&&)>;
    [[nodiscard]] bool handle(DataFunction&& data_func, ErrorFunction&& error_func) {
        if (std::holds_alternative<Error>(_result)) {
            error_func(std::move(std::get<Error>(_result)));
            return false;
        }

        data_func(std::move(std::get<Data>(_result)));
        return true;
    }

private:
    std::variant<Data, Error> _result;
};
}

//
// simple example to demonstrate use case:
// parse a text file containing "key=value" pairs, newline separated.
//
// the file could look like the below:
//
//          dog=max
//          cat=tom
//          tiger=tigger
//          donkey=eeyore
//
// this is less trivial than something like division (and checking division by zero or not)
// but otherwise a fairly easy example to understand for demonstrating the Result class
//
namespace {
std::string fetch_line(const std::string& filename, int line_num) {
    std::ifstream file(filename);

    int l = 1;
    std::string line;
    while (std::getline(file, line)) {
        if (l == line_num) {
            return line;
        }
        ++l;
    }
    return "";
}

struct SplitError {};
util::Result<std::pair<std::string, std::string>, SplitError> split(
        const std::string& str,
        const std::string& delim
) {
    size_t delim_location = str.find(delim);
    if (delim_location == std::string::npos) {
        return SplitError();
    }
    std::string key = str.substr(0, delim_location);
    std::string value = str.substr(delim_location + delim.size());
    if (key.size() == 0 || value.size() == 0) {
        return SplitError();
    }

    return std::make_pair(key, value);
}

bool is_all_alphanum(const std::string& str, size_t start) {
    if (start >= str.size()) return false;

    for (size_t i = start; i < str.size(); ++i) {
        if (!std::isalnum(str[i])) {
            return false;
        }
    }

    return true;
}
}

class FakeConfig {
public:
    FakeConfig(FakeConfig&&) = default;

    struct InitError {
        enum class Reason {
            INVALID_FILE,
            SYNTAX_ERROR,
            KEY_ALREADY_DEFINED // disallow re-assignment of keys
        } reason;
        int line_num;
        std::string line;

        InitError(InitError&&) = default;
        InitError(InitError::Reason r) : reason(r) {}

        static InitError from_line(const std::string& filename, int line_num, Reason reason) {
            std::string line = fetch_line(filename, line_num);
            InitError error(reason);
            error.line_num = line_num;
            error.line = line;
            return error;
        }
    };

    static util::Result<FakeConfig, InitError> init(const std::string& filename) {
        using Reason = InitError::Reason;

        std::ifstream file(filename);
        if (!file.is_open()) {
            return InitError(Reason::INVALID_FILE);
        }

        std::unordered_map<std::string, std::string> dictionary;

        int line_num = 1;
        std::string line;
        while (std::getline(file, line)) {
            if (line.size() > 0) {
                std::string key, value;
                std::unique_ptr<InitError> error;

                if (!split(line, "=").handle(
                    [&key, &value](std::pair<std::string, std::string>&& tokens) {
                        std::tie(key, value) = tokens;
                    },
                    [](SplitError&& split_error) { }
                )) {
                    return InitError::from_line(filename, line_num, Reason::SYNTAX_ERROR);
                }

                if (dictionary.find(key) != dictionary.end()) {
                    return InitError::from_line(filename, line_num, Reason::KEY_ALREADY_DEFINED);
                }
                dictionary[key] = value;
            }

            ++line_num;
        }

        return FakeConfig(std::move(dictionary));
    }

    struct GetError {
        enum class Reason {
            ILLEGAL_KEY,
            KEY_NOT_FOUND,
        } reason;

        std::string key;

        GetError(Reason r, const std::string& k) : reason(r), key(k) {}
    };

    util::Result<std::string, GetError> get(const std::string& key) {
        using Reason = GetError::Reason;

        bool is_legal_key = key.size() >= 1
            && std::isalpha(key[0])
            && is_all_alphanum(key, 1)
            ;
        if (!is_legal_key) {
            return GetError(Reason::ILLEGAL_KEY, key);
        }

        if (_values.find(key) == _values.end()) {
            return GetError(Reason::KEY_NOT_FOUND, key);
        }
        return std::string(_values[key]);
    }

private:
    FakeConfig(std::unordered_map<std::string, std::string>&& values) : _values(values) {}
    std::unordered_map<std::string, std::string> _values;
};


int main(int argc, char** argv) {
    if (argc < 2) {
        std::cerr << "usage: ./parser filename" << std::endl;
        return -1;
    }
    std::string filename = argv[1];

    std::unique_ptr<FakeConfig> config;
    if (!FakeConfig::init(filename).handle(
        [&config] (FakeConfig&& fc) { config = std::make_unique<FakeConfig>(std::move(fc)); },
        [&filename] (FakeConfig::InitError&& error) {
            std::cerr << "Error initializing from file: " << filename << std::endl;

            using Reason = FakeConfig::InitError::Reason;
            switch (error.reason) {
                case Reason::INVALID_FILE: {
                    std::cerr << "Invalid file" << std::endl;
                    break;
                }
                case Reason::SYNTAX_ERROR: {
                    std::cerr << "Syntax error on line " << error.line_num << std::endl;
                    std::cerr << "\t\t" << error.line << std::endl;
                    break;
                }
                case Reason::KEY_ALREADY_DEFINED: {
                    std::cerr << "Key already defined on line " << error.line_num << std::endl;
                    std::cerr << "\t\t" << error.line << std::endl;
                    break;
                }
            }
        }
    )) {
        return -1;
    }

    std::string input;
    do {
        std::cout << "Enter a key (or ctrl-C to quit): ";
        std::cin >> input;

        std::cout << "\t";
        if (!config->get(input).handle(
            [&input] (std::string&& value) { std::cout << input << " -> " << value << std::endl; },
            [&input] (FakeConfig::GetError&& error) {
                std::cerr << "Could not get key: " << input << std::endl << "\t";

                using Reason = FakeConfig::GetError::Reason;
                switch (error.reason) {
                    case Reason::ILLEGAL_KEY: {
                        std::cerr << "\"" << input << "\" is not a legal key" << std::endl;
                        break;
                    }
                    case Reason::KEY_NOT_FOUND: {
                        std::cerr << "key \"" << input << "\" was not found" << std::endl;
                        break;
                    }
                }
            }
        )) {
            // no early return, just continue with the next input
        }
        std::cout << std::endl;
    } while (true);

    return 0;
}

一些示例输出

./parser animals.txt
Enter a key (or ctrl-C to quit): tiger
        tiger -> tigger

Enter a key (or ctrl-C to quit): donkey
        donkey -> eeyore

Enter a key (or ctrl-C to quit): asdfqwef
        Could not get key: asdfqwef
        key "asdfqwef" was not found

Enter a key (or ctrl-C to quit): asdf@@
        Could not get key: asdf@@
        "asdf@@" is not a legal key

Enter a key (or ctrl-C to quit): ^C

./parser animals
Error initializing from file: animals
Invalid file

Error initializing from file: animals_error.txt
Syntax error on line 4
                tigertigger=

我认为这种错误处理范例可能存在于其他语言中，但我在 C++ 中找不到类似的东西。这可能本质上是临时的模式匹配？

非常欢迎您提供反馈，并指出任何潜在的缺陷。特别是针对Result类本身和使用示例的反馈。FakeConfig 代码本身只是一个愚蠢的演示程序，用于实际测试这个想法。