在返回 void 的函数中，为什么要返回 void 表达式而不是省略 return 语句？

Question

考虑以下代码片段：

void Foo()
{
  // ...
}

void Bar()
{
  return Foo();
}

与更常见的方法相比，在 C++ 中使用上述内容的合理理由是什么：

void Foo()
{
  // ...
}

void Bar()
{
  Foo();

  // no more expressions -- i.e., implicit return here
}

Answer 1

在您的示例中可能没有用，但在某些情况下很难在模板代码中处理 void ，我希望此规则有时会有所帮助。非常人为的示例：

#include <iostream>

template <typename T>
T retval() {
    return T();
}

template <>
void retval() {
    return;
}

template <>
int retval() {
    return 23;
}

template <typename T>
T do_something() {
    std::cout << "doing something\n";
}

template <typename T>
T do_something_and_return() {
    do_something<T>();
    return retval<T>();
}

int main() {
    std::cout << do_something_and_return<int>() << "\n";
    std::cout << do_something_and_return<void*>() << "\n";
    do_something_and_return<void>();
}

请注意，只有 main 必须处理这样的事实：在 void 情况下， retval 没有任何内容可返回。中间函数do_something_and_return是通用的。

当然，这只能让你到目前为止 - 如果在正常情况下 do_something_and_return 想要将 retval 存储在变量中并在返回之前对其执行某些操作，那么你会仍然有麻烦 - 你必须专门化（或重载）do_something_and_return for void。

Answer 2

这是一个相当无用的结构，除非与模板一起使用，否则没有任何作用。也就是说，如果您定义的模板函数返回的值可能为“void”。

Answer 3

您可以在通用代码中使用它，其中 Foo() 的返回值未知或可能会更改。考虑：

template<typename Foo, typename T> T Bar(Foo f) {
    return f();
}

在这种情况下，Bar 对于 void 有效，但如果返回类型更改也有效。然而，如果它只是调用 f，那么如果 T 是非空的，这段代码就会中断。使用 return f();语法保证保留 Foo() 的返回值（如果存在），并且允许使用 void()。

此外，明确返回是一个值得养成的好习惯。

Answer 4

模板：

template <typename T, typename R>
R some_kind_of_wrapper(R (*func)(T), T t)
{
   /* Do something interesting to t */
   return func(t);
}

int func1(int i) { /* ... */ return i; }

void func2(const std::string& str) { /* ... */ }

int main()
{
   int i = some_kind_of_wrapper(&func1, 42);

   some_kind_of_wrapper(&func2, "Hello, World!");

   return 0;
}

如果无法返回 void，则当要求包装 func2 时，模板中的 return func(t) 将无法工作。

Answer 5

我能想到的唯一原因是，如果您在 switch 中有一长串 return Foo(); 语句，并且希望使其更加紧凑。

Answer 6

可能是 Foo() 最初返回一个值，但后来改为 void，而更新它的人只是想得不太清楚。

Answer 7

首先也是最重要的，在编写模板时返回 void 会很有帮助。
如果您知道函数返回 void，您通常不会这样做，但它是合法的会很有帮助：

template <typename T, typename F>
auto apply(T x, F f) {
    // if f returns void, the return type of apply is deduced to void, and the following
    // return statement is legal
    return f(x);
}

这个示例可能有点人为，但实际上，返回 void > 简化了 std::apply 的实现。

另一个用例是使 switch 语句更加紧凑：

void one(), two(), three();

void before(int x) {
    switch (x) {
    case 1:
        one();
        break;
    case 2:
        one();
        break;
    case 3:
        one();
        break;
    }
}

void after(int x) {
    switch (x) {
    case 1: return one();
    case 2: return two();
    case 3: return three();
    }
}

从技术上讲，before 每个案例也可以只有一行，但是将多个语句放在一行上通常会与样式指南发生冲突，并且/或自动格式化程序。

Answer 8

原因是返回内存，就像 math.h 总是返回一样。 math.h 没有 void 也没有空参数。有许多实际情况需要记忆。