26

Since boost is forbidden in a company I work for I need to implement its functionality in pure C++. I've looked into boost sources but they seem to be too complex to understand, at least for me. I know there is something called static_assert() in the C++0x standart, but I'd like not to use any C++0x features.

Improve this question
4
  • did you ask why you're not allowed to use boost? Commented Dec 30, 2009 at 14:05
  • 3
    Nobody took the pain to build the case so that the lawyer's team give its approval for its use? Commented Dec 30, 2009 at 14:24
  • 1
    @Gregory Pakosz, they say because it is too complex :) Commented Dec 30, 2009 at 22:26
  • and can you use a compiler of some sort? because they are complex too Commented Jan 27, 2016 at 16:33

6 Answers 6

Reset to default
27

One other trick (which can be used in C) is to try to build an array with a negative size if the assert fail:

#define ASSERT(cond) int foo[(cond) ? 1 : -1]

as a bonus, you may use a typedef instead of an object, so that it is usable in more contexts and doesn't takes place when it succeed:

#define ASSERT(cond) typedef int foo[(cond) ? 1 : -1]

finally, build a name with less chance of name clash (and reusable at least in different lines):

#define CAT_(a, b) a ## b #define CAT(a, b) CAT_(a, b) #define ASSERT(cond) typedef int CAT(AsSeRt, __LINE__)[(cond) ? 1 : -1]
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Could someone explain why two CAT macros are necessary? What problem are you trying to avoid? Thanks.
If you don't do that, arguments which are macros (like __LINE__) aren't expanded. So it would generate AsSeRt__LINE__ instead of the wanted AsSeRt42. I'm pretty sure there is a question somewhere explaining this in detail.
21 
template<bool> struct StaticAssert; template<> struct StaticAssert<true> {}; int main() { StaticAssert< (4>3) >(); //OK StaticAssert< (2+2==5) >(); //ERROR }
Improve this answer

6 Comments

+1 simple enough, but I like to have a message associated with the assertion
@Gregory: StaticAssert< (2+2==5) > associatedMessage();
there are places where you don't want / can't use variables though
@Gregory: typedef StaticAssert< (2+2==5) > AssociatedMessage_t;
Aren't you missing the struct keyword in the first two lines? And the typedef trick doesn't appear to work - incomplete types appear to be acceptable (in fact it seems the struct might even declare, e.g a negative-sized array but typedeffing would still compile, as it doesn't instantiate the template?)
|
19

Here is my own implementation of static assertions extracted from my code base: Pre-C++11 Static Assertions Without Boost.

Usage:

STATIC_ASSERT(expression, message);

When the static assertion test fails, a compiler error message that somehow contains the STATIC_ASSERTION_FAILED_AT_LINE_xxx_message is generated.

message has to be a valid C++ identifier, like no_you_cant_have_a_pony which will produce a compiler error containing:

STATIC_ASSERTION_FAILED_AT_LINE_1337_no_you_cant_have_a_pony :)

#define CONCATENATE(arg1, arg2) CONCATENATE1(arg1, arg2) #define CONCATENATE1(arg1, arg2) CONCATENATE2(arg1, arg2) #define CONCATENATE2(arg1, arg2) arg1##arg2 /** * Usage: * * <code>STATIC_ASSERT(expression, message)</code> * * When the static assertion test fails, a compiler error message that somehow * contains the "STATIC_ASSERTION_FAILED_AT_LINE_xxx_message" is generated. * * /!\ message has to be a valid C++ identifier, that is to say it must not * contain space characters, cannot start with a digit, etc. * * STATIC_ASSERT(true, this_message_will_never_be_displayed); */ #define STATIC_ASSERT(expression, message)\ struct CONCATENATE(__static_assertion_at_line_, __LINE__)\ {\ implementation::StaticAssertion<static_cast<bool>((expression))> CONCATENATE(CONCATENATE(CONCATENATE(STATIC_ASSERTION_FAILED_AT_LINE_, __LINE__), _), message);\ };\ typedef implementation::StaticAssertionTest<sizeof(CONCATENATE(__static_assertion_at_line_, __LINE__))> CONCATENATE(__static_assertion_test_at_line_, __LINE__) // note that we wrap the non existing type inside a struct to avoid warning // messages about unused variables when static assertions are used at function // scope // the use of sizeof makes sure the assertion error is not ignored by SFINAE namespace implementation { template <bool> struct StaticAssertion; template <> struct StaticAssertion<true> { }; // StaticAssertion<true> template<int i> struct StaticAssertionTest { }; // StaticAssertionTest<int> } // namespace implementation STATIC_ASSERT(true, ok); STATIC_ASSERT(false, ko); int main() { return 0; }
Improve this answer

2 Comments

Very nice! This is a complete solution (and a good alternative to boost's implementation if you want to avoid boost itself) +1
If you have -Wunused-local-typedef and warnings as errors, this will fail to build with an error about unused typedef. That can be circumvented by adding __attribute__ ((unused)) to the typedef in the STATIC_ASSERT macro (at least for gcc and clang).
4

You could simply copy the macro from the Boost source file to your own code. If you don't need to support all the compilers Boost supports you can just pick the right definition for your compiler and omit the rest of the #ifdefs in that file.

Improve this answer

1 Comment

Is that legal with Boost's license?
4

I believe this should work:

template<bool> struct CompileTimeAssert; template<> struct CompileTimeAssert<true>{}; #define STATIC_ASSERT(e) (CompileTimeAssert <(e) != 0>())
Improve this answer

Comments

2

I am using the following header file, with code ripped from someone else...

#ifndef STATIC_ASSERT__H #define STATIC_ASSERT__H /* ripped from http://www.pixelbeat.org/programming/gcc/static_assert.html */ #define ASSERT_CONCAT_(a, b) a##b #define ASSERT_CONCAT(a, b) ASSERT_CONCAT_(a, b) /* These can't be used after statements in c89. */ #ifdef __COUNTER__ /* microsoft */ #define STATIC_ASSERT(e) enum { ASSERT_CONCAT(static_assert_, __COUNTER__) = 1/(!!(e)) } #else /* This can't be used twice on the same line so ensure if using in headers * that the headers are not included twice (by wrapping in #ifndef...#endif) * Note it doesn't cause an issue when used on same line of separate modules * compiled with gcc -combine -fwhole-program. */ #define STATIC_ASSERT(e) enum { ASSERT_CONCAT(assert_line_, __LINE__) = 1/(!!(e)) } #endif /* http://msdn.microsoft.com/en-us/library/ms679289(VS.85).aspx */ #ifndef C_ASSERT #define C_ASSERT(e) STATIC_ASSERT(e) #endif #endif
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.