template constructor

[Alexander Stippler]

Hello,

short question: What is illegal about the following code?

template <typename T>
class Method
{
};

class Procedure
{
public:
template <typename T>
Procedure(const Method<T> &rhs);

double
operator()(double x);
};

int
main()
{
Procedure p(Method<double>());
p(1.);

return 0;
}

I want the operator() to be called with p(1.), but the compiler thinks
different and wants to choose the constructor? Why?

regards,
alex

 

[msalters]

Hello,

short question: What is illegal about the following code?

Nothing, it seems.

template <typename T>
class Method
{
};

class Procedure
{
public:
template <typename T>
Procedure(const Method<T> &rhs);

double
operator()(double x);
};

int
main()
{
Procedure p(Method<double>());
p(1.);

return 0;
}

I want the operator() to be called with p(1.), but the compiler thinks
different and wants to choose the constructor? Why?

No, it doesn't think that. It /does/ call the
Procedure:rocedure(Method<double>() const& rhs) constructor
first, because that is the argument you provided when you
defined p. Oviously, you must create p before you use p.

Once it is constructed (the ctor returned) the compiler /will/
call Procedure:perator()(double).

Regards,
Michiel Salters

 

[msalters]

Hello,

short question: What is illegal about the following code?

Nothing, it seems.

template <typename T>
class Method
{
};

class Procedure
{
public:
template <typename T>
Procedure(const Method<T> &rhs);

double
operator()(double x);
};

int
main()
{
Procedure p(Method<double>());
p(1.);

return 0;
}

I want the operator() to be called with p(1.), but the compiler thinks
different and wants to choose the constructor? Why?

No, it doesn't think that. It /does/ call the
Procedure:rocedure(Method<double>() const& rhs) constructor
first, because that is the argument you provided when you
defined p. Oviously, you must create p before you use p.

Once it is constructed (the ctor returned) the compiler /will/
call Procedure:perator()(double).

Regards,
Michiel Salters

 

[msalters]

Hello,

short question: What is illegal about the following code?

Nothing, it seems.

template <typename T>
class Method
{
};

class Procedure
{
public:
template <typename T>
Procedure(const Method<T> &rhs);

double
operator()(double x);
};

int
main()
{
Procedure p(Method<double>());
p(1.);

return 0;
}

I want the operator() to be called with p(1.), but the compiler thinks
different and wants to choose the constructor? Why?

No, it doesn't think that. It /does/ call the
Procedure:rocedure(Method<double>() const& rhs) constructor
first, because that is the argument you provided when you
defined p. Oviously, you must create p before you use p.

Once it is constructed (the ctor returned) the compiler /will/
call Procedure:perator()(double).

Regards,
Michiel Salters

 

[msalters]

Hello,

short question: What is illegal about the following code?

Nothing, it seems.

template <typename T>
class Method
{
};

class Procedure
{
public:
template <typename T>
Procedure(const Method<T> &rhs);

double
operator()(double x);
};

int
main()
{
Procedure p(Method<double>());
p(1.);

return 0;
}

I want the operator() to be called with p(1.), but the compiler thinks
different and wants to choose the constructor? Why?

No, it doesn't think that. It /does/ call the
Procedure:rocedure(Method<double>() const& rhs) constructor
first, because that is the argument you provided when you
defined p. Oviously, you must create p before you use p.

Once it is constructed (the ctor returned) the compiler /will/
call Procedure:perator()(double).

Regards,
Michiel Salters

 

[Tom Widmer]

Hello,

short question: What is illegal about the following code?

template <typename T>
class Method
{
};

class Procedure
{
public:
template <typename T>
Procedure(const Method<T> &rhs);

double
operator()(double x);
};

int
main()
{
Procedure p(Method<double>());

That's the declaration of a function "p" that takes a pointer to a

p(1.);

return 0;
}

I want the operator() to be called with p(1.), but the compiler thinks
different and wants to choose the constructor? Why?

Because it thinks p(1.) is a call of the (undefined) function you
declared above. I think you meant:

Procedure p((Method<double>()));
or the semantically very slightly different:
Procedure p = Method<double>();

Tom

 

[Alexander Stippler]

Nothing, it seems.


No, it doesn't think that. It /does/ call the
Procedure:rocedure(Method<double>() const& rhs) constructor
first, because that is the argument you provided when you
defined p. Oviously, you must create p before you use p.

Once it is constructed (the ctor returned) the compiler /will/
call Procedure:perator()(double).

Regards,
Michiel Salters

But icc8.1, gcc3.4 and como complain like that:

example.cc(20): error: argument of type "double" is incompatible with
parameter of type "Method<double> (*)()"
p(1.);

 

[Alexander Stippler]

That's the declaration of a function "p" that takes a pointer to a


Because it thinks p(1.) is a call of the (undefined) function you
declared above. I think you meant:

Procedure p((Method<double>()));
or the semantically very slightly different:
Procedure p = Method<double>();

Tom

Can you please explain to me the effect of the additional ()-pair? Where can
I find this difference in the standard?

regards,
alex

 

[Victor Bazarov]

Tom Widmer wrote:




Can you please explain to me the effect of the additional ()-pair? Where can
I find this difference in the standard?

How many times?

The statement:

<type-id> <identifier> ( <some-other-type-id> ( ) ) ;

is a _function_declaration_, not an object definition. Read the FAQ.

V