Re: Why do single-argument constructors act as implicit type conversion functions by default

From:

Andrew Tomazos <andrew@tomazos.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Sun, 21 Jun 2009 01:05:24 CST

Message-ID:

<d6b7b07c-b447-456a-af08-7501054ee433@l8g2000vbp.googlegroups.com>

On Jun 20, 2:42 am, Bart van Ingen Schenau <b...@ingen.ddns.info>
wrote:

Andrew Tomazos wrote:

On Jun 17, 1:57 pm, Mathias Gaunard <loufo...@gmail.com> wrote:

On 16 juin, 19:51, Andrew Tomazos <and...@tomazos.com> wrote:

As I already told you, even without implicit conversions, finding
which overload is called is not necessarily clear, especially
with templates involved.

This is completely irrelevant. We were discussing using implicit
conversion versus explicit conversion. You will agree that
requiring explicit conversion will make it clearer than implicit
conversion
which overload is called. That's the point.

I fail to see how it is irrelevant.

The (only) argument against implicit conversions you gave is that it
makes it difficult to tell which overload is called.
Banning implicit conversions does not make that any clearer, however,
due to other facts, rendering your argument moot.

Of course it makes it clearer which one is called:

     void MyFunction(A a);
     void MyFunction(B b);

     C c = ...;
     MyFunction(c); // duh? which one is called?

     MyFunction(A(c)); // oh that one

Your argument that we should ignore the advantage in this specific
case because there are other different cases where we can't do it (in
cases of virtual method call or templates etc) - is just ludicrous.

Lets take another example.
Assuming we have these classes and a function:

class Text { /* some members */ };
class ColorText : public Text { /* some members */ };

void Render(const Text&);

And we have two objects:

Text t;
ColorText ct;

Which of the sets of calls to Render would you prefer and why?

/* Set A */
Render(t);
Render(ct);

/* Set B */
Render(t);
Render(Text(ct));

/* Set C */
Render(Text(t));
Render(Text(ct));

The last two are completely incorrect. When an object is past to a
function taking a reference to one of its base classes, no copy
constructor is called. The pointer to the object is placed on the
call activation frame of the function. This example is not relevant
to the discussion of when to use implicit construction instead of
explicit construction.
   -Andrew.

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