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]

Alexander Stippler wrote:

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::Procedure(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::operator()(double).

Regards,
Michiel Salters

[msalters]

Alexander Stippler wrote:

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::Procedure(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::operator()(double).

Regards,
Michiel Salters

[msalters]

Alexander Stippler wrote:

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::Procedure(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::operator()(double).

Regards,
Michiel Salters

[msalters]

Alexander Stippler wrote:

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::Procedure(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::operator()(double).

Regards,
Michiel Salters

[Alexander Stippler]

msalters wrote:

Alexander Stippler wrote:

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::Procedure(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::operator()(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.);

[Tom Widmer]

On Tue, 07 Dec 2004 15:13:50 +0100, Alexander Stippler
<st**@mathematik.uni-ulm.de> wrote:

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
function that returns a Method<double> and returns a Procedure.
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]

Tom Widmer wrote:

On Tue, 07 Dec 2004 15:13:50 +0100, Alexander Stippler
<st**@mathematik.uni-ulm.de> wrote:

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
function that returns a Method<double> and returns a Procedure.

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

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]

Alexander Stippler wrote:

Tom Widmer wrote:

On Tue, 07 Dec 2004 15:13:50 +0100, Alexander Stippler
<st**@mathematik.uni-ulm.de> wrote:

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
function that returns a Method<double> and returns a Procedure.

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

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