Constructor syntax woes.

[willo]

Greetings all,

I have run into a small problem with my understanding of some C++
language syntax, and seek some clarification.

Below is a condensed version of some code I'm having difficulty with:

================================================== =============

#include <cstddef// size_t
#include <functional// binary_function

// the input parameter type to a class constructor.
template< typename T >
struct ABinaryFunction : public std::binary_function< T, size_t,
double >
{
typename ABinaryFunction::result_type
operator()( typename ABinaryFunction< T >::first_argument_type lhs,
typename ABinaryFunction< T >::second_argument_type
rhs )
{
return ABinaryFunction< T >::result_type();
}
};

template< typename T >
class AClass
{
public:

// constructor takes one specialized binary_function type parameter.
AClass( std::binary_function< T, size_t, double function )
{
}

// arbitrary method to test instantiation.
bool True()
{
return true;
}
};

int main()
{
// this won't create a class of type "AClass".
AClass< int instance_a( ABinaryFunction< int >() );
// this will not compile.
bool bool_a = instance_a.True();

// this will create a class of type "AClass", along with an unwanted
binary_function_b.
ABinaryFunction< int binary_function_b;
AClass< int instance_b( binary_function_b );
// this will compile.
bool bool_b = instance_b.True();

return 0;
}

================================================== =============

I'm using gcc-4.3, and get the following compile-error:

test.cpp:37: error: request for member ‘True’ in ‘instance_a’, which
is of non-class type ‘AClass<int()(ABinaryFunction<int(*)())'

I'm not very adept at deciphering uncommon C++ syntax, but my best
guess is that line 37 is interpreted as a definition or declaration of
the parenthesis operator, which takes a pointer to ABinaryFunction's
parenthesis operator, and returns AClass. This is not what I expected
or intended at all.

What I wish to know is: why does the first stanza in main not
compile? To me, it is exactly the same as the second stanza; what am
I missing?

