Re: Can I use overloading for optional parameters?

From:

DeMarcus <use_my_alias_here@hotmail.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Wed, 31 Mar 2010 17:50:38 CST

Message-ID:

<4bb3c198$0$279$14726298@news.sunsite.dk>

Goran wrote:

On Mar 31, 5:43 pm, DeMarcus <use_my_alias_h...@hotmail.com> wrote:

Goran wrote:

On Mar 30, 5:49 pm, DeMarcus <use_my_alias_h...@hotmail.com> wrote:

Hi,
I need to provide a set of parameters to a function where one or more
can be optional. Standard C++ can only provide default values for the
last parameters and a default value representing N/A for references is
not quite pleasant.
I came up with an idea of overloading the optional parameters. Please
give me your feedback.
class SomeClass
{
public:
    void fnc( int& a );
    void fnc( int& a, int& b );
    void fnc( int& a, int& b, int& c );
    // Now insert a pointer if we want to disable (b).
    void fnc( int& a, int* b, int& c );
};

From what I gather, you have b and c as optional parameters from the
get-go. So I would go for:
void fnc( int& a, int* b=NULL, int* c=NULL);
That gives you, the implementor, all the information you need, and
only one public interface to maintain. That also gives you, the
user :-), a possibility to call any possible variant (a, ab, ac, abc)
through only one interface point, but with the inconvenience (IMO, a
very small one) of having to type a "&" in front of optional
parameters.
Goran.

Yes, in most cases that's the way to go, but in a few cases with
temporaries, that solution gives compiler warnings. E.g.

fnc( &TmpClass( "Hello" ), NULL, &TmpClass( "World" ) );

"Warning, taking address of temporary"

It's probably only that MSVC compiler that allows that. As said, it
should actually be an error. (Historicaly, MS was allowing this code,
as well passing temporary as non-const). But since you want to modify
a, b, c (otherwise, you would use "const", would you not?), it's
nonsense to pass a temporary, isn't it? :-)

Goran.

Sorry, I forgot to tell you I'm running with the C++0x switch, but the
original idea, or answer to your previous post, should remain.

The idea came from a constructor that looked like this.

MyClass( const SomeClass& a, const SomeClass& b, const SomeClass& c );

Here a temporary could make sense.

--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]