这是一个有趣的挑战。

我想创建一些样板，允许使用类似于 perl 的 x 或 die("reason") 方法的语法干净地处理前提条件失败。

我想到了这个删除器:

struct do_exit {
    [[noreturn]]
    void operator()(void*) const noexcept {
        std::exit(code_);
    }
    int code_;
};

我们可以使用它来管理可能指向 std::cerr 的临时 std::unique_ptr 的“删除”:

struct exit_stream
{
    exit_stream(int code, std::ostream& os)
    : stream_(std::addressof(os), do_exit { code })
    {}

    std::ostream& as_stream() const { return *stream_; }
    operator bool() const { return bool(*stream_); }

    template<class T>
    friend auto operator<<(const exit_stream& es, T const& t) -> exit_stream const&
    {
        es.as_stream() << t;
        return es;
    }

    std::unique_ptr<std::ostream, do_exit> stream_;
};

使用以下函数创建:

exit_stream die(int code = 100)
{
    return exit_stream(code, std::cerr);
}

现在我们可以编写如下程序:

int main(int argc, char* argv[]) {

    // preconditions
    argc >= 2 or die(4) << "usage: myprog <inputfile>\n";

    auto input = std::ifstream(argv[1]);
    input or die(100) << "failed to open " << argv[1] << "\n";
}

这是有效的，因为当 exit_stream 作为临时返回时，它必须被移动(unique_ptr 删除复制操作符)。 unique_ptr 保证移出指针将为空。它还保证仅当 unique_ptr 不为空时才会调用删除器。因此，只有在调用点执行完所有流操作后，exit 才会被调用。

然而，明显的失败是我不会写:

auto input = std::ifstream(argv[1]]) or die() << "failed to open " << argv[1] << "\n";

因为如果我这样做，input 将是一个 bool。

这是我的问题。你能想出一种方法来产生所需的效果，或者尽可能接近它吗？

我真的想避免这种情况，因为传递案例的效率，以及清晰和优雅:

auto input = (std::ifstream(argv[1]]) or die() << "failed to open " << argv[1] << "\n").get();

完整代码:

#include <fstream>
#include <iostream>
#include <cstdlib>

struct do_exit {
    [[noreturn]]
    void operator()(void*) const noexcept {
        std::exit(code_);
    }
    int code_;
};

struct exit_stream
{
    exit_stream(int code, std::ostream& os)
    : stream_(std::addressof(os), do_exit { code })
    {}

    std::ostream& as_stream() const { return *stream_; }
    operator bool() const { return bool(*stream_); }

    template<class T>
    friend auto operator<<(const exit_stream& es, T const& t) -> exit_stream const&
    {
        es.as_stream() << t;
        return es;
    }

    std::unique_ptr<std::ostream, do_exit> stream_;
};

exit_stream die(int code = 100)
{
    return exit_stream(code, std::cerr);
}

int main(int argc, char* argv[]) {

    // preconditions
    argc >= 2 or die(4) << "usage: myprog <inputfile>\n";

    auto input = std::ifstream(argv[1]);
    input or die(100) << "failed to open " << argv[1];
}

最佳答案

好的，这是我的第一次尝试。由于缺少短路，我有点担心冗余构造，但语法是我想要的。

欢迎评论/改进!

#include <fstream>
#include <iostream>
#include <utility>
#include <iomanip>

namespace detail {
    struct tuple_emitter {
        tuple_emitter(std::ostream &os) : os(os) {}

        template<class...Refs>
        void operator()(std::tuple<Refs...> const &t) const {
            emit_impl(t, std::make_index_sequence<sizeof...(Refs)>());
        }

    private:

        template<class T>
        void emit_impl(T const &t) const {
            os << t;
        }

        // make sure we handle lazy manipulators
        void emit_impl(std::ios_base (* f)(std::ios_base &)) const
        {
            f(os);
        }

        template<class Tie, std::size_t...Is>
        void emit_impl(Tie const &refs, std::index_sequence<Is...>) const {
            using expand = int[];

            void(expand{0,
                        ((emit_impl(std::get<Is>(refs))), 0)...});
            os << std::endl;
        };


        std::ostream &os;
    };

