1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702 |
- [/
- Boost.Config
- Copyright (c) 2001 Beman Dawes
- Copyright (c) 2001 Vesa Karvonen
- Copyright (c) 2001 John Maddock
- Distributed under the Boost Software License, Version 1.0.
- (See accompanying file LICENSE_1_0.txt or copy at
- http://www.boost.org/LICENSE_1_0.txt)
- ]
- [section Boost Macro Reference]
- [#config_defects]
- [section Macros that describe C++03 defects]
- The following macros all describe features that are required by the C++03 standard,
- if one of the following macros is defined, then it represents a defect in the
- compiler's conformance with the 2003 standard.
- [table
- [[Macro ][Section ][ Description ]]
- [[`BOOST_BCB_PARTIAL_SPECIALIZATION_BUG`][Compiler][
- The compiler exhibits certain partial specialisation bug - probably Borland
- C++ Builder specific.
- ]]
- [[`BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL`][Compiler][
- Argument dependent lookup fails if there is a using declaration for the
- symbol being looked up in the current scope. For example, using
- `boost::get_pointer`; prevents ADL from finding overloads of `get_pointer`
- in namespaces nested inside boost (but not elsewhere). Probably
- Borland specific.
- ]]
- [[`BOOST_NO_ADL_BARRIER`][Compiler][
- The compiler locates and searches namespaces that it should /*not*/ in fact
- search when performing argument dependent lookup.
- ]]
- [[`BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP`][Compiler][
- Compiler does not implement argument-dependent lookup (also named
- Koenig lookup); see std::3.4.2 \[basic.koenig.lookup\]
- ]]
- [[`BOOST_NO_AUTO_PTR`][Standard library][
- If the compiler / library supplies non-standard or broken `std::auto_ptr`.
- ]]
- [[`BOOST_NO_COMPLETE_VALUE_INITIALIZATION`][Compiler][
- Compiler has not completely implemented value-initialization.
- See also [@../../../utility/value_init.htm#compiler_issues The Utility\/Value Init docs]
- ]]
- [[`BOOST_NO_CTYPE_FUNCTIONS`][Platform][
- The Platform does not provide functions for the character-classifying
- operations `<ctype.h>` and `<cctype>`, only macros.
- ]]
- [[`BOOST_NO_CV_SPECIALIZATIONS`][Compiler][
- If template specialisations for cv-qualified types conflict with a
- specialisation for a cv-unqualififed type.
- ]]
- [[`BOOST_NO_CV_VOID_SPECIALIZATIONS`][Compiler][
- If template specialisations for cv-void types conflict with a specialisation
- for void.
- ]]
- [[`BOOST_NO_CWCHAR`][Platform][
- The Platform does not provide `<wchar.h>` and `<cwchar>`.
- ]]
- [[`BOOST_NO_CWCTYPE`][Platform][
- The Platform does not provide `<wctype.h>` and `<cwctype>`.
- ]]
- [[`BOOST_NO_FENV_H`][Platform, Standard library][
- The C standard library doesn't provide `<fenv.h>`. [@../../../../boost/detail/fenv.hpp
- `<boost/detail/fenv.hpp>`] should be included instead of `<fenv.h>` for maximum
- portability on platforms which do provide `<fenv.h>`.
- ]]
- [[`BOOST_NO_DEPENDENT_NESTED_DERIVATIONS`][Compiler][
- The compiler fails to compile a nested class that has a dependent base class:
- ``
- template<typename T>
- struct foo : {
- template<typename U>
- struct bar : public U {};
- ``
- };
- ]]
- [[`BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS`][Compiler][
- Template value parameters cannot have a dependent type, for example:
- ``
- template<class T, typename T::type value>
- class X { ... };
- ``
- ]]
- [[`BOOST_NO_EXCEPTION_STD_NAMESPACE`][Standard Library][
- The standard library does not put some or all of the contents of
- `<exception>` in namespace std.
- ]]
- [[`BOOST_NO_EXCEPTIONS`][Compiler][
- The compiler does not support exception handling (this setting is typically
- required by many C++ compilers for embedded platforms). Note that there is
- no requirement for boost libraries to honor this configuration setting -
- indeed doing so may be impossible in some cases. Those libraries that do
- honor this will typically abort if a critical error occurs - you have been
- warned!
- ]]
- [[`BOOST_NO_FUNCTION_TEMPLATE_ORDERING`][Compiler][
- The compiler does not perform function template ordering or its function
- template ordering is incorrect.
- ``
- // #1
- template<class T> void f(T);
- // #2
- template<class T,class U> void f(T(*)(U));
- void bar(int);
- f(&bar); // should choose #2.
- ``
- ]]
- [[`BOOST_NO_INCLASS_MEMBER_INITIALIZATION`][Compiler][
- Compiler violates std::9.4.2/4.
- ]]
- [[`BOOST_NO_INTRINSIC_WCHAR_T`][Compiler][
- The C++ implementation does not provide `wchar_t`, or it is really a synonym
- for another integral type. Use this symbol to decide whether it is appropriate
- to explicitly specialize a template on `wchar_t` if there is already a
- specialization for other integer types.
- ]]
- [[`BOOST_NO_IOSFWD`][std lib][
- The standard library lacks `<iosfwd>`.
- ]]
- [[`BOOST_NO_IOSTREAM`][std lib][
- The standard library lacks `<iostream>`, `<istream>` or `<ostream>`.
- ]]
- [[`BOOST_NO_IS_ABSTRACT`][Compiler][
- The C++ compiler does not support SFINAE with abstract types, this is covered
- by __CORE_LANGUAGE_DR337__, but is not part of the current standard. Fortunately
- most compilers that support SFINAE also support this DR. See also BOOST_NO_SFINAE and BOOST_NO_SFINAE_EXPR
- ]]
- [[`BOOST_NO_LIMITS`][Standard library][
- The C++ implementation does not provide the `<limits>` header. Never check for
- this symbol in library code; always include `<boost/limits.hpp>`, which
- guarantees to provide `std::numeric_limits`.
- ]]
- [[`BOOST_NO_CXX11_NUMERIC_LIMITS`][Standard library][
- C++11 additions to `std::numeric_limits` are not available for use.
- `static function numeric_limits<T>::lowest()` the lowest finite value representable by the numeric type.
- `static int const max_digits10` the number of decimal digits that are required to make sure that two distinct values of the type have distinct decimal representations.
- `template<> class numeric_limits<char16_t>;`, see also `BOOST_NO_CXX11_CHAR16_T`,
- `template<> class numeric_limits<char32_t>;` see also `BOOST_NO_CXX11_CHAR32_T`.
- Replaces BOOST_NO_NUMERIC_LIMITS_LOWEST.
- ]]
- [[`BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS`][Standard library][
- Constants such as `numeric_limits<T>::is_signed` are not available for use
- at compile-time.
- ]]
- [[`BOOST_NO_LONG_LONG_NUMERIC_LIMITS`][Standard library][
- There is no specialization for `numeric_limits<long long>` and
- `numeric_limits<unsigned long long>`. `<boost/limits.hpp>` will then add these
- specializations as a standard library "fix" only if the compiler supports the
- `long long` datatype.
- ]]
- [[`BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS`][Compiler][
- The compiler does not support the specialization of individual member
- functions of template classes.
- ]]
- [[`BOOST_NO_MEMBER_TEMPLATE_KEYWORD`][Compiler][
- If the compiler supports member templates, but not the template keyword
- when accessing member template classes.
- ]]
- [[`BOOST_NO_MEMBER_TEMPLATE_FRIENDS`][Compiler][
- Member template friend syntax (`template<class P> friend class frd;`)
- described in the C++ Standard, 14.5.3, not supported.
- ]]
- [[`BOOST_NO_MEMBER_TEMPLATES`][Compiler][
- Member template functions not fully supported.
- ]]
- [[`BOOST_NO_MS_INT64_NUMERIC_LIMITS`][Standard library][
- There is no specialization for `numeric_limits<__int64>` and
- `numeric_limits<unsigned __int64>`. `<boost/limits.hpp>` will then add these
- specializations as a standard library "fix", only if the compiler supports
- the `__int64` datatype.
- ]]
- [[`BOOST_NO_NESTED_FRIENDSHIP`][Compiler][
- Compiler doesn't allow a nested class to access private members of its
- containing class. Probably Borland/CodeGear specific.
- ]]
- [[`BOOST_NO_OPERATORS_IN_NAMESPACE`][Compiler][
- Compiler requires inherited operator friend functions to be defined at
- namespace scope, then using'ed to boost. Probably GCC specific. See
- [@../../../../boost/operators.hpp `<boost/operators.hpp>`] for example.
- ]]
- [[`BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS`][Compiler][
- The compiler does not correctly handle partial specializations
- which depend upon default arguments in the primary template.
- ]]
- [[`BOOST_NO_POINTER_TO_MEMBER_CONST`][Compiler][
- The compiler does not correctly handle pointers to const member functions,
- preventing use of these in overloaded function templates. See
- [@../../../../boost/functional.hpp `<boost/functional.hpp>`] for example.
- ]]
- [[`BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS`][Compiler][
- Pointers to members don't work when used as template parameters.
- ]]
- [[`BOOST_NO_PRIVATE_IN_AGGREGATE`][Compiler][
- The compiler misreads 8.5.1, treating classes as non-aggregate if they
- contain private or protected member functions.
- ]]
- [[`BOOST_NO_RESTRICT_REFERENCES`][Compiler][
- Compiler-specific `restrict` keyword can not be applied to references.
- ]]
- [[`BOOST_NO_RTTI`][Compiler][
- The compiler may (or may not) have the typeid operator, but RTTI on the dynamic type
- of an object is not supported.
- ]]
- [[`BOOST_NO_SFINAE`][Compiler][
- The compiler does not support the "Substitution Failure Is Not An Error"
- meta-programming idiom. This is the lightweight pre-C++11 version of SFINAE.
- ]]
- [[`BOOST_NO_SFINAE_EXPR`][Compiler][
- The compiler does not support usage of SFINAE with arbitrary expressions. This is the
- post-C++11 SFINAE, but excludes a few specific corner cases, see also BOOST_NO_CXX11_SFINAE_EXPR.
- ]]
- [[`BOOST_NO_STD_ALLOCATOR`][Standard library][
- The C++ standard library does not provide a standards conforming
- `std::allocator`.
- ]]
- [[`BOOST_NO_STD_DISTANCE`][Standard library][
- The platform does not have a conforming version of `std::distance`.
- ]]
- [[`BOOST_NO_STD_ITERATOR`][Standard library][
- The C++ implementation fails to provide the `std::iterator` class.
- Note that post C++17, this macro is re-purposed to indicate that std::iterator has been removed or deprecated.
- ]]
- [[`BOOST_NO_STD_ITERATOR_TRAITS`][Standard library][
- The compiler does not provide a standard compliant implementation of
- `std::iterator_traits`. Note that the compiler may still have a
- non-standard implementation.
- ]]
- [[`BOOST_NO_STD_LOCALE`][Standard library][
- The standard library lacks `std::locale`.
- ]]
- [[`BOOST_NO_STD_MESSAGES`][Standard library][
- The standard library lacks a conforming `std::messages` facet.
- ]]
- [[`BOOST_NO_STD_MIN_MAX`][Standard library][
- The C++ standard library does not provide the `min()` and `max()` template
- functions that should be in `<algorithm>`.
- ]]
- [[`BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN`][Standard library][
- Defined if the standard library's output iterators are not assignable.
- ]]
- [[`BOOST_NO_STD_TYPEINFO`][Standard library][
- The <typeinfo> header declares `type_info` in the global namespace instead of namespace std.
- ]]
- [[`BOOST_NO_STD_USE_FACET`][Standard library][
- The standard library lacks a conforming `std::use_facet`.
- ]]
- [[`BOOST_NO_STD_WSTREAMBUF`][Standard library][
- The standard library's implementation of `std::basic_streambuf<wchar_t>`
- is either missing, incomplete, or buggy.
- ]]
- [[`BOOST_NO_STD_WSTRING`][Standard library][
- The standard library lacks `std::wstring`.
- ]]
- [[`BOOST_NO_STDC_NAMESPACE`][Compiler, Platform][
- The contents of C++ standard headers for C library functions
- (the `<c...>` headers) have not been placed in namespace std. This test is
- difficult - some libraries "fake" the std C functions by adding using
- declarations to import them into namespace std, unfortunately they don't
- necessarily catch all of them...
- ]]
- [[`BOOST_NO_STRINGSTREAM`][Standard library][
- The C++ implementation does not provide the `<sstream>` header.
- ]]
- [[`BOOST_NO_SWPRINTF`][Platform][
- The platform does not have a conforming version of `swprintf`.
- ]]
- [[`BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION`][Compiler][
- Class template partial specialization (14.5.4 \[temp.class.spec\]) not
- supported.
- ]]
- [[`BOOST_NO_TEMPLATED_IOSTREAMS`][Standard library][
- The standard library does not provide templated iostream classes.
- ]]
- [[`BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS`][Standard library][
- The standard library does not provide templated iterator constructors
- for its containers.
- ]]
- [[`BOOST_NO_TEMPLATE_TEMPLATES`][Compiler][
- The compiler does not support template template parameters.
- ]]
- [[`BOOST_NO_TYPEID`][Compiler][
- The compiler does not support the typeid operator at all.
- ]]
- [[`BOOST_NO_TYPENAME_WITH_CTOR`][Compiler][
- The typename keyword cannot be used when creating a temporary of a
- Dependent type.
- ]]
- [[`BOOST_NO_UNREACHABLE_RETURN_DETECTION`][Compiler][
- If a return is unreachable, then no return statement should be required,
- however some compilers insist on it, while other issue a bunch of warnings
- if it is in fact present.
- ]]
- [[`BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE`][Compiler][
- The compiler will not accept a using declaration that brings a function
- from a typename used as a base class into a derived class if functions of
- the same name are present in the derived class.
- ]]
- [[`BOOST_NO_USING_TEMPLATE`][Compiler][
- The compiler will not accept a using declaration that imports a template
- class or function from another namespace. Originally a Borland specific
- problem with imports to/from the global namespace, extended to MSVC6
- which has a specific issue with importing template classes (but not
- functions).
- ]]
- [[`BOOST_NO_VOID_RETURNS`][Compiler][
- The compiler does not allow a void function to return the result of calling
- another void function.
- ``
- void f() {}
- void g() { return f(); }
- ``
- ]]
- ]
- [endsect]
- [#config_features]
- [section Macros that describe optional features]
- The following macros describe features that are not required by the C++
- standard. The macro is only defined if the feature is present.
- [table
- [[Macro ][Section ][Description ]]
- [[`BOOST_HAS_BETHREADS`][Platform][
- The platform supports BeOS style threads.
- ]]
- [[`BOOST_HAS_CLOCK_GETTIME`][Platform][
- The platform has the POSIX API `clock_gettime`.
- ]]
- [[`BOOST_HAS_DIRENT_H`][Platform][
- The platform has the POSIX header `<dirent.h>`.
- ]]
- [[`BOOST_HAS_EXPM1`][Platform][
- The platform has the functions `expm1`, `expm1f` and `expm1l` in `<math.h>`
- ]]
- [[`BOOST_HAS_FLOAT128`][Compiler][
- The compiler has `__float128` as a native type which is distinct
- from all the regular C++ floating point types.]]
- [[`BOOST_HAS_FTIME`][Platform][
- The platform has the Win32 API type FTIME.
- ]]
- [[`BOOST_HAS_GETSYSTEMTIMEASFILETIME`][Platform][
- The platform has the Win32 API GetSystemTimeAsFileTime.
- ]]
- [[`BOOST_HAS_GETTIMEOFDAY`][Platform][
- The platform has the POSIX API `gettimeofday`.
- ]]
- [[`BOOST_HAS_HASH`][Standard library][
- The C++ implementation provides the (SGI) hash_set and hash_map classes.
- When defined, `BOOST_HASH_SET_HEADER` and `BOOST_HASH_LIST_HEADER` will contain
- the names of the header needed to access hash_set and hash_map;
- `BOOST_STD_EXTENSION_NAMESPACE` will provide the namespace in which the two
- class templates reside.
- ]]
- [[`BOOST_HAS_INT128`][Compiler][
- The compiler has `__int128` and `unsigned __int128` as native types which are distinct
- from all the regular C++ integer types.]]
- [[`BOOST_HAS_LOG1P`][Platform][
- The platform has the functions `log1p`, `log1pf` and `log1pl` in `<math.h>`.
- ]]
- [[`BOOST_HAS_MACRO_USE_FACET`][Standard library][
- The standard library lacks a conforming `std::use_facet`, but has a macro
- `_USE(loc, Type)` that does the job. This is primarily for the Dinkumware
- std lib.
- ]]
- [[`BOOST_HAS_MS_INT64`][Compiler][
- The compiler supports the `__int64` data type.
- ]]
- [[`BOOST_HAS_NANOSLEEP`][Platform][
- The platform has the POSIX API nanosleep.
- ]]
- [[`BOOST_HAS_NL_TYPES_H`][Platform][
- The platform has an `<nl_types.h>`.
- ]]
- [[`BOOST_HAS_NRVO`][Compiler][
- Indicated that the compiler supports the named return value optimization
- (NRVO). Used to select the most efficient implementation for some function.
- See [@../../../../boost/operators.hpp `<boost/operators.hpp>`] for example.
- ]]
- [[`BOOST_HAS_PARTIAL_STD_ALLOCATOR`][Standard Library][
- The standard library has a partially conforming `std::allocator` class, but
- without any of the member templates.
- ]]
- [[`BOOST_HAS_PRAGMA_ONCE`][Compiler][
- The compiler recognizes the `#pragma once` directive which tells that the
- containing header should be included only once while preprocessing the
- current translation unit. The pragma may improve compile times of large projects
- with some compilers.
- ]]
- [[`BOOST_HAS_PRAGMA_DETECT_MISMATCH`][Compiler][
- The compiler recognizes the `#pragma detect_mismatch("name", "value")` directive which tells that the
- link stage should be terminated with error if values for provided `"name"` missmatch.
- This pragma may be a help in preventing ODR violations and ensuring that different modules
- are compiled with same flags.
- ]]
- [[`BOOST_HAS_PTHREAD_DELAY_NP`][Platform][
- The platform has the POSIX API `pthread_delay_np`.
- ]]
- [[`BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE`][Platform][
- The platform has the POSIX API `pthread_mutexattr_settype`.
- ]]
- [[`BOOST_HAS_PTHREAD_YIELD`][Platform][
- The platform has the POSIX API `pthread_yield`.
- ]]
- [[`BOOST_HAS_PTHREADS`][Platform][
- The platform support POSIX style threads.
- ]]
- [[`BOOST_HAS_SCHED_YIELD`][Platform][
- The platform has the POSIX API `sched_yield`.
- ]]
- [[`BOOST_HAS_SGI_TYPE_TRAITS`][Compiler, Standard library][
- The compiler has native support for SGI style type traits.
- ]]
- [[`BOOST_HAS_STDINT_H`][Platform][
- The platform has a `<stdint.h>`
- ]]
- [[`BOOST_HAS_SLIST`][Standard library][
- The C++ implementation provides the (SGI) slist class. When defined,
- `BOOST_SLIST_HEADER` will contain the name of the header needed to access
- `slist` and `BOOST_STD_EXTENSION_NAMESPACE` will provide the namespace in
- which `slist` resides.
- ]]
- [[`BOOST_HAS_STLP_USE_FACET`][Standard library][
- The standard library lacks a conforming `std::use_facet`, but has a workaround
- class-version that does the job. This is primarily for the STLport std lib.
- ]]
- [[`BOOST_HAS_TR1_ARRAY`][Standard library][
- The library has a TR1 conforming version of `<array>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_ARRAY.
- ]]
- [[`BOOST_HAS_TR1_COMPLEX_OVERLOADS`][Standard library][
- The library has a version of `<complex>` that supports passing scalars to the
- complex number algorithms.
- ]]
- [[`BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG`][Standard library][
- The library has a version of `<complex>` that includes the new inverse trig
- functions from TR1.
- ]]
- [[`BOOST_HAS_TR1_REFERENCE_WRAPPER`][Standard library][
- The library has TR1 conforming reference wrappers in `<functional>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_FUNCTIONAL.
- ]]
- [[`BOOST_HAS_TR1_RESULT_OF`][Standard library][
- The library has a TR1 conforming result_of template in `<functional>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_FUNCTIONAL.
- ]]
- [[`BOOST_HAS_TR1_MEM_FN`][Standard library][
- The library has a TR1 conforming mem_fn function template in `<functional>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_FUNCTIONAL.
- ]]
- [[`BOOST_HAS_TR1_BIND`][Standard library][
- The library has a TR1 conforming bind function template in `<functional>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_FUNCTIONAL.
- ]]
- [[`BOOST_HAS_TR1_FUNCTION`][Standard library][
- The library has a TR1 conforming function class template in `<functional>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_FUNCTIONAL.
- ]]
- [[`BOOST_HAS_TR1_HASH`][Standard library][
- The library has a TR1 conforming hash function template in `<functional>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_FUNCTIONAL.
- ]]
- [[`BOOST_HAS_TR1_SHARED_PTR`][Standard library][
- The library has a TR1 conforming `shared_ptr` class template in `<memory>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_SMART_PTR.
- ]]
- [[`BOOST_HAS_TR1_RANDOM`][Standard library][
- The library has a TR1 conforming version of `<random>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_RANDOM.
- ]]
- [[`BOOST_HAS_TR1_REGEX`][Standard library][
- The library has a TR1 conforming version of `<regex>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_REGEX.
- ]]
- [[`BOOST_HAS_TR1_TUPLE`][Standard library][
- The library has a TR1 conforming version of `<tuple>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_TUPLE.
- ]]
- [[`BOOST_HAS_TR1_TYPE_TRAITS`][Standard library][
- The library has a TR1 conforming version of `<type_traits>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_TYPE_TRAITS.
- ]]
- [[`BOOST_HAS_TR1_UTILITY`][Standard library][
- The library has the TR1 additions to `<utility>` (tuple interface to `std::pair`). This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_TUPLE.
- ]]
- [[`BOOST_HAS_TR1_UNORDERED_MAP`][Standard library][
- The library has a TR1 conforming version of `<unordered_map>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_UNORDERED_MAP.
- ]]
- [[`BOOST_HAS_TR1_UNORDERED_SET`][Standard library][
- The library has a TR1 conforming version of `<unordered_set>`. This macro is only guaranteed
- to be defined after including one of the headers from Boost.TR1. Further this macro
- is now deprecated in favour of BOOST_NO_CXX11_HDR_UNORDERED_SET.
- ]]
- [[`BOOST_HAS_TR1`][Standard library][
- Implies all the other `BOOST_HAS_TR1_*` macros should be set.
- ]]
- [[`BOOST_HAS_THREADS`][Platform, Compiler][
- Defined if the compiler, in its current translation mode, supports multiple
- threads of execution.
- ]]
- [[`BOOST_HAS_TWO_ARG_USE_FACET`][Standard library][
- The standard library lacks a conforming std::use_facet, but has a two
- argument version that does the job. This is primarily for the Rogue Wave
- std lib.
- ]]
- [[`BOOST_HAS_UNISTD_H`][Platform][
- The Platform provides `<unistd.h>`.
- ]]
- [[`BOOST_HAS_WINTHREADS`][Platform][
- The platform supports MS Windows style threads.
- ]]
- [[`BOOST_MSVC_STD_ITERATOR`][Standard library][
- Microsoft's broken version of `std::iterator` is being used. This implies that
- `std::iterator` takes no more than two template parameters.
- ]]
- [[`BOOST_MSVC6_MEMBER_TEMPLATES`][Compiler][
- Microsoft Visual C++ 6.0 has enough member template idiosyncrasies
- (being polite) that `BOOST_NO_MEMBER_TEMPLATES` is defined for this compiler.
- `BOOST_MSVC6_MEMBER_TEMPLATES` is defined to allow compiler specific workarounds.
- This macro gets defined automatically if `BOOST_NO_MEMBER_TEMPLATES` is not
- defined - in other words this is treated as a strict subset of the features
- required by the standard.
- ]]
- [[`BOOST_HAS_STDINT_H`][Platform][
- There are no 1998 C++ Standard headers `<stdint.h>` or `<cstdint>`, although the
- 1999 C Standard does include `<stdint.h>`. If `<stdint.h>` is present,
- `<boost/stdint.h>` can make good use of it, so a flag is supplied (signalling
- presence; thus the default is not present, conforming to the current C++
- standard).
- ]]
- ]
- [endsect]
- [section Macros that describe possible C++ future features]
- The following macros describe features that may be included in some future
- ISO C++ standard, but have not yet been approved for inclusion in the language.
- [table
- [[Macro ][Description ]]
- [[`BOOST_HAS_CONCEPTS`][
- The compiler supports concepts.
- ]]
- ]
- [endsect]
- [section Macros that describe C++11 features not supported]
- The following macros describe features in the 2011 ISO C++ standard, formerly known as C++0x,
- that are not yet supported by a particular compiler or library.
- [table
- [[Macro ][Description ]]
- [[`BOOST_NO_CXX11_ADDRESSOF`][The standard library header <memory> has no working std::addressof.]]
- [[`BOOST_NO_CXX11_ALIGNAS`][The compiler does not support the `alignas` keyword.]]
- [[`BOOST_NO_CXX11_ALLOCATOR`][The standard library does not provide a C++11 version of `std::allocator` in <memory>.]]
- [[`BOOST_NO_CXX11_ATOMIC_SMART_PTR`][The standard library <memory> does not support atomic smart pointer operations.]]
- [[`BOOST_NO_CXX11_AUTO_DECLARATIONS`][The compiler does not support
- type deduction for variables declared with the `auto` keyword (`auto var = ...;`).
- ]]
- [[`BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS`][The compiler does not support
- type deduction for multiple variables declared with the `auto` keyword (`auto var = ..., *ptr = ...;`).
- ]]
- [[`BOOST_NO_CXX11_CHAR16_T`][The compiler does not support
- type `char16_t`.
- ]]
- [[`BOOST_NO_CXX11_CHAR32_T`][The compiler does not support
- type `char32_t`.
- ]]
- [[`BOOST_NO_CXX11_CONSTEXPR`][The compiler does not support
- `constexpr`.
- ]]
- [[`BOOST_NO_CXX11_DECLTYPE`][The compiler does not support
- `decltype`.
- ]]
- [[`BOOST_NO_CXX11_DECLTYPE_N3276`][The compiler does not support the extension to
- `decltype` described in [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf N3276],
- accepted in Madrid, March 2011.
- ]]
- [[`BOOST_NO_CXX11_DELETED_FUNCTIONS`][The compiler does not support
- deleted (`= delete`) functions.
- ]]
- [[`BOOST_NO_CXX11_DEFAULTED_FUNCTIONS`][The compiler does not support
- defaulted (`= default`) functions.
- ]]
- [[`BOOST_NO_CXX11_DEFAULTED_MOVES`][The compiler does not support
- defaulted move constructor or assignment. Other defaulted functions may still be supported.
- ]]
- [[`BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS`][The compiler does not support
- explicit conversion operators (`explicit operator T()`).
- ]]
- [[`BOOST_NO_CXX11_EXTERN_TEMPLATE`][The compiler does not support
- explicit instantiation forward declarations for templates (`extern template ...`).
- ]]
- [[`BOOST_NO_CXX11_FINAL`][The compiler does not support the C++ class-virt-specifier final.
- ]]
- [[`BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS`][The compiler does not support
- expanding a variadic template parameter pack into a template containing one or more
- fixed arguments]]
- [[`BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS`][The compiler does not support
- default template arguments for function templates.
- ]]
- [[`BOOST_NO_CXX11_HDR_ATOMIC`][The standard library does not provide header <atomic>.]]
- [[`BOOST_NO_CXX11_HDR_ARRAY`][The standard library does not provide header <array>.]]
- [[`BOOST_NO_CXX11_HDR_CHRONO`][The standard library does not provide header <chrono>.]]
- [[`BOOST_NO_CXX11_HDR_CODECVT`][The standard library does not provide header <codecvt>.]]
- [[`BOOST_NO_CXX11_HDR_CONDITION_VARIABLE`][The standard library does not provide header <condition_variable>.]]
- [[`BOOST_NO_CXX11_HDR_EXCEPTION`][The standard library does not provide a C++11 compatible version of <exception>.]]
- [[`BOOST_NO_CXX11_HDR_FORWARD_LIST`][The standard library does not provide header <forward_list>.]]
- [[`BOOST_NO_CXX11_HDR_FUNCTIONAL`][The standard library does not provide a C++11 compatible version of <functional>.]]
- [[`BOOST_NO_CXX11_HDR_FUTURE`][The standard library does not provide header <future>.]]
- [[`BOOST_NO_CXX11_HDR_INITIALIZER_LIST`][The standard library does not provide header <initializer_list>.]]
- [[`BOOST_NO_CXX11_HDR_MUTEX`][The standard library does not provide header <mutex>.]]
- [[`BOOST_NO_CXX11_HDR_RANDOM`][The standard library does not provide header <random>.]]
- [[`BOOST_NO_CXX11_HDR_RATIO`][The standard library does not provide header <ratio>.]]
- [[`BOOST_NO_CXX11_HDR_REGEX`][The standard library does not provide header <regex>.]]
- [[`BOOST_NO_CXX11_HDR_SYSTEM_ERROR`][The standard library does not provide header <system_error>.]]
- [[`BOOST_NO_CXX11_HDR_THREAD`][The standard library does not provide header <thread>.]]
- [[`BOOST_NO_CXX11_HDR_TUPLE`][The standard library does not provide header <tuple>.]]
- [[`BOOST_NO_CXX11_HDR_TYPEINDEX`][The standard library does not provide header <typeindex>.]]
- [[`BOOST_NO_CXX11_HDR_TYPE_TRAITS`][The standard library does not provide header <type_traits>.]]
- [[`BOOST_NO_CXX11_HDR_UNORDERED_MAP`][The standard library does not provide header <unordered_map>.]]
- [[`BOOST_NO_CXX11_HDR_UNORDERED_SET`][The standard library does not provide header <unordered_set>.]]
- [[`BOOST_NO_CXX11_INLINE_NAMESPACES`][The compiler does not support inline namespaces.]]
- [[`BOOST_NO_CXX11_LAMBDAS`][The compiler does not support Lambdas.
- ]]
- [[`BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS`][The compiler does not allow to
- pass local classes as template parameters (this macro intentionally does not
- control passing of unnamed types as template parameters, see also
- [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm N2657]).
- ]]
- [[`BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS`][The compiler does not support
- defaulted (`= default`) functions in access control sections other than `public`. Public defaulted
- functions may still be supported, as indicated by `BOOST_NO_CXX11_DEFAULTED_FUNCTIONS`. Some
- compilers implementing an early draft of the C++11 standard (in particular, incorporating
- [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#906 DR906]) are susceptible to this problem.
- ]]
- [[`BOOST_NO_CXX11_NOEXCEPT`][The compiler does not support `noexcept`.
- ]]
- [[`BOOST_NO_CXX11_NULLPTR`][The compiler does not support `nullptr`.
- ]]
- [[`BOOST_NO_CXX11_NUMERIC_LIMITS`][The standard library `<limits>` header does
- not support the C++11 version of `numeric_limits`.
- ]]
- [[`BOOST_NO_CXX11_POINTER_TRAITS`][The standard library does not provide a
- C++11 version of `std::pointer_traits` in <memory>.]]
- [[`BOOST_NO_CXX11_RANGE_BASED_FOR`][The compiler does not support
- range-based for statements.
- ]]
- [[`BOOST_NO_CXX11_RAW_LITERALS`][The compiler does not support
- raw string literals.
- ]]
- [[`BOOST_NO_CXX11_REF_QUALIFIERS`][The compiler does not support
- ref-qualifiers on member functions as described in
- [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm N2439].
- ]]
- [[`BOOST_NO_CXX11_RVALUE_REFERENCES`][The compiler does not support
- r-value references.
- ]]
- [[`BOOST_NO_CXX11_SCOPED_ENUMS`][The compiler does not support
- scoped enumerations (`enum class`).
- ]]
- [[`BOOST_NO_CXX11_SFINAE_EXPR`][The compiler does not support
- usage of C++11 SFINAE with arbitrary expressions. Use this macro only if you
- are using all of the features of SFINAE including substitution-failure-on-private-member-access.
- Otherwise use BOOST_NO_SFINAE_EXPR or BOOST_NO_SFINAE which get defined for fewer compilers.
- ]]
- [[`BOOST_NO_CXX11_SMART_PTR`][The standard library header <memory> has no shared_ptr and unique_ptr.]]
- [[`BOOST_NO_CXX11_STATIC_ASSERT`][The compiler does not support
- `static_assert`.
- ]]
- [[`BOOST_NO_CXX11_STD_ALIGN`][The standard library header <memory> has no working std::align.]]
- [[`BOOST_NO_CXX11_STD_UNORDERED`][The standard library does not support
- <unordered_map> and <unordered_set>.
- ]]
- [[`BOOST_NO_CXX11_TEMPLATE_ALIASES`][The compiler does not support template aliases.
- ]]
- [[`BOOST_NO_CXX11_THREAD_LOCAL`][The compiler does not support the `thread_local` storage specifier.
- ]]
- [[`BOOST_NO_CXX11_TRAILING_RESULT_TYPES`][The compiler does not support the new function result type
- specification syntax (e.g. `auto foo(T) -> T;`).]]
- [[`BOOST_NO_CXX11_UNICODE_LITERALS`][The compiler does not support
- Unicode (`u8`, `u`, `U`) literals.
- ]]
- [[`BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX`][The compiler does not support
- the [@http://en.wikipedia.org/wiki/C%2B%2B0x#Uniform_initialization C++11 Unified Initialization Syntax].
- ]]
- [[`BOOST_NO_CXX11_USER_DEFINED_LITERALS`][The compiler does not support user defined literals.
- ]]
- [[`BOOST_NO_CXX11_VARIADIC_TEMPLATES`][The compiler does not support
- variadic templates.
- ]]
- [[`BOOST_NO_CXX11_VARIADIC_MACROS`][The compiler does not support
- variadic macros.
- ]]
- [[`BOOST_NO_LONG_LONG`][The compiler does not support `long long`.
- ]]
- ]
- [endsect]
- [#config_11_for_03]
- [section Macros that allow use of C++11 features with C++03 compilers]
- The following macros allow use of C++11 features even with compilers that do not yet
- provide compliant C++11 support.
- [table
- [[Macro ][ Description ]]
- [[`BOOST_ALIGNMENT(X)`, `BOOST_NO_ALIGNMENT`][
- Some compilers don't support the `alignas` keyword but provide other means to specify alignment
- (usually, through compiler-specific attributes). The macro `BOOST_ALIGNMENT(X)` will expand to the `alignas(X)`
- keyword if the compiler supports it or to some compiler-specific attribute to achieve the specified alignment.
- If no such compiler-specific attribute is known then `BOOST_ALIGNMENT(X)` will expand to nothing and
- `BOOST_NO_ALIGNMENT` will be defined. Unlike native `alignas`, `X` must always be a compile-time integer constant.
- The macro can be used to specify alignment of types and data:
- ``
- struct BOOST_ALIGNMENT(16) my_data
- {
- char c[16];
- };
- BOOST_ALIGNMENT(8) int arr[32];
- ``
- ]]
- [[`BOOST_CONSTEXPR`][
- Some compilers don't support the use of `constexpr`. This macro expands to nothing on those compilers, and `constexpr`
- elsewhere. For example, when defining a constexpr function or constructor replace:
- ``
- constexpr tuple();
- ``
- with:
- ``
- BOOST_CONSTEXPR tuple();
- ``
- ]]
- [[`BOOST_CONSTEXPR_OR_CONST`][
- Some compilers don't support the use of `constexpr`. This macro expands to `const` on those compilers, and `constexpr`
- elsewhere. For example, when defining const expr variables replace:
- ``
- static constexpr UIntType xor_mask = a;
- ``
- with:
- ``
- static BOOST_CONSTEXPR_OR_CONST UIntType xor_mask = a;
- ``
- ]]
- [[`BOOST_STATIC_CONSTEXPR`][
- This is a shortcut for `static BOOST_CONSTEXPR_OR_CONST`. For example, when defining const expr variables replace:
- ``
- static constexpr UIntType xor_mask = a;
- ``
- with:
- ``
- BOOST_STATIC_CONSTEXPR UIntType xor_mask = a;
- ``
- ]]
- [[`BOOST_DEFAULTED_FUNCTION(fun, body)`][
- This macro is intended to be used within a class definition in order to declare a default implementation of function `fun`.
- For the compilers that do not support C++11 defaulted functions the macro will expand into an inline function definition
- with the `body` implementation. For example:
- ``
- struct my_struct
- {
- BOOST_DEFAULTED_FUNCTION(my_struct(), {})
- };
- ``
- is equivalent to:
- ``
- struct my_struct
- {
- my_struct() = default;
- };
- ``
- or:
- ``
- struct my_struct
- {
- my_struct() {}
- };
- ``
- ]]
- [[`BOOST_DELETED_FUNCTION(fun)`][
- This macro is intended to be used within a class definition in order to declare a deleted function `fun`.
- For the compilers that do not support C++11 deleted functions the macro will expand into a private function
- declaration with no definition. Since the macro may change the access mode, it is recommended to use this macro
- at the end of the class definition. For example:
- ``
- struct noncopyable
- {
- BOOST_DELETED_FUNCTION(noncopyable(noncopyable const&))
- BOOST_DELETED_FUNCTION(noncopyable& operator= (noncopyable const&))
- };
- ``
- is equivalent to:
- ``
- struct noncopyable
- {
- noncopyable(noncopyable const&) = delete;
- noncopyable& operator= (noncopyable const&) = delete;
- };
- ``
- or:
- ``
- struct noncopyable
- {
- private:
- noncopyable(noncopyable const&);
- noncopyable& operator= (noncopyable const&);
- };
- ``
- ]]
- [[
- ``
- BOOST_NOEXCEPT
- BOOST_NOEXCEPT_OR_NOTHROW
- BOOST_NOEXCEPT_IF(Predicate)
- BOOST_NOEXCEPT_EXPR(Expression)
- ``
- ][
- If `BOOST_NO_CXX11_NOEXCEPT` is defined (i.e. C++03 compliant compilers) these macros are defined as:
- [:
- ``
- #define BOOST_NOEXCEPT
- #define BOOST_NOEXCEPT_OR_NOTHROW throw()
- #define BOOST_NOEXCEPT_IF(Predicate)
- #define BOOST_NOEXCEPT_EXPR(Expression) false
- ``
- ]
- If `BOOST_NO_CXX11_NOEXCEPT` is not defined (i.e. C++11 compliant compilers) they are defined as:
- [:
- ``
- #define BOOST_NOEXCEPT noexcept
- #define BOOST_NOEXCEPT_OR_NOTHROW noexcept
- #define BOOST_NOEXCEPT_IF(Predicate) noexcept((Predicate))
- #define BOOST_NOEXCEPT_EXPR(Expression) noexcept((Expression))
- ``
- ]
- ]]
- [[`BOOST_FINAL`][
- If `BOOST_NO_CXX11_FINAL` is not defined (i.e. C++11 compliant compilers), expands to `final` keyword,
- otherwise expands to nothing.
- ]]
- [[`BOOST_MSVC_ENABLE_2012_NOV_CTP`][
- For Microsoft Visual C++ 2012, enable the C++11 features supplied by the
- November 2012 Community Technology Preview. These features are not automatically
- enabled because the CTP is non-supported alpha code that is not recommended
- for production use. This macro must be defined before including any Boost headers,
- and must be defined for all translation units in the program, including Boost library builds.
- This macro will no longer have any effect once an official Microsoft
- release supports the CTP features.
- ]]
- ]
- [endsect]
- [section Macros that describe C++14 features not supported]
- The following macros describe features in the 2014 ISO C++ standard, formerly known as C++0y,
- that are not yet supported by a particular compiler or library.
- [table
- [[Macro ][Description ]]
- [[`BOOST_NO_CXX14_AGGREGATE_NSDMI`][The compiler does not support member initializer for aggregates as in the following example:
- [:
- ``
- struct Foo
- {
- int x, y = 42;
- };
- Foo foo = { 0 };
- ``
- ]
- ]]
- [[`BOOST_NO_CXX14_BINARY_LITERALS`][The compiler does not binary literals (e.g. `0b1010`).]]
- [[`BOOST_NO_CXX14_CONSTEXPR`][The compiler does not support relaxed `constexpr`.]]
- [[`BOOST_NO_CXX14_DECLTYPE_AUTO`][The compiler does not support `decltype(auto)`.]]
- [[`BOOST_NO_CXX14_DIGIT_SEPARATORS`][The compiler does not support digit separators (e.g. `1'000'000`).]]
- [[`BOOST_NO_CXX14_STD_EXCHANGE`][The compiler does not support `std::exchange()`.]]
- [[`BOOST_NO_CXX14_GENERIC_LAMBDAS`][The compiler does not support generic lambda (e.g. `[](auto v){ }`).]]
- [[`BOOST_NO_CXX14_HDR_SHARED_MUTEX`][The standard library does not provide header <shared_mutex>.]]
- [[`BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES`][The compiler does not support initialized lambda capture (e.g. `[foo = 42]{ }`).]]
- [[`BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION`][The compiler does not support return type deduction for normal functions (e.g. `auto f() { return val; }`).]]
- [[`BOOST_NO_CXX14_VARIABLE_TEMPLATES`][The compiler does not support variable template (e.g. `template <class T> T kibi = T(1024);`).]]
- ]
- [endsect]
- [#config_14_for_11]
- [section Macros that allow use of C++14 features with C++11 or earlier compilers]
- The following macros allow use of C++14 features even with compilers that do not yet
- provide compliant C++14 support.
- [table
- [[Macro ][ Description ]]
- [[`BOOST_CXX14_CONSTEXPR`][This macro works similar to `BOOST_CONSTEXPR`, but expands to `constexpr` only if the C++14 "relaxed" `constexpr` is available.]]
- ]
- [endsect]
- [section Macros that describe C++17 features not supported]
- The following macros describe features in the 2017 ISO C++ standard, formerly known as C++1z,
- that are not yet supported by a particular compiler or library.
- [table
- [[Macro ][Description ]]
- [[`BOOST_NO_CXX17_HDR_OPTIONAL`][The compiler does not support the header `<optional>`.]]
- [[`BOOST_NO_CXX17_HDR_VARIANT`][The compiler does not support the header `<variant>`.]]
- [[`BOOST_NO_CXX17_HDR_STRING_VIEW`][The compiler does not support the header `<string_view>`.]]
- [[`BOOST_NO_CXX17_STD_APPLY`][The compiler does not support `std::apply()`.]]
- [[`BOOST_NO_CXX17_STD_INVOKE`][The compiler does not support `std::invoke()`.]]
- [[`BOOST_NO_CXX17_ITERATOR_TRAITS`][The compiler does not support SFINAE-friendly `std::iterator_traits`.]]
- [[`BOOST_NO_CXX17_IF_CONSTEXPR`][The compiler does not support `if constexpr`.]]
- [[`BOOST_NO_CXX17_INLINE_VARIABLES`][The compiler does not support `inline` variables.]]
- ]
- [endsect]
- [#config_17_for_14]
- [section Macros that allow use of C++17 features with C++14 or earlier compilers]
- The following macros allow use of C++17 features even with compilers that do not yet
- provide compliant C++17 support.
- [table
- [[Macro ][ Description ]]
- [[`BOOST_INLINE_VARIABLE`][This macro expands to `inline` on compilers that support C++17 inline variables and to nothing otherwise. Users may need to check for `BOOST_NO_CXX17_INLINE_VARIABLES` for further adjustments to the code.]]
- ]
- [endsect]
- [section Macros that describe features that have been removed from the standard.]
- The following macros describe features which were required by one version of the standard, but have been removed by later versions.
- [table
- [[Macro ][Description ]]
- [[`BOOST_NO_CXX98_RANDOM_SHUFFLE`][The standard library no longer supports `std::random_shuffle()`. It was deprecated in C++11 and is removed from C++14.]]
- [[`BOOST_NO_AUTO_PTR`][The standard library no longer supports `std::auto_ptr`. It was deprecated in C++11 and is removed from C++14.]]
- [[`BOOST_NO_CXX98_FUNCTION_BASE`][The standard library no longer supports `std::unary_function` and `std::binary_function`. They were deprecated in C++11 and is removed from C++14.]]
- [[`BOOST_NO_CXX98_BINDERS`][The standard library no longer supports `std::bind1st`, `std::bind2nd`, `std::ptr_fun` and `std::mem_fun`. They were deprecated in C++11 and is removed from C++14.]]
- ]
- [endsect]
- [#config_helpers]
- [section Boost Helper Macros]
- The following macros are either simple helpers, or macros that provide
- workarounds for compiler/standard library defects.
- [table
- [[Macro ][Description ]]
- [[`BOOST_WORKAROUND`][
- This macro is used where a compiler specific workaround is required that is not otherwise
- described by one of the other Boost.Config macros. To use the macro you must first
- ``
- #include <boost/config/workaround.hpp>
- ``
- usage is then:
- ``
- #if BOOST_WORKAROUND(MACRONAME, CONDITION)
- // workaround code goes here...
- #else
- // Standard conforming code goes here...
- #endif
- ``
- where `MACRONAME` is a macro that usually describes the version number to be tested against, and `CONDITION`
- is a comparison operator followed by a value. For example `BOOST_WORKAROUND(BOOST_INTEL, <= 1010)` would
- evaluate to `1` for Intel C++ 10.1 and earlier.
- The macro can also be used with `BOOST_TESTED_AT` if all
- current compiler versions exhibit the issue, but the issue is expected to be fixed at some later point.
- For example
- `BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x590))` would normally evaluate to `1` for all values
- of `__BORLANDC__` /unless/ the macro `BOOST_DETECT_OUTDATED_WORKAROUNDS` is defined, in which case evaluates to
- `(__BORLANDC__ <= 0x590)`.
- [*Note]: the ultimate source of documentation for this macro is in [@../../../../boost/config/workaround.hpp boost/config/workaround.hpp].
- ]]
- [[`BOOST_PREVENT_MACRO_SUBSTITUTION`][
- Sometimes you have a function name with the same name as a C macro, for example "min" and "max"
- member functions, in which case one can prevent the function being expanded as a macro using:
- ``
- someclass.min BOOST_PREVENT_MACRO_SUBSTITUTION(arg1, arg2);
- ``
- The following also works in most, but not all, contexts:
- ``
- (someclass.max)(arg1, arg2);
- ``
- ]]
- [[`BOOST_DEDUCED_TYPENAME`][
- Some compilers don't support the use of typename for dependent types in deduced
- contexts. This macro expands to nothing on those compilers, and typename
- elsewhere. For example, replace:
- `template <class T> void f(T, typename T::type);`
- with:
- `template <class T> void f(T, BOOST_DEDUCED_TYPENAME T::type);`
- ]]
- [[`BOOST_HASH_MAP_HEADER`][
- The header to include to get the SGI `hash_map` class. This macro is only
- available if `BOOST_HAS_HASH` is defined.
- ]]
- [[`BOOST_HASH_SET_HEADER`][
- The header to include to get the SGI `hash_set` class. This macro is only
- available if `BOOST_HAS_HASH` is defined.
- ]]
- [[`BOOST_SLIST_HEADER`][
- The header to include to get the SGI `slist` class. This macro is only
- available if `BOOST_HAS_SLIST` is defined.
- ]]
- [[`BOOST_STD_EXTENSION_NAMESPACE`][
- The namespace used for std library extensions (hashtable classes etc).
- ]]
- [[`BOOST_STATIC_CONSTANT(Type, assignment)`][
- On compilers which don't allow in-class initialization of static integral
- constant members, we must use enums as a workaround if we want the constants
- to be available at compile-time. This macro gives us a convenient way to
- declare such constants.
- For example instead of:
- ``
- struct foo{
- static const int value = 2;
- };
- ``
- use:
- ``
- struct foo{
- BOOST_STATIC_CONSTANT(int, value = 2);
- };
- ``
- ]]
- [[`BOOST_UNREACHABLE_RETURN(result)`][
- Normally evaluates to nothing, but evaluates to return x; if the compiler
- requires a return, even when it can never be reached.
- ]]
- [[`BOOST_FALLTHROUGH`][
- The BOOST_FALLTHROUGH macro can be used to annotate implicit fall-through
- between switch labels:
- ``
- switch (x) {
- case 40:
- case 41:
- if (truth_is_out_there) {
- ++x;
- BOOST_FALLTHROUGH; // Use instead of/along with annotations in
- // comments.
- } else {
- return x;
- }
- case 42:
- ...
- ``
- As shown in the example above, the BOOST_FALLTHROUGH macro should be
- followed by a semicolon. It is designed to mimic control-flow statements
- like 'break;', so it can be placed in most places where 'break;' can, but
- only if there are no statements on the execution path between it and the
- next switch label.
- When compiled with Clang >3.2 in C++11 mode, the BOOST_FALLTHROUGH macro is
- expanded to `[[clang::fallthrough]]` attribute, which is analysed when
- performing switch labels fall-through diagnostic ('-Wimplicit-fallthrough').
- See clang [@http://clang.llvm.org/docs/LanguageExtensions.html#clang__fallthrough
- documentation on language extensions for details.]
- When used with unsupported compilers, the BOOST_FALLTHROUGH macro has no
- effect on diagnostics.
- In either case this macro has no effect on runtime behavior and performance
- of code.
- ]]
- [[`BOOST_EXPLICIT_TEMPLATE_TYPE(t)`
- `BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t,v)`
- `BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)`
- `BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t,v)`][
- Some compilers silently "fold" different function template instantiations if
- some of the template parameters don't appear in the function parameter list.
- For instance:
- ``
- #include <iostream>
- #include <ostream>
- #include <typeinfo>
- template <int n>
- void f() { std::cout << n << ' '; }
- template <typename T>
- void g() { std::cout << typeid(T).name() << ' '; }
- int main() {
- f<1>();
- f<2>();
- g<int>();
- g<double>();
- }
- ``
- incorrectly outputs [^2 2 double double] on VC++ 6. These macros, to be used
- in the function parameter list, fix the problem without effects on the calling
- syntax. For instance, in the case above write:
- ``
- template <int n>
- void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... }
- template <typename T>
- void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... }
- ``
- Beware that they can declare (for affected compilers) a dummy defaulted
- parameter, so they
- [*a)] should be always invoked [*at the end] of the parameter list
- [*b)] can't be used if your function template is multiply declared.
- Furthermore, in order to add any needed comma separator, an `APPEND_*` version
- must be used when the macro invocation appears after a normal parameter
- declaration or after the invocation of another macro of this same group.
- ]]
- [[`BOOST_USE_FACET(Type, loc)`][
- When the standard library does not have a conforming `std::use_facet` there
- are various workarounds available, but they differ from library to library.
- This macro provides a consistent way to access a locale's facets. For example,
- replace:
- `std::use_facet<Type>(loc);`
- with:
- `BOOST_USE_FACET(Type, loc);`
- Note do not add a `std::` prefix to the front of `BOOST_USE_FACET`.
- ]]
- [[`BOOST_HAS_FACET(Type, loc)`][
- When the standard library does not have a comforming `std::has_facet` there
- are various workarounds available, but they differ from library to library.
- This macro provides a consistent way to check a locale's facets. For example,
- replace:
- `std::has_facet<Type>(loc);`
- with:
- `BOOST_HAS_FACET(Type, loc);`
- Note do not add a `std::` prefix to the front of `BOOST_HAS_FACET`.
- ]]
- [[`BOOST_NESTED_TEMPLATE`][
- Member templates are supported by some compilers even though they can't use
- the `A::template member<U>` syntax, as a workaround replace:
- `typedef typename A::template rebind<U> binder;`
- with:
- `typedef typename A::BOOST_NESTED_TEMPLATE rebind<U> binder;`
- ]]
- [[`BOOST_STRINGIZE(X)`][
- Converts the parameter `X` to a string after macro replacement on `X` has
- been performed.
- ]]
- [[`BOOST_JOIN(X,Y)`][
- This piece of macro magic joins the two arguments together, even when one of
- the arguments is itself a macro (see 16.3.1 in C++ standard). This is normally
- used to create a mangled name in combination with a predefined macro such a
- \_\_LINE__.
- ]]
- [[`BOOST_RESTRICT`][
- This macro can be used in place of the compiler specific variant of the C99 `restrict` keyword to
- notify the compiler that, for the lifetime of the qualified pointer variable, only it and its
- derivative value will be used to gain access to the object it references. This limits the effect of
- pointer aliasing and helps the optimizers in generating better code. However, i this condition is
- violated, undefined behavior may occurs.
- Usage example:
- ``
- void perform_computation( float* BOOST_RESTRICT in, float* BOOST_RESTRICT out )
- {
- *out = *in * 0.5f;
- }
- ``
- ]]
- [[`BOOST_FORCEINLINE`][
- This macro can be used in place of the `inline` keyword to instruct the compiler
- that the function should always be inlined.
- Overuse of this macro can lead to significant bloat, while good use can increase
- performance in certain cases, such as computation-intensive code built through
- generative programming techniques.
- Usage example:
- ``
- template<class T>
- BOOST_FORCEINLINE T& f(T& t)
- {
- return t;
- }
- ``
- Note that use of this macro can lead to cryptic error messages with some compilers.
- Consider defining it to `inline` before including the Boost.Config header in order to be
- able to debug errors more easily.
- ]]
- [[`BOOST_NOINLINE`][
- This macro can be used in place of the `inline` keyword to instruct the compiler
- that the function should never be inlined. One should typically use this macro
- to mark functions that are unlikely to be called, such as error handling routines.
- Usage example:
- ``
- BOOST_NOINLINE void handle_error(const char* descr)
- {
- // ...
- }
- ``
- ]]
- [[`BOOST_NORETURN`][
- This macro can be used before the function declaration or definition to instruct the compiler
- that the function does not return normally (i.e. with a `return` statement or by leaving
- the function scope, if the function return type is `void`). The macro can be used to mark
- functions that always throw exceptions or terminate the application. Compilers that support
- this markup may use this information to specifically organize the code surrounding calls to
- this function and suppress warnings about missing `return` statements in the functions
- enclosing such calls.
- Usage example:
- ``
- BOOST_NORETURN void on_error_occurred(const char* descr)
- {
- throw std::runtime_error(descr);
- }
- ``
- If the compiler does not support this markup, `BOOST_NORETURN` is defined empty and an
- additional macro `BOOST_NO_NORETURN` is defined.
- ]]
- [[`BOOST_LIKELY(X)`
- `BOOST_UNLIKELY(X)`][
- These macros communicate to the compiler that the conditional expression `X` is likely
- or unlikely to yield a positive result. The expression should result in a boolean value.
- The result of the macro is an integer or boolean value equivalent to the result of `X`.
- The macros are intended to be used in branching statements. The additional hint they provide
- can be used by the compiler to arrange the compiled code of the branches more effectively.
- Usage example:
- ``
- if (BOOST_UNLIKELY(ptr == NULL))
- handle_error("ptr is NULL");
- ``
- ]]
- [[`BOOST_ATTRIBUTE_UNUSED`][Expands to `__attribute__((unused))` when this is available -
- can be used to disable compiler warnings relating to unused types or variables.]]
- [[`BOOST_ATTRIBUTE_NODISCARD`][Expands to `[[nodiscard]]` when this is available -
- can be used to create a warning when a type or variable is unused.]]
- [[`BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS`][Expands to `[[no_unique_address]]` when this is available -
- can be used to indicate that a non-static data member need not have a unique address (for example empty classes).]]
- [[`BOOST_MAY_ALIAS`, `BOOST_NO_MAY_ALIAS`][
- `BOOST_MAY_ALIAS` expands to a type attribute that can be used to mark types that may
- alias other types. Pointers or references to such marked types can be used to access objects
- of other types. If the compiler supports this feature `BOOST_NO_MAY_ALIAS` is not defined.
- Otherwise `BOOST_MAY_ALIAS` expands to nothing and `BOOST_NO_MAY_ALIAS` is defined.
- Usage example:
- ``
- struct BOOST_MAY_ALIAS aliasing_struct;
- typedef unsigned int BOOST_MAY_ALIAS aliasing_uint;
- ``
- ]]
- [[`BOOST_PRAGMA_MESSAGE(M)`][Defined in header `<boost/config/pragma_message.hpp>`,
- this macro expands to the equivalent of `#pragma message(M)`. `M` must be a string
- literal.
- Example: `BOOST_PRAGMA_MESSAGE("This header is deprecated.")`
- The messages issued by `BOOST_PRAGMA_MESSAGE` can be suppressed by defining the macro
- `BOOST_DISABLE_PRAGMA_MESSAGE`.]]
- [[`BOOST_HEADER_DEPRECATED(A)`][Defined in header `<boost/config/header_deprecated.hpp>`,
- this macro issues the message "This header is deprecated. Use `A` instead." via
- `BOOST_PRAGMA_MESSAGE`. `A` must be a string literal.
- Example: `BOOST_HEADER_DEPRECATED("<boost/config/workaround.hpp>")`
- The messages issued by `BOOST_HEADER_DEPRECATED` can be suppressed by defining the macro
- `BOOST_ALLOW_DEPRECATED_HEADERS`.]]
- ]
- [endsect]
- [#config_info_macros]
- [section Boost Informational Macros]
- The following macros describe boost features; these are, generally speaking
- the only boost macros that should be tested in user code.
- [table
- [[Macro ][Header ][Description ]]
- [[`BOOST_VERSION`][`<boost/version.hpp>`][
- Describes the boost version number in XYYYZZ format such that:
- `(BOOST_VERSION % 100)` is the sub-minor version, `((BOOST_VERSION / 100) % 1000)`
- is the minor version, and `(BOOST_VERSION / 100000)` is the major version.
- ]]
- [[`BOOST_NO_INT64_T`][`<boost/cstdint.hpp>` `<boost/stdint.h>`][
- Defined if there are no 64-bit integral types: `int64_t`, `uint64_t` etc.
- ]]
- [[`BOOST_NO_INTEGRAL_INT64_T`][`<boost/cstdint.hpp>` `<boost/stdint.h>`][
- Defined if `int64_t` as defined by `<boost/cstdint.hpp>` is not usable in
- integral constant expressions.
- ]]
- [[`BOOST_MSVC`][`<boost/config.hpp>`][
- Defined if the compiler is really Microsoft Visual C++, as opposed to one
- of the many other compilers that also define `_MSC_VER`. Has the same value as
- _MSC_VER.
- ]]
- [[`BOOST_MSVC_FULL_VER`][`<boost/config.hpp>`][
- Defined to a normalised 9 digit version of _MSC_FULL_VER (which sometimes only has 8 digits),
- the macro has the form VVMMPPPPP where VV is the major version number, MM is the minor version number, and
- PPPPP is the compiler build number.
- ]]
- [[`BOOST_GCC`][`<boost/config.hpp>`][
- Defined if the compiler is really GCC, as opposed to one
- of the many other compilers that also define `__GNUC__`. Has the value:
- `__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__`.
- ]]
- [[`BOOST_INTEL`][`<boost/config.hpp>`][
- Defined if the compiler is an Intel compiler, takes the same value as the
- compiler version macro.
- ]]
- [[`BOOST_CLANG`][`<boost/config.hpp>`][
- Defined to 1 if the compiler is the Clang compiler.
- ]]
- [[`BOOST_WINDOWS`][`<boost/config.hpp>`][
- Defined if the Windows platform API is available.
- ]]
- [[`BOOST_DINKUMWARE_STDLIB`][`<boost/config.hpp>`][
- Defined if the dinkumware standard library is in use, takes the same value
- as the Dinkumware library version macro `_CPPLIB_VER` if defined, otherwise 1.
- ]]
- [[`BOOST_NO_WREGEX`][`<boost/regex.hpp>`][
- Defined if the regex library does not support wide character regular
- expressions.
- ]]
- [[`BOOST_COMPILER`][`<boost/config.hpp>`][
- Defined as a string describing the name and version number of the compiler
- in use. Mainly for debugging the configuration.
- ]]
- [[`BOOST_STDLIB`][`<boost/config.hpp>`][
- Defined as a string describing the name and version number of the standard
- library in use. Mainly for debugging the configuration.
- ]]
- [[`BOOST_PLATFORM`][`<boost/config.hpp>`][
- Defined as a string describing the name of the platform. Mainly for debugging
- the configuration.
- ]]
- ]
- [endsect]
- [#deprecated_macros]
- [section Boost Deprecated Macros]
- The following have been deprecated; please use the replacements instead.
- They will be removed in a future version of boost.
- [table
- [[Deprecated Macro][Replacement][When deprecated][When removed]]
- [[`BOOST_NO_0X_HDR_ARRAY`][`BOOST_NO_CXX11_HDR_ARRAY`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_CHRONO`][`BOOST_NO_CXX11_HDR_CHRONO`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_CODECVT`][`BOOST_NO_CXX11_HDR_CODECVT`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_CONDITION_VARIABLE`][`BOOST_NO_CXX11_HDR_CONDITION_VARIABLE`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_FORWARD_LIST`][`BOOST_NO_CXX11_HDR_FORWARD_LIST`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_FUTURE`][`BOOST_NO_CXX11_HDR_FUTURE`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_INITIALIZER_LIST`][`BOOST_NO_CXX11_HDR_INITIALIZER_LIST`][Boost 1.50][]]
- [[`BOOST_NO_INITIALIZER_LISTS`][`BOOST_NO_CXX11_HDR_INITIALIZER_LIST`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_MUTEX`][`BOOST_NO_CXX11_HDR_MUTEX`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_RANDOM`][`BOOST_NO_CXX11_HDR_RANDOM`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_RATIO`][`BOOST_NO_CXX11_HDR_RATIO`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_REGEX`][`BOOST_NO_CXX11_HDR_REGEX`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_SYSTEM_ERROR`][`BOOST_NO_CXX11_HDR_SYSTEM_ERROR`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_THREAD`][`BOOST_NO_CXX11_HDR_THREAD`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_TUPLE`][`BOOST_NO_CXX11_HDR_TUPLE`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_TYPE_TRAITS`][`BOOST_NO_CXX11_HDR_TYPE_TRAITS`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_TYPEINDEX`][`BOOST_NO_CXX11_HDR_TYPEINDEX`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_UNORDERED_SET`][`BOOST_NO_CXX11_HDR_UNORDERED_SET`][Boost 1.50][]]
- [[`BOOST_NO_0X_HDR_UNORDERED_MAP`][`BOOST_NO_CXX11_HDR_UNORDERED_MAP`][Boost 1.50][]]
- [[`BOOST_NO_STD_UNORDERED`][`BOOST_NO_CXX11_HDR_UNORDERED_SET`][Boost 1.50][]]
- [[][][][]]
- [[`BOOST_NO_AUTO_DECLARATIONS`][`BOOST_NO_CXX11_AUTO_DECLARATIONS`][Boost 1.51][]]
- [[`BOOST_NO_AUTO_MULTIDECLARATIONS`][`BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS`][Boost 1.51][]]
- [[`BOOST_NO_CHAR16_T`][`BOOST_NO_CXX11_CHAR16_T`][Boost 1.51][]]
- [[`BOOST_NO_CHAR32_T`][`BOOST_NO_CXX11_CHAR32_T`][Boost 1.51][]]
- [[`BOOST_NO_TEMPLATE_ALIASES`][`BOOST_NO_CXX11_TEMPLATE_ALIASES`][Boost 1.51][]]
- [[`BOOST_NO_CONSTEXPR`][`BOOST_NO_CXX11_CONSTEXPR`][Boost 1.51][]]
- [[`BOOST_NO_DECLTYPE`][`BOOST_NO_CXX11_DECLTYPE`][Boost 1.51][]]
- [[`BOOST_NO_DECLTYPE_N3276`][`BOOST_NO_CXX11_DECLTYPE_N3276`][Boost 1.51][]]
- [[`BOOST_NO_DEFAULTED_FUNCTIONS`][`BOOST_NO_CXX11_DEFAULTED_FUNCTIONS`][Boost 1.51][]]
- [[`BOOST_NO_DELETED_FUNCTIONS`][`BOOST_NO_CXX11_DELETED_FUNCTIONS`][Boost 1.51][]]
- [[`BOOST_NO_EXPLICIT_CONVERSION_OPERATORS`][`BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS`][Boost 1.51][]]
- [[`BOOST_NO_EXTERN_TEMPLATE`][`BOOST_NO_CXX11_EXTERN_TEMPLATE`][Boost 1.51][]]
- [[`BOOST_NO_FUNCTION_TEMPLATE_DEFAULT_ARGS`][`BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS`][Boost 1.51][]]
- [[`BOOST_NO_LAMBDAS`][`BOOST_NO_CXX11_LAMBDAS`][Boost 1.51][]]
- [[`BOOST_NO_LOCAL_CLASS_TEMPLATE_PARAMETERS`][`BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS`][Boost 1.51][]]
- [[`BOOST_NO_NOEXCEPT`][`BOOST_NO_CXX11_NOEXCEPT`][Boost 1.51][]]
- [[`BOOST_NO_NULLPTR`][`BOOST_NO_CXX11_NULLPTR`][Boost 1.51][]]
- [[`BOOST_NO_RAW_LITERALS`][`BOOST_NO_CXX11_RAW_LITERALS`][Boost 1.51][]]
- [[`BOOST_NO_RVALUE_REFERENCES`][`BOOST_NO_CXX11_RVALUE_REFERENCES`][Boost 1.51][]]
- [[`BOOST_NO_SCOPED_ENUMS`][`BOOST_NO_CXX11_SCOPED_ENUMS`][Boost 1.51][]]
- [[`BOOST_NO_STATIC_ASSERT`][`BOOST_NO_CXX11_STATIC_ASSERT`][Boost 1.51][]]
- [[`BOOST_NO_STD_UNORDERED`][`BOOST_NO_CXX11_STD_UNORDERED`][Boost 1.51][]]
- [[`BOOST_NO_UNICODE_LITERALS`][`BOOST_NO_CXX11_UNICODE_LITERALS`][Boost 1.51][]]
- [[`BOOST_NO_UNIFIED_INITIALIZATION_SYNTAX`][`BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX`][Boost 1.51][]]
- [[`BOOST_NO_VARIADIC_TEMPLATES`][`BOOST_NO_CXX11_VARIADIC_TEMPLATES`][Boost 1.51][]]
- [[`BOOST_NO_VARIADIC_MACROS`][`BOOST_NO_CXX11_VARIADIC_MACROS`][Boost 1.51][]]
- [[`BOOST_NO_NUMERIC_LIMITS_LOWEST`][`BOOST_NO_CXX11_NUMERIC_LIMITS`][Boost 1.51][]]
- [[][][][]]
- [[`BOOST_HAS_STATIC_ASSERT`][`BOOST_NO_CXX11_STATIC_ASSERT` (negated)][Boost 1.53][]]
- [[`BOOST_HAS_VARIADIC_TMPL`][`BOOST_NO_CXX11_VARIADIC_TEMPLATES` (negated)][Boost 1.53][]]
- [[`BOOST_HAS_RVALUE_REFS`][`BOOST_NO_CXX11_RVALUE_REFERENCES` (negated)][Boost 1.53][]]
- [[`BOOST_HAS_CHAR16_T`][`BOOST_NO_CXX11_CHAR16_T` (negated)][Boost 1.53][]]
- [[`BOOST_HAS_CHAR32_T`][`BOOST_NO_CXX11_CHAR32_T` (negated)][Boost 1.53][]]
- ]
- [endsect]
- [section Macros for libraries with separate source code]
- The following macros and helper headers are of use to authors whose libraries
- include separate source code, and are intended to address several issues:
- * Controlling shared library symbol visibility
- * Fixing the ABI of the compiled library
- * Selecting which compiled library to link against based upon the compilers settings
- See [@http://www.boost.org/development/separate_compilation.html Guidelines for Authors of Boost Libraries Containing Separate Source]
- [section Macros controlling shared library symbol visibility]
- Some compilers support C++ extensions that control which symbols
- will be exported from shared libraries such as dynamic shared objects (DSO's) on Unix-like
- systems or dynamic-link libraries (DLL's) on Windows.
- The Microsoft VC++ compiler has long supplied
- `__declspec(dllexport)` and `__declspec(dllimport)` extensions for this purpose,
- as do virtually all other compilers targeting the Windows platform.
-
- Modern versions of the GNU GCC compiler provide the `__attribute__((visibility("default")))`
- extension to indicate that a symbol should be exported. All other symbols may be hidden by using the
- `-fvisibility-hidden` or `-fvisibility-ms-compat` compiler switches.
- Boost supplies several macros to make it easier to manage symbol visibility in a way that
- is portable between compilers and operating systems.
- [table
- [[Macro ][Description ]]
- [[`BOOST_SYMBOL_EXPORT`][
- Defines the syntax of a C++ language extension that indicates a symbol is to be exported from a shared library.
- If the compiler has no such extension, the macro is defined with no replacement text.
- ]]
- [[`BOOST_SYMBOL_IMPORT`][
- Defines the syntax of a C++ language extension that indicates a symbol is to be imported from a shared library.
- If the compiler has no such extension, the macro is defined with no replacement text.
- ]]
- [[`BOOST_SYMBOL_VISIBLE`][
- Defines the syntax of a C++ language extension that indicates a symbol is to be globally visible.
- If the compiler has no such extension, the macro is defined with no replacement text.
- Needed for classes that are not otherwise exported, but are used by RTTI. Examples include
- class for objects that will be thrown as exceptions or used in dynamic_casts,
- across shared library boundaries. For example, a header-only exception class might look like this:
- ``
- class BOOST_SYMBOL_VISIBLE my_exception : public std::runtime_error { ... };
- ``
- Without BOOST_SYMBOL_VISIBLE, it would be impossible to catch my_exception thrown from a shared library
- compiled by GCC with the -fvisibility=hidden option.
- ]]
- [[`BOOST_HAS_DECLSPEC`][
- The compiler has C++ extensions `__declspec(dllexport)` and `__declspec(dllimport)` to control
- export/import of symbols from shared libraries.
- ['Deprecated. This macro is no longer necessary since BOOST_SYMBOL_EXPORT and BOOST_SYMBOL_IMPORT
- are now supplied. It is provided to support legacy code.]
- ]]
- ]
- Typical usage:
- [*boost/foo/config.hpp]
- ...
- #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_FOO_DYN_LINK)
- # if defined(BOOST_FOO_SOURCE)
- # define BOOST_FOO_DECL BOOST_SYMBOL_EXPORT
- # else
- # define BOOST_FOO_DECL BOOST_SYMBOL_IMPORT
- # endif
- #else
- # define BOOST_FOO_DECL
- #endif
- ...
-
- [*boost/foo/foo.hpp]
-
- #include <boost/foo/config.hpp>
- ...
- class BOOST_FOO_DECL bar { ... };
- ...
- void BOOST_FOO_DECL f();
- ...
- [*boost/libs/foo/src/foo.cpp]
-
- #define BOOST_FOO_SOURCE
- #include <boost/foo/foo.hpp>
- ...
- void BOOST_FOO_DECL f()
- {
- ...
- }
- ...
-
- [endsect]
- [section ABI Fixing]
- When linking against a pre-compiled library it vital that the ABI used by the
- compiler when building the library ['matches exactly] the ABI used by the code
- using the library. In this case ABI means things like the struct packing
- arrangement used, the name mangling scheme used, or the size of some types
- (enum types for example). This is separate from things like threading support,
- or runtime library variations, which have to be dealt with by build variants.
- To put this in perspective there is one compiler (Borland's) that has so many
- compiler options that make subtle changes to the ABI, that at least in theory
- there 3200 combinations, and that's without considering runtime library
- variations. Fortunately these variations can be managed by `#pragma`'s that
- tell the compiler what ABI to use for the types declared in your library.
- In order to avoid sprinkling `#pragma`'s all over the boost headers, there are
- some prefix and suffix headers that do the job. Typical usage is:
- [*my_library.hpp]
- #ifndef MY_INCLUDE_GUARD
- #define MY_INCLUDE_GUARD
- // all includes go here:
- ``[^[*#include <boost/config.hpp>]]``
- #include <whatever>
- ``[^[*#include <boost/config/abi_prefix.hpp>]]`` // must be the last #include
- namespace boost {
- // your code goes here
- }
- ``[^[*#include <boost/config/abi_suffix.hpp>]]`` // pops abi_prefix.hpp pragmas
- #endif // include guard
- [*my_library.cpp]
- ...
- // nothing special need be done in the implementation file
- ...
- The user can disable this mechanism by defining `BOOST_DISABLE_ABI_HEADERS`, or
- they can define `BOOST_ABI_PREFIX` and/or `BOOST_ABI_SUFFIX` to point to their
- own prefix/suffix headers if they so wish.
- [endsect]
- [section Automatic library selection]
- It is essential that users link to a build of a library which was built against
- the same runtime library that their application will be built against -if this
- does not happen then the library will not be binary compatible with their own
- code- and there is a high likelihood that their application will experience
- runtime crashes. These kinds of problems can be extremely time consuming and
- difficult to debug, and often lead to frustrated users and authors alike (simply
- selecting the right library to link against is not as easy as it seems when
- their are 6-8 of them to chose from, and some users seem to be blissfully
- unaware that there even are different runtimes available to them).
- To solve this issue, some compilers allow source code to contain `#pragma`'s that
- instruct the linker which library to link against, all the user need do is
- include the headers they need, place the compiled libraries in their library
- search path, and the compiler and linker do the rest. Boost.config supports
- this via the header `<boost/config/auto_link.hpp>`, before including this header
- one or more of the following macros need to be defined:
- [variablelist
- [[`BOOST_LIB_NAME`][
- Required: An identifier containing the basename of the library, for
- example 'boost_regex'.
- ]]
- [[`BOOST_DYN_LINK`][
- Optional: when set link to dll rather than static library.
- ]]
- [[`BOOST_LIB_DIAGNOSTIC`][
- Optional: when set the header will print out the name of the library selected
- (useful for debugging).
- ]]
- [[`BOOST_AUTO_LINK_NOMANGLE`][
- Optional: whan set specifies that we should link to BOOST_LIB_NAME.lib, rather than a mangled-name version.]]
- [[`BOOST_AUTO_LINK_TAGGED`][Optional: Specifies that we link to libraries built with the --layout=tagged option.
- This is essentially the same as the default name-mangled version, but without
- the compiler name and version, or the Boost version. Just the build options.]]
- [[`BOOST_AUTO_LINK_SYSTEM`][Optional: Specifies that we link to libraries built with the --layout=system option.
- This is essentially the same as the non-name-mangled version, but with
- the prefix to differentiate static and dll builds]]
- ]
- If the compiler supports this mechanism, then it will be told to link against
- the appropriately named library, the actual algorithm used to mangle the name
- of the library is documented inside `<boost/config/auto_link.hpp>` and has to
- match that used to create the libraries via bjam 's install rules.
- [*my_library.hpp]
- ...
- //
- // Don't include auto-linking code if the user has disabled it by
- // defining BOOST_ALL_NO_LIB, or BOOST_MY_LIBRARY_NO_LIB, or if this
- // is one of our own source files (signified by BOOST_MY_LIBRARY_SOURCE):
- //
- #if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_MY_LIBRARY_NO_LIB) && !defined(BOOST_MY_LIBRARY_SOURCE)
- # define BOOST_LIB_NAME boost_my_library
- # ifdef BOOST_MY_LIBRARY_DYN_LINK
- # define BOOST_DYN_LINK
- # endif
- # include <boost/config/auto_link.hpp>
- #endif
- ...
- [*my_library.cpp]
- // define BOOST_MY_LIBRARY_SOURCE so that the header knows that the
- // library is being built (possibly exporting rather than importing code)
- //
- #define BOOST_MY_LIBRARY_SOURCE
- #include <boost/my_library/my_library.hpp>
- ...
- [endsect]
- [endsect]
- [endsect]
|