如何在 try 块中实例化变量？ [关闭]

Question

实现的最佳方法是什么：

for (const auto &arg : args) {
    try {
        auto var = create(arg);
    } catch (const std::invalid_argument &e) {
        continue;
    }
    // ...
    // use(var)
    // ...
}

一种方法是移动

    // ...
    // use(var)
    // ...

进入 try 块，但这引入了整个嵌套负载。另外，我不想捕捉来自use的错误

typeof(var) 是一个没有默认构造函数的类。

Answer 1

也许std::optional 是您所需要的。您可以将它与没有默认构造函数的 Class 一起使用，如下所示

如果您不想知道抛出了哪些异常值，您可以使用类似以下的方法

#include <iostream>
#include <optional>

struct A{
    int var;
    explicit A(int arg):var{arg}{}
    A() = delete ;
};
A create( int arg){
    if (arg == 5 || arg == 8)
        throw std::invalid_argument{""};
    return A{arg};
}

void use(const A & a)
{
    std::cout << "\n" << a.var;
}
int main()
{
    std::optional<A> a;
    for (size_t i{}; i < 10; ++i) {
        try {
            a = create(i);
        } catch (const std::invalid_argument &e) {
                continue;
        }
        if(a) use(a.value());

    }

}

Live

Answer 2

这样的事情会起作用：

template<typename T>
struct initializing {
    T self;
    template<typename F>
    initializing(F &&f) : self(std::forward<F>(f)()) { }
};

for(auto const &arg : args) {
    std::optional<initializing<std::decay_t<decltype(create(arg))>>> var_opt;
    try { var_opt.emplace([&]() -> decltype(auto) { return create(arg); }); }
    catch(std::invalid_argument const &e) { continue; }
    auto &var = var_opt->self;
}

Complete example

我们使用std::optional 本质上只是为了为我们的价值提供未初始化的存储。整个initializing 很可能是不必要的：它避免执行任何 移动或复制构造。如果您改为使用std::optional<std::decay_t<decltype(create(arg))>> var_opt 和var_opt.emplace(create(arg))，则如果create 按值返回，则该值将作为临时值实现，并且对该临时值的引用将传递给emplace。然后，最终对象将从该临时对象构造移动。一般来说，这已经足够了。

Answer 3

一种方法是将use(var) 移动到 try 块中，但这会引入大量的嵌套

您可以将use(var) 移出一个单独的函数并在您的try 块中调用它：

void use(var_type var) {
    //...
}

for(const auto& arg : args) {
    try {            
        use(create(arg));
    } catch(const std::invalid_argument& e) {
        continue;
    }
}

由于您无法控制 create 或 use 块，并且希望确保不会捕获 use 块中抛出的任何内容，因此您可以捕获并重新抛出 create 异常作为不同的类型只能捕捉到它。由于异常只应在异常情况下发生，因此这种开销应该没有任何问题。

例子：

struct create_error : std::invalid_argument {
    using std::invalid_argument::invalid_argument;
    explicit create_error(const std::invalid_argument& e) : std::invalid_argument(e) {}
};

auto create_wrapper(const arg_type& arg) {
    try {
        return create(arg);
    }
    catch(const std::invalid_argument& ex) {
        throw create_error(ex);
    }
}

void use(var_type var) {
    // may throw std::invalid_argument, but it won't be caught below
}

for(const auto& arg : args) {        
    try {
        use(create_wrapper(arg));
    }
    catch(const create_error& e) {
        continue;
    }        
}

Answer 4

我认为这主要取决于变量类型。

例如，如果它是一个指针（智能或哑），您可以在 try 块之前将其设置为 nullptr 并检查它是否被分配到 try 块之外。

如果它是无法获取nullptr 的另一种类型，您可以尽可能使用默认值。 如果这也不可能 - 那么您应该举一个具体的例子，也许您可​​以获得更好的答案。