composition of declarators

[ssailor]

I saw an exaple in the c++ standard(clause 6.8),

-------------------------------------------------------
struct T1 {
T1 operator ()( int x ) { return T1(x ); }
int operator =( int x ) { return x; }
T1(int ) { }
};
struct T2 { T2(int ){ } };
int a , (*(* b)( T2 ))( int ), c , d;
void ff ()
{
T1(a) = 3 ,
(*(* b)( T2(c )))( int(d )); // AA
}

 

[Victor Bazarov]

I saw an exaple in the c++ standard(clause 6.8),

-------------------------------------------------------
struct T1 {
T1 operator ()( int x ) { return T1(x ); }
int operator =( int x ) { return x; }
T1(int ) { }
};
struct T2 { T2(int ){ } };
int a , (*(* b)( T2 ))( int ), c , d;
void ff ()
{
T1(a) = 3 ,
(*(* b)( T2(c )))( int(d )); // AA
}

It is.

Then, what's the meaning of this declaration? Thank in advance.

The second part of the declaration declares 'b' to be a pointer
to a function that takes one argument of type 'int' and returns
a pointer to a function that takes one argument of type T2 and
returns T1. 'c' and 'd' are names of the formal arguments and
do not add meaning to the declaration. The fact that they are
in parentheses does not matter.

In the example in the subclause 6.8 of the Standard the
declaration of 'b' is preceded by another declaration of 'T2'
which masks the type name, thus making parsing of the 'b'
declaration improper, and the code ill-formed. That's at least
AIUI. No diagnostic is required, though. Online trial of
Comeau compiles either code without a problem.

V

 

[ssailor]

'c' and 'd' are names of the formal arguments and
do not add meaning to the declaration. The fact that they are
in parentheses does not matter.

I took for granted that T2(c ), int(d ) were function-style casts
instead of function parameter declarations. This is the cause of my
confusion.

Thanks again for your clarification.

 

[Sylvester Hesp]

It is.


The second part of the declaration declares 'b' to be a pointer
to a function that takes one argument of type 'int' and returns
a pointer to a function that takes one argument of type T2 and
returns T1.

Actually, it is the other way around: it is a function pointer taking a T2
and returning a pointer to a function taking an int and returning a T1.

The funny thing is, if you replace the comma on the previous line with a
semi-colon, it actually becomes a double function call: first on the
function pointed to by the earlier defined 'b', passing a T2 constructed out
of c, and another function call on the function returned by b(), passing an
int constructed out of d)

- Sylvester Hesp

 

[Victor Bazarov]

Actually, it is the other way around: it is a function pointer taking
a T2 and returning a pointer to a function taking an int and
returning a T1.

Right. My mistake.

The funny thing is, if you replace the comma on the previous line
with a semi-colon, it actually becomes a double function call: first
on the function pointed to by the earlier defined 'b', passing a T2
constructed out of c, and another function call on the function
returned by b(), passing an int constructed out of d)

The funnier thing is, if you drop 'T1' from the line above, the
entire statement becomes executable, assigning 3 to 'a' and then
calling 'b' and the other function as you described.

V