    // a class that emits a number of references to std::cerr and then
    // exits    
    template<class...Refs>
    struct dier {
        dier(int code, std::tuple<Refs...> t) : code(code), emitter(std::cout), refs_(t) {}

        template<class...Others, class Ref>
        dier(dier<Others...> const &original, Ref const &r)
                : code(original.code), emitter(original.emitter), refs_(std::tuple_cat(original.refs_, std::tie(r))) {};

        void operator()() const {
            emitter(refs_);
            std::exit(code);
        }

        int code;
        tuple_emitter emitter;
        std::tuple<Refs&...> refs_;
    };

    template<class...Refs, class Ref>
    auto operator<<(dier<Refs...> original, Ref const &ref) {
        return dier<Refs..., const Ref &>(original, ref);
    };


    template<class T, class...Refs>
    T operator||(T &&t, dier<Refs...> death) {
        if (!t) {
            death();
        }
        return std::move(t);
    };

    template<class T, class...Refs>
    T const &operator||(T &t, dier<Refs...> death) {
        if (!t) {
            death();
        }
        return t;
    };
}

auto die(int code = 100) {
    return detail::dier<>(code, std::make_tuple());
}

int main(int argc, char *argv[]) {

    // preconditions
    argc >= 2 or die(4) << "usage: myprog <inputfile>\n";

    auto input = std::ifstream(argv[1]) or die(5) << "failed to open " << std::setfill('-') << std::setw(10) << argv[1] << " and here is a hex number " << std::hex << 40;

}

预期产出:

没有参数:

usage: myprog <inputfile>

使用一个参数“foo.txt”:

failed to open ---foo.txt and here is a hex number 28

根据 Yakk 的建议更新

归结为这个 - 这更清晰:

#include <fstream>
#include <iostream>
#include <utility>
#include <iomanip>

namespace notstd {

    namespace detail {
        template<class F, class T, std::size_t...Is>
        void apply_impl(F&& f, T&& t, std::index_sequence<Is...>)
        {
            using expand = int[];
            void(expand{0,
                        ((f(std::get<Is>(t))), 0)...});
        };
    }

    template<class F, class...Ts>
    void apply(F&& f, std::tuple<Ts...> const& t)
    {
        detail::apply_impl(std::forward<F>(f), t, std::make_index_sequence<sizeof...(Ts)>());
    };

    struct apply_to_stream
    {
        apply_to_stream(std::ostream& os)
                : os(os)
        {}

        template<class T>
        std::ostream& operator()(T&& t) const
        {
            return os << t;
        };

        std::ostream& operator()(std::ios_base& (*f)(std::ios_base&)) const
        {
            f(os);
            return os;
        };

        std::ostream& os;
    };


}

namespace detail {

    template<class Tuple>
    struct dier {
        constexpr dier(int code, Tuple t) : code(code), refs_(std::move(t)) {}

        void operator()() const {
            notstd::apply(notstd::apply_to_stream(std::cout), refs_);
            std::cout << '\n';
            std::exit(code);
        }

        int code;
        Tuple refs_;
    };

    template<class Tie>
    constexpr auto make_dier(int code, Tie&& t) {
        return detail::dier<Tie>(code, std::forward<Tie>(t));
    }

    template<class Tuple, class Ref>
    constexpr auto operator<<(dier<Tuple> original, Ref&& ref) {
        return make_dier(original.code, std::tuple_cat(original.refs_, std::tie(ref)));
    }


    template<class T, class...Refs>
    T operator||(T &&t, dier<Refs...> death) {
        if (!t) {
            death();
        }
        return std::forward<T>(t);
    }

}

template<class Tie = std::tuple<>>
constexpr auto die(int code = 100, Tie&& t = {}) {
    return detail::make_dier(code, std::forward<Tie>(t));
}

int main(int argc, char *argv[]) {

    // preconditions
    argc >= 2 or die(4) << "usage: myprog <inputfile>\n";

    auto input = std::ifstream(argv[1]) or die(5) << "failed to open " << std::setfill('-') << std::setw(10) << argv[1] << " and here is a hex number " << std::hex << 40;
}

关于c++ - C++ 中干净、功能性的脚本式错误处理，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/42989330/