CODEWITHSUNDEEP
c++c++11cross-compilingpreprocessor-directive
qdii
qdii

Reputation: 12963

How can I know if my compiler support XXXX C++11 feature?

Possible Duplicate:
How do I check for C++11 support?

I am writing a small library and I would like to use class enums whenever the compiler supports them. I also want to use other C++11 features, such as final and override keywords.

So far, I have used tricks to make sure it compiled on all versions of GCC, but I when I booted my Windows partition, Visual Studio 2010 started complaining too. Here is an example of the tricks I used:

#if __GNUC__ == 4 && (__GNUC_MINOR__ > 7 || \
      (__GNUC_MINOR__ == 7 && __GNUC_PATCHLEVEL__ > 1))
#   define TATO_OVERRIDE override
#   define TATO_NO_THROW nothrow
#else
#   define TATO_OVERRIDE
#   define TATO_NO_THROW throw()
#endif

I know that the newest version of Visual Studio already supports a batch of new features too. What I would like to have, is something like a set of macro which tells me what features are available on the compiler I am using. 

#ifdef THIS_COMPILER_SUPPORTS_CLASS_ENUMS
  ...
#endif

Does this exist? Is there a library that does that?

The compiler’s documentation?

Let me clarify. I know how to find those information, my problem is elsewhere. I don’t want to go through every possible compiler’s documentation to gather those information, especially since the same compiler might support different features with respect to its version. This is what I have been doing so far, and what I am looking for is actually a way not to do that.

Upvotes: 4

Views: 5979

Answers (4)

Cheers and hth. - Alf
Cheers and hth. - Alf

Reputation: 145379

“What I would like to have, is something like a set of macro which tells me what features are available on the compiler I am using.”

There's no such thing in the standard.

A practical approach to compiler differences is to have a header for each compiler and compiler version you support. These headers should have the same name. Which one is included depends on the include path, tool usage, which is easy to customize for each compiler.

I call that concept virtual headers. I've found that it works nicely for three levels: system dependency, compiler dependency and version dependency. I think the scheme doesn't scale up to more than that, but on the other hand, that seems to be all that one needs.

Upvotes: 0

Dietmar Kühl
Dietmar Kühl

Reputation: 153955

There were discussions of having some standardized feature test mechanism but it turns out that this doesn't make any sense: If a compiler implements the standard, all feature tests would yield true. If it doesn't there is no reason to assume that it follows the standard in terms of the feature tests!

Thus, using some sort of configuration file seems to be the most reliable approach. Personally, I would do it differently than explicitly checking for compiler versions: instead, I would use something trying whether a compiler supports a specific feature to an acceptable degree. The configuration could be run in terms of autoconf or something similar.

With respect to the resulting configuration I would try to map things to suitable constructs and not use conditional compilation outside the configuration headers. For example, I would use something like this:

#if defined(KUHL_HAS_CLASS_FINAL)
#  define kuhl_class_final final
#else
#  define kuhl_class_final
#endif

Specifically for class enums you might need to use something a bit tricky because the enumeration values will only be available within a scope while the values are only available outside a scope. Thus, it may be necessaray to come up with some form of extra nesting in one case but not the other.

Upvotes: 3

Nicol Bolas
Nicol Bolas

Reputation: 474046

Boost actually has a wide range of such macros available. You could use that. Otherwise, the only way is to essentially check the compiler's version and use your knowledge of the features supported in that version to decide if a feature is available or not.

Essentially, what Boost does, except manually.

Upvotes: 4

mitchnull
mitchnull

Reputation: 6331

clang has some built-in macros for various feature checks: clang feature-check macros Would be nice if all compiler vendors would pick up these (and more).

Upvotes: 1

Related Questions