C++返回类型nodiscard函数和void函数定义

Question

If i have a version of a function that returns a boolean i want to have a version of the function that doesnt return a boolean. i tried nodiscard around the function definition but it didnt allow for both definitions. are functions returning booleans the same speed as functions returning void? If not then is there a way to declare a void and a bool version of a function?

I dont need more space to describe my issue it is very simple. But i have to do weird things to allow me to post my question.

Answer 1

are functions returning booleans the same speed as functions returning void?

The overhead of assigning a value to a bool , and discarding a bool return value, is infinitesimal to the point of not being noticeable. So, essentially, yes for all practical purposes.

is there a way to declare a void and a bool version of a function?

Functions can't be overloaded on return value alone. You would have to either use separate function names:

bool myFunctionWithResult()
{
    ...
    return ...;
}

void myFunctionWithoutResult()
{
    myFunctionWithResult();
}

void doSomething()
{
    bool result = myFunctionWithResult();
    // use result as needed...
}

void doSomethingElse()
{
    myFunctionWithoutResult();
}

Or else give one of them an output parameter:

void myFunction(bool &result)
{
    ...
    result = ...;
}

void myFunction()
{
    bool ignored;
    myFunction(ignored);
}

void doSomething()
{
    bool result;
    myFunction(result);
    // use result as needed...
}

void doSomethingElse()
{
    myFunction();
}

In which case, you could simplify that into a single function:

void myFunction(bool *result = nullptr)
{
    ...
    if (result)
        *result = ...;
}

void doSomething()
{
    bool result;
    myFunction(&result);
    // use result as needed...
}

void doSomethingElse()
{
    myFunction();
}

Needless to say, for a bool (or any other primitive type), this is needlessly complicated. Just return the bool /primitive normally, and let the caller discard the value if it wants to. This kind of micro-optimizing only really matters if the output is a more complex type, say a class with dynamically allocated members, where returning an instance actually invokes overhead that you may need to avoid at times.