add a parameter or add a function? - c++

Question

I always meet such a problem when coding.
there is a interface named "INetworkReader", which looks like:
struct INetworkReader
{
virtual void readFile(const std::string& url) = 0;
...
};
Now, I wanted to expand the readFile() function, the readFile() function need setting a timeout or something else to realize more controls, so Now I has two solutions.
solution 1(add a default parameter):
struct INetworkReader
{
virtual void readFile(const std::string& url, int timeout = 0) = 0;
...
};
solution 2(add another function):
struct INetworkReader
{
virtual void readFile(const std::string& url) = 0;
virtual void readFileTimeout(const std::string& url，int timeout) = 0;
...
};
I prefer the solution 1 for that it's parameter describe it's action clearly, the only disadvantage I think is that it increase the number of parameter.
So, as you see, which looks better? why?
I found another case which could be more complicated, look the following code.
struct IComputer
{
virtual bool addMouse(/* in */const std::string& mouseID, /*out*/ IMouse** ppMouse ) = 0;
}
Now want to add a parameter to tell if it's adding to a USB port, these are still has two solutions.
solution 1(add a default parameter):
struct IComputer
{
virtual bool addMouse(/* in */const std::string& mouseID, /*out*/ IMouse** ppMouse, /* in */ bool USBPort = true ) = 0;
}
solution 2(add another function):
struct IComputer
{
virtual bool addMouse(/* in */const std::string& mouseID, /*out*/ IMouse** ppMouse ) = 0;
virtual bool addMouseNotUSB(/* in */const std::string& mouseID, /*out*/ IMouse** ppMouse ) = 0;
}
this time I prefer the second for that the first solution has broken sequence of in-out parameter.
so, two case, four solutions, which one is better? why?

Answer 1

IMO I prefer solution 2 (as long as it takes a timeout parameter). If you face the code for the first time, you'll quickly understand what '1000' is in the expression readFileTimeout(url, 1000), rather than in readFile(url, 1000). In the second expression one could think the code is reading 1000 bytes, for example.
In the second case, I also prefer using different function names, but since we're passing a boolean, I'd use function names from which one can deduce the boolean value:
addMouse(const std::string& mouseID, IMouse** ppMouse) //For non-USB mice
addUSBMouse(const std::string& mouseID, IMouse** ppMouse) //For USB mice
The decision of using inverse logic or not (i.e. creating addNonUSBMouse instead of addUSBMouse) is arbitrary and depends on the cases your code is likely going to run. If in most cases mice are not USB, use my proposal. Otherwise use the inverse logic version.
My lemma is: try naming functions the way it would be unnecessary to read their prototypes.

Answer 2

Yet another option is to use types to force expressiveness in the calling code:
struct INetworkReader
{
virtual void readFile(const std::string& url, Timeout timeout = Timeout::Infinite) = 0;
...
};
Calling code might be:
p->readFile(url, Timeout{200, Timeout::ms});
Mote that a Timeout of 0 is a bit ambiguous: it might mean a non-blocking check for data, or it might block indefinitely, so a value like Infinite or Never is clearer.
With C++14 you could create an explicit Timeout constructor from a std::chrono::duration such as 200ms.
For the mouse example:
enum Connection { USB, NonUSB };
virtual std::pair<bool, IMouse*> addMouse(const std::string& mouseID,
Connection connection = USB ) = 0;
Notice that for the in / out parameter problem, I've returned all outputs rather than taking an IMouse**? You could return a tuple, pair or custom struct.

Answer 3

Solution 1 is preferred. It's definitely OK for a function to contain two parameters. Just consider other solutions(such as the Builder Pattern for too many parameters for constructors) when there are too many parameters.