Why this code must add sizeof()?

[nevergone]

Hello Everybody
In <<Modern C++ Design>Compile-Time Assertions
there is :
template <boolstruct CompileTimeChec ker
{
CompileTimeChec ker(...);
};

template <struct CompileTimeChec ker<false{ };

#define STATIC_CHECK(ex pr,msg) \
{ \
class ERROR_##msg {}; \
(void)sizeof( CompileTimeChec ker< (expr) !=
0>( (ERROR_##msg() ) )); \
}
//.....
so my question is why " (void)sizeof( CompileTimeChec ker< (expr) !=
0>( (ERROR_##msg() ) )); \" must add sizeof?
Thanks

[Ron Natalie]

nevergone wrote:

so my question is why " (void)sizeof( CompileTimeChec ker< (expr) !=
0>( (ERROR_##msg() ) )); \" must add sizeof?
Thanks

Sizeof is a handy function used in these kinds of macros because
it causes the syntax of the expression to be checked but never
actually evaluates the expression.

[aiooua]

On Apr 9, 2:08 pm, "nevergone" <wyx2006s...@gm ail.comwrote:

so my question is why " (void)sizeof( CompileTimeChec ker< (expr) != 0>( (ERROR_##msg() ) )); \" must add sizeof?

in general, checks for incomplete types are better done within sizeof
because it's runtime overheads are minimum. try to generate the
assembly code (using, g++ -S) with and without the "sizeof" and you'll
see that the sizeof version is better.

however, i have a related, but different problem. i tried the code as
printed in the book[#1] and couldn't get it to work.

---
/* begin code */
template<boolst ruct CompileTimeChec ker{ CompileTimeChec ker(...); };
template<struct CompileTimeChec ker<false{ };
#define STATIC_CHECK(ex pr, msg) { class ERROR_##msg {};
(void)sizeof(Co mpileTimeChecke r<(expr) != 0>((ERROR_##msg ()))); }
int main(){ STATIC_CHECK(1> 2,mustFail);}
/* end code */
---

here's what g++ gives me:

---

g++ -Wall -pedantic test.cpp

test.cpp: In function `int main()':
test.cpp:4: warning: ISO C++ forbids applying `sizeof' to a function
type
---

apart from that warning, the compilation goes through.
shouldn't it fail? what am i missing?

thanks,
--
#1 - pg. 21, Modern C++ Design, Andrei Alexandrescu.

[nevergone]

On 4ÔÂ9ÈÕ, ÏÂÎç8ʱ34·Ö, "aiooua" <aio...@gmail.c om>wrote:

On Apr 9, 2:08 pm, "nevergone" <wyx2006s...@gm ail.comwrote:

so my question is why " (void)sizeof( CompileTimeChec ker< (expr) != 0>( (ERROR_##msg() ) )); \" must add sizeof?

in general, checks for incomplete types are better done within sizeof
because it's runtime overheads are minimum. try to generate the
assembly code (using, g++ -S) with and without the "sizeof" and you'll
see that the sizeof version is better.

however, i have a related, but different problem. i tried the code as
printed in the book[#1] and couldn't get it to work.

---
/* begin code */
template<boolst ruct CompileTimeChec ker{ CompileTimeChec ker(...); };
template<struct CompileTimeChec ker<false{ };
#define STATIC_CHECK(ex pr, msg) { class ERROR_##msg {};
(void)sizeof(Co mpileTimeChecke r<(expr) != 0>((ERROR_##msg ()))); }
int main(){ STATIC_CHECK(1> 2,mustFail);}
/* end code */
---

here's what g++ gives me:

---g++ -Wall -pedantic test.cpp

test.cpp: In function `int main()':
test.cpp:4: warning: ISO C++ forbids applying `sizeof' to a function
type
---

apart from that warning, the compilation goes through.
shouldn't it fail? what am i missing?

thanks,
--
#1 - pg. 21, Modern C++ Design, Andrei Alexandrescu.

I don't know.
but i think it would be better to add () in 1>2

[Fei Liu]

nevergone wrote:

On 4ÔÂ9ÈÕ, ÏÂÎç8ʱ34·Ö, "aiooua" <aio...@gmail.c omwrote:

>On Apr 9, 2:08 pm, "nevergone" <wyx2006s...@gm ail.comwrote:

>>so my question is why " (void)sizeof( CompileTimeChec ker< (expr) != 0>( (ERROR_##msg() ) )); \" must add sizeof?

in general, checks for incomplete types are better done within sizeof
because it's runtime overheads are minimum. try to generate the
assembly code (using, g++ -S) with and without the "sizeof" and you'll
see that the sizeof version is better.

however, i have a related, but different problem. i tried the code as
printed in the book[#1] and couldn't get it to work.

---
/* begin code */
template<bools truct CompileTimeChec ker{ CompileTimeChec ker(...); };
template<struc t CompileTimeChec ker<false{ };
#define STATIC_CHECK(ex pr, msg) { class ERROR_##msg {};
(void)sizeof(C ompileTimeCheck er<(expr) != 0>((ERROR_##msg ()))); }
int main(){ STATIC_CHECK(1> 2,mustFail);}
/* end code */
---

here's what g++ gives me:

---g++ -Wall -pedantic test.cpp

test.cpp: In function `int main()':
test.cpp:4: warning: ISO C++ forbids applying `sizeof' to a function
type
---

apart from that warning, the compilation goes through.
shouldn't it fail? what am i missing?

thanks,
--
#1 - pg. 21, Modern C++ Design, Andrei Alexandrescu.

I don't know.
but i think it would be better to add () in 1>2

It's not necessary to add () in 1>2 except for readability reasons
(arguably since some people consider more () to be less readable). In
the macro, 'expr' is already guarded by ().

I found the code example confusing, it almost seemed like it should do a
sizeof(CompileT imeChecker<(exp r)>) != 0 test instead. It may be trying
to facility the empty structure optimization, an empty struct/class's
sizeof returns 0 as the specialization template<struct
CompileTimeChec ker<false{ }; would do.

Fei

[=?gb2312?B?stTxtw==?=]

i got the same problem with aiooua
but if i took off the sizeof function
the code could work,but it seems that the compiler took the code
"CompileTimeChe cker< (expr) >( (ERROR_##msg() ) )"
as a function declaration instead of a temporary object
here is my test code :

#include <iostream>
using namespace std ;
template <boolstruct CompileTimeChec ker
{
CompileTimeChec ker(...) { cout << "constructo r" << endl ; }
};
template <struct CompileTimeChec ker<false{ };
#define STATIC_CHECK(ex pr,msg) \
{ \
class ERROR_##msg {}; \
CompileTimeChec ker< (expr) >( (ERROR_##msg() ) ); \
}
int main()
{
STATIC_CHECK( true , error ) ;
return 0 ;
}
can anybody explain it ?

[Jack Klein]

On Mon, 09 Apr 2007 07:51:25 -0400, Ron Natalie <ro*@spamcop.ne t>
wrote in comp.lang.c++:

nevergone wrote:

so my question is why " (void)sizeof( CompileTimeChec ker< (expr) !=
0>( (ERROR_##msg() ) )); \" must add sizeof?
Thanks

Sizeof is a handy function used in these kinds of macros because
it causes the syntax of the expression to be checked but never
actually evaluates the expression.

sizeof is NOT a function, it is an operator.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[=?gb2312?B?stTxtw==?=]

i think i got the answer:
suppose you have a class : class a { public : a(){} } ;
when you write the code : a() ;
the compiler can explain this in two ways:
1. a temporary object of type a
2. a function declaration of type a (*)(void)
so , in order to distinguish this you can use sizeof
which can not take a function type as a parameter
in order to tell sizeof that which you pass is a type
you have to add additional ()
so ,if you write sizeof( ( a() ) ) , the compiler will understand
that
a() is a temporary object

[James Kanze]

On Apr 9, 2:34 pm, "aiooua" <aio...@gmail.c omwrote:

On Apr 9, 2:08 pm, "nevergone" <wyx2006s...@gm ail.comwrote:

so my question is why " (void)sizeof( CompileTimeChec ker< (expr) != 0>( (ERROR_##msg() ) )); \" must add sizeof?

in general, checks for incomplete types are better done within sizeof
because it's runtime overheads are minimum. try to generate the
assembly code (using, g++ -S) with and without the "sizeof" and you'll
see that the sizeof version is better.

however, i have a related, but different problem. i tried the code as
printed in the book[#1] and couldn't get it to work.

---
/* begin code */
template<boolst ruct CompileTimeChec ker{ CompileTimeChec ker(...); };
template<struct CompileTimeChec ker<false{ };
#define STATIC_CHECK(ex pr, msg) { class ERROR_##msg {};
(void)sizeof(Co mpileTimeChecke r<(expr) != 0>((ERROR_##msg ()))); }

I'm not sure about the exact error message you got---it seems a
little strange. But this line is definitly illegal; for
starters, it contains a } for which there is no {. And ##
operators are only legal in macros.

Are you sure you didn't forget a \ at the end of the previous
line? This line would make sense as part of the macro.

int main(){ STATIC_CHECK(1> 2,mustFail);}
/* end code */
---

here's what g++ gives me:

---g++ -Wall -pedantic test.cpp

test.cpp: In function `int main()':
test.cpp:4: warning: ISO C++ forbids applying `sizeof' to a function
type

Which, as I say, is wierd. The only way a compiler could
possibly parse the sizeof here is as part of an expression
statement. (But of course, expression statements are not legal
at namespace scope.)

Note that if you did mean for this line to be part of the macro,
the line number in the error message should tip you off
immediately about the forgotten \. You never get error messages
from continuation lines in a macro. (Just error messages from
where you invoke the macro.)

---

apart from that warning, the compilation goes through.
shouldn't it fail? what am i missing?

Probably just an \.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[aiooua]

On Apr 10, 8:34 pm, "James Kanze" <james.ka...@gm ail.comwrote:

On Apr 9, 2:34 pm, "aiooua" <aio...@gmail.c omwrote:

however, i have a related, but different problem. i tried the code as
printed in the book[#1] and couldn't get it to work.
---
/* begin code */
template<boolst ruct CompileTimeChec ker{ CompileTimeChec ker(...); };
template<struct CompileTimeChec ker<false{ };
#define STATIC_CHECK(ex pr, msg) { class ERROR_##msg {};
(void)sizeof(Co mpileTimeChecke r<(expr) != 0>((ERROR_##msg ()))); }

Are you sure you didn't forget a \ at the end of the previous
line? This line would make sense as part of the macro.

the macro was well-formed when i compiled, it got wrapped into two
lines (maybe because of line-length limits or something) while i
posted it here.

I'm not sure about the exact error message you got---it seems a

unlike what the book says, and what i expected i did not get any
error.
however, i got the following warning.

--
test.cpp:4: warning: ISO C++ forbids applying `sizeof' to a function
type
--

it seemed too simple to be a g++ bug, but i'll follow it on their
newsgroup.

thanks,