如何在不使用 c++ 中的“return”的情况下使用返回值退出 function

Question

How would I exit a function with a return value without using return .

Is there something like this in c++:

auto random_function() {
    printf("Random string"); // Gets executed

    exit_with_return_value(/* Any random value. */);

    printf("Same string as before"); // Doesn't get executed
}

Because I'm aware about exit() which takes a exit code. But is there any way I could exit with a return value.

It is just that I can't call return is parentheses like this:

( return /* random value*/ );

But I can call functions in parentheses,

(exit(0));

My use case:

 template <typename ...Parameters>
 class Parameter_Pack 
 {
 private:
     void* paramsAddr[sizeof...(Parameters)];

 public:
     Parameter_Pack(Parameters ...parameters) { 
        size_t count = 0;
       
       ((
        parameters, 
        this->paramsAddr[count] = malloc(sizeof(Parameters)), 
        *(Parameters*)paramsAddr[count] = parameters, 
        count++
      ), ...);
    }

    auto operator[](size_t index) {
        size_t count = 0;
        try {
           (((count == index ? : return * 
             (Parameters*)paramsAddr[index] : * 
             (Parameters*)paramsAddr[index]), count++), ...);
         } catch (Parameters...) {
              std::cout << "Error: " << std::endl;
         }
   }

    const size_t size() const {
        return sizeof...(Parameters);
    }
};

The problem is I can't return in auto operator[](size_t index) .

The compiler error is:

"expected primary-expression before 'return'"

Answer 1

This doesn't answer your question directly, but instead of reinventing the wheel why not unpack the parameter pack into an std::tuple . You can then use std::get to access the object 's by index.

#include <iostream>
#include <tuple>

template<typename ...Args>
static void unpack(Args&& ...args) 
{
    std::tuple pack{ std::forward<Args>(args)... };

    int first = std::get<0>(pack);
    std::cout << first << '\n';

    const std::string& second = std::get<1>(pack);
    std::cout << second << '\n';

    bool third = std::get<2>(pack);
    std::cout << std::boolalpha << third << '\n';
}

int main()
{
    unpack(42, std::string{ "Some string" }, false);
}

OK, so the only thing I could come up with that kind of does what you want is to use a std::vector in conjunction with a std::variant .

Personally I think this would be an annoying API to use but it will allow you to return multiple types from the subscript operator and doesn't require a constant expression, ie index can be a runtime value.

#include <iostream>
#include <variant>
#include <vector>
#include <string>

template<typename ...Args>
class Pack {    
public:
    using Types = std::variant<Args...>;

    Pack(Args... args)
        : pack_{ std::move(args)... }
    {}

    Types& operator[](const std::size_t index) {
        return pack_.at(index);
    }

    std::size_t size() const noexcept {
        return pack_.size();
    }

private:
    std::vector<Types> pack_;
};

int main() {
    Pack pack{42, std::string{ "Some string" }, false};
    std::cout << pack.size() << '\n';

    if (int* num = std::get_if<int>(&pack[0])) {
        std::cout << "My num: " << *num << '\n';
    }
}

Answer 2

return is a statement. Statements can't be part of a larger expression, so you can't return as a subexpression of some larger expression.

throw is an expression. It can be a subexpression of a larger expression, and you can throw any object you like.

It will be inconvenient for your callers, particularly if you mix it with an ordinary return. It will also not match the expectations other programmers have for how functions work. For that reason, I suggest you don't throw when you mean return .