The second stanza works, so I can get by. However, using an anonymous
temporary ABinaryFunction object inline, as I intended stanza one to
be, is cleaner / more intuitive. Additionally, I'd like to know what
the syntax should be for what I intended, ( assuming it's possible. )

Thanks for your consideration,

-- Charles Wilcox

[Sam]

wi***@cynd.net writes:

[ snippety ]

I'm not very adept at deciphering uncommon C++ syntax, but my best
guess is that line 37 is interpreted as a definition or declaration of
the parenthesis operator, which takes a pointer to ABinaryFunction's
parenthesis operator, and returns AClass. This is not what I expected
or intended at all.

No, it appears to be parsed as a function prototype, that's what appears to
be happening. Consider the following statement:

int foo (char () );

This gets parsed as a prototype of a function that returns an int, and takes
a parameter that's a pointer to a function that returns a char, and takes
no parameters.

Your declaration is:

AClass< int instance_a( ABinaryFunction<int>() );

This apparently gets parsed a function prototype: a prototype for a function
that returns an AClass<int>, and that takes an argument of a pointer to a
function that returns an ABinaryFunction<int>, and takes no arguments.

When templates are involved, weird parsing anomalies like this are quite
common. I'm sure there's some obscure clause in the C++ standard that
explains why this gets parsed this way, but that's an academic excersize. I
note that if you change this to:

AClass< int instance_a( (ABinaryFunction<int>()) );

This apparently does what you want: invoke the default constructor for
ABinaryFunction<int>, and pass the result as the argument to AClass<int>'s
constructor.

Heh, this is a nice one.

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.9 (GNU/Linux)

iEYEABECAAYFAkh9QQQACgkQx9p3GYHlUOKAngCcDHSHPWH8ZJ XoG/hkolJnhxRi
U6cAn0YdD8w/dcTuyaAIj0CL6NjR4ips
=NWMO
-----END PGP SIGNATURE-----

[willo]

On Jul 15, 7:21*pm, [e-mail] wrote:

Greetings all,

I have run into a small problem with my understanding of some C++
language syntax, and seek some clarification.

Below is a condensed version of some code I'm having difficulty with:

================================================== =============

#include <cstddef// size_t
#include <functional// binary_function

// the input parameter type to a class constructor.
template< typename T >
struct ABinaryFunction : public std::binary_function< T, size_t,
double >
{
* typename ABinaryFunction::result_type
* operator()( typename ABinaryFunction< T >::first_argument_type lhs,
* * * * * * * typename ABinaryFunction< T >::second_argument_type
rhs )
* {
* * return ABinaryFunction< T >::result_type();
* }

};

template< typename T >
class AClass
{
* public:

* // constructor takes one specialized binary_function type parameter.
* AClass( std::binary_function< T, size_t, double function )
* {
* }

* // arbitrary method to test instantiation.
* bool True()
* {
* * return true;
* }

};

int main()
{
* // this won't create a class of type "AClass".
* AClass< int instance_a( ABinaryFunction< int >() );
* // this will not compile.
* bool bool_a = instance_a.True();

* // this will create a class of type "AClass", along with an unwanted
binary_function_b.
* ABinaryFunction< int binary_function_b;
* AClass< int instance_b( binary_function_b );
* // this will compile.
* bool bool_b = instance_b.True();

* return 0;

}

================================================== =============

I'm using gcc-4.3, and get the following compile-error:

test.cpp:37: error: request for member ‘True’ in ‘instance_a’, which
is of non-class type ‘AClass<int()(ABinaryFunction<int(*)())'

I'm not very adept at deciphering uncommon C++ syntax, but my best
guess is that line 37 is interpreted as a definition or declaration of
the parenthesis operator, which takes a pointer to ABinaryFunction's
parenthesis operator, and returns AClass. *This is not what I expected
or intended at all.

What I wish to know is: why does the first stanza in main not
compile? *To me, it is exactly the same as the second stanza; what am
I missing?

The second stanza works, so I can get by. *However, using an anonymous
temporary ABinaryFunction object inline, as I intended stanza one to
be, is cleaner / more intuitive. *Additionally, I'd like to know what
the syntax should be for what I intended, ( assuming it's possible. )

Thanks for your consideration,

*-- Charles Wilcox

This evening I realized I could explicitly break the line into a
declaration and "constructor by assignment" as follows:

AClass< int instance_a = AClass< int >( ABinaryFunction< int

>() );

I know the "constructor by assignment" is a bit confusing to some, but
I know it's actually using the explicit constructor only, as I put
"operator=" into a "private" section.

I like it a bit more than stanza two; I'll use this potentially.

[willo]

On Jul 15, 8:29*pm, Sam <[e-mail]:

[e-mail] writes:

[ snippety ]

I'm not very adept at deciphering uncommon C++ syntax, but my best
guess is that line 37 is interpreted as a definition or declaration of
the parenthesis operator, which takes a pointer to ABinaryFunction's
parenthesis operator, and returns AClass. *This is not what I expected
or intended at all.

No, it appears to be parsed as a function prototype, that's what appears to
be happening. Consider the following statement:

int foo (char () );

This gets parsed as a prototype of a function that returns an int, and takes
a parameter that's a pointer to a function that returns a char, and takes
no parameters.

Your declaration is:

AClass< int instance_a( ABinaryFunction<int>() *);

This apparently gets parsed a function prototype: a prototype for a function
that returns an AClass<int>, and that takes an argument of a pointer to a
function that returns an ABinaryFunction<int>, and takes no arguments.

When templates are involved, weird parsing anomalies like this are quite
common. I'm sure there's some obscure clause in the C++ standard that
explains why this gets parsed this way, but that's an academic excersize.I
note that if you change this to:

AClass< int instance_a( (ABinaryFunction<int>()) );

This apparently does what you want: invoke the default constructor for
ABinaryFunction<int>, and pass the result as the argument to AClass<int>'s
constructor.

Heh, this is a nice one.

*application_pgp-signature_part
1KDownload

Sam,

Thanks for the input. I see your point, that it's declaring a
function prototype.

The double-parens trick is very cute, although it's not very clear /
why/ it works. It's a bit subtle... I think I'd almost prefer
something more explicit. As I just previously posted, I was able to
make the line compile by breaking it out into a variable declaration,
and a "constructor by assignment". Of course, that could confuse
people into thinking a real assignment is happening.

Ahh well, the fun of C++ parsing legacy.

-- Charles Wilcox