Return type declaration and checks

Question

I've been mainly programming PHP, and I recently started with C++.

In PHP the return of a function can be of any type, so you can do checks like this:

public function doSomething()
{
    if (! this->userHasAttribute()) {
        return false;
    }
    return "you are logged in.";
}

So basically, if the user would not be logged in doSomething would return false, else it returns a string.

Since in C++ you return strictly one datatype, how would you approach this?

How to structure those checks/policies, because clearly you dont want to have them inside a function itself (or you will be throwing exceptions everywhere you do a minor check).

Please correct me if I said anything incorrect.

---

I also came across this post, talking about why the Single Entry Single Exit notion exists in the first place. Someone said that the strongest argument in favor or SESE has vanished.

https://softwareengineering.stackexchange.com/a/118717/269571

Answer 1

One way of achieving this in C++ is via std::optional (upcomming in C++17) or boost::optional (external library).

It can wrap any type and basically allows you to check if a value has been set or not.

#include <iostream>
#include <optional>
#include <string>

std::optional<std::string> doSomething()
{
    if (! userHasAttribute()) {
        return {};
    }
    return "you are logged in.";
}

int main()
{
    auto result = doSomething();
    if (result)
    {
        std::cout << *result;  
    }
}

Answer 2

You can return more than one result & result type in C & C++ but you need to do it differently, you have a couple of options:

1. Return an enumerate type with one entry for each possible result and have a separate decode/log function that gives the text of the appropriate message. Important to remember - your decoder/log must be able to handle invalid values. One nice way of doing this in C++ is to create a type/class that has the values as an enumerate but has it's own decoder or output method that looks up the text to output.

2. Pass into the function one, or more, pointers that allow the function to pass supplementary information back. In your example above you would return a bool for success or failure but also use a string pointer passed into the call to pass back, as opposed to return, a text message of why that was the result. Important things to remember in this case:

   • Possible Null pointers as inputs - need to check for them!
   • All paths though the code should set both the return value and the message.
   • Possible string overflows if you write a string to a location & possible memory leaks if you pass back a pointer to a dynamically created value.
   • Any pointers that are passed in should be marked static if not intended to be written to.
   • Clear comments & documentation of what such pointers are, must point to, etc. /* Note that the following is very rough and does not have the checks for null pointers, etc. DO NOT USE FOR PRODUCTION CODE you may also need to play about with where the const goes.*/ public function doSomething(const char** Message // pointer to where to pu an Output message to supplement the result ) { bool result = FALSE; if (! this->userHasAttribute()) { *Message = "You are not logged in"; } else { *Message = "you are logged in."; result = TRUE; } return result; }
3. You can modify class members to provide more detailed results or even, (horrid don't do it), global variables.
4. You can also do nasty things like always returning a string then parsing the string for specific content, e.g. does the returned value start with "OK", or even nastier, (but I have seen it done), pass back a null terminated string with the result value after the 0x00 I do not recommend either of these options!