Templated constructor behaviour

[Ioannis Papadopoulos]

Hi,

I have the following code:

#include <iostream>

int foo() {
std::cout << __func__ << std::endl;
}

struct func {
void operator()() {
std::cout << __func__ << std::endl;
}
};

class run {
private:
public:
run() {
std::cout << "THIS SHOULD NOT HAVE BEEN CALLED 1" << std::endl;
}
run(const run&) {
std::cout << "THIS SHOULD NOT HAVE BEEN CALLED 2" << std::endl;
}

template<typena me Functor>
run(Functor f) {
std::cout << "CALLED" << std::endl;
f();
}
};

int main() {
run(foo);
run(func());
return 0;
}

My output is:
THIS SHOULD NOT HAVE BEEN CALLED 1

and clearly not what I expected. Any hints?

Thanks

[werasm]

Neelesh Bodas wrote:

Look at the following example. Do you think it would compile and run?

class X { };
int main()
{
X(helloworld);
}

The above code compiles and runs properly. Why? because

X(helloworld);

Runs properly, although different to original intention...

is treated as a "declaratio n" by the compiler. ("anything that can be
treated as a declaration will be treated as a declaration"). Thus

Yes.

int main()
{
X(helloworld);
}

is same as saying

I think you meant "is not the same as saying"

int main()
{
X helloworld; //define variable of type X. The name of the
variable is "helloworld ".
}

In the one case its a declaration of a function pointer, in the other
a definition of the variable. But I think that is what you meant, I'm
just clarifying it a bit for the OP.

Regards,

Werner

[Neelesh Bodas]

On Aug 28, 2:02 pm, werasm <wer...@gmail.c omwrote:

Neelesh Bodas wrote:

int main()
{
X(helloworld);
}

is same as saying

I think you meant "is not the same as saying"

No i didnot.

int main()
{
X helloworld; //define variable of type X. The name of the
variable is "helloworld ".
}

int the example given by me, I said that
int main() { X(helloworld);}
is semantically equivalent to (aka "same as" )
int main() { X helloworld;}

-N

[werasm]

Neelesh Bodas wrote:

the example given by me, I said that
int main() { X(helloworld);}
is semantically equivalent to (aka "same as" )
int main() { X helloworld;}

Ahhh, I learnt something. Your're right. I was thinking
about this case:

struct X
{
int foo();
};
int f1()
{
X helloworld;
helloworld.foo( );
return 0;
}

int f2()
{
X helloworld();
helloworld(); //calls the function that returns X and takes void as
param
return 0;
}

Now for a question. Is this considered a definition? I know that it
is
categorized as a declaration.

X helloworld;

W

[Neelesh Bodas]

On Aug 28, 3:37 pm, werasm <wer...@gmail.c omwrote:

Now for a question. Is this considered a definition?
I know that it ix categorized as a declaration.

X helloworld;

Yes, it is a definition. This statement defines an object of type X.
The fact that the constructor X::X() is invoked indicates that this is
a definition.

-N

[werasm]

Yes, it is a definition. This statement defines an object of type X.
The fact that the constructor X::X() is invoked indicates that this is
a definition.

This is exactly why your original wording...

"X(hellowor ld);

is treated as a "declaratio n" by the compiler. ("anything that can be
treated as a declaration will be treated as a declaration"). Thus ...
"

confused me.

Yes, its treated as a declaration, but a declaration <is adefinition
in this
case. All said, I've never used the syntax...

X(helloworld)

....before, and confused it with a function ptr returning X named
helloworld (which
is is not, of course).

Kind regards,

Werner

[Joe Greer]

See Neelesh Boda's post about what you have actually declared in your main(), but to add
something further. You seem to think that there is a way to invoke a member function on
an object without actually creating an object. There isn't. Why have the run class at
all? Pull your templated function out of the class and invoke it directly. That is:

template <typename Functor>
void run(Functor f)
{
std::cout << "CALLED" << std::endl;
f();
}

int main()
{
run(foo);
run(func());
return 0;
}
Should work as you expect. Generally speaking, if you have a stateless class, think
twice about why you think you want a class. With the exception of functors, namespaces
or classes with static methods work just well (if not better) and you don't have to
create useless instances just to invoke the method.

joe