Question

Possible Duplicate:
What is the difference between (type)value and type(value)?

If you have a function that takes an argument of type b, but at the call site you only have a variable of type a. Is there a difference between casting the function parameter from a to b, and constructing type b.

The specific example I am interested in is when there is no user defined cast operator, but there is a single argument constructor.

Example:

Function definition:

void DoWork(const B &arg1);

In my specific example type a is const char *

Call site:

DoWork((B)"Hello");

vs

DoWork(B("Hello"));

B class definition

class B
{
public:
    B() : m_szValue(){}
    B(const char *szValue) { strcpy (m_szValue, szValue); }
private:
    char m_szValue[MAX_VALUE_LEN + 1];
};

Answer 1

Writing a C-style cast (T)x, where x is of type U, more or less tries the following in order:

1. If T and U are of class type, look for a conversion operator U::operator T() const or a one-argument constructor T::T(U).

2. If T and U are primitive types, apply the standard value conversions (int to double, etc.).

3. reinterpret_cast<T>(x).

Note that you mustn’t have both a conversion operator and implicit conversion construction, though, or the call will be ambiguous.

[Correction/Clarification:] There is no difference between T(x) and (T)x.[/] You can even say DoWork("Hello"); on account of the implicit conversion provided by the one-argument constructor. (Do disallow this sneaky behaviour, declare the constructor explicit, as is often a good idea for one-argument constructors.)