Difference between revisions of "cpp/freestanding"
From cppreference.com
< cpp
(change 'may' to 'might' and added commas) |
|||
| Line 2: | Line 2: | ||
{{cpp/navbar}} | {{cpp/navbar}} | ||
| − | There are two kinds of implementations defined by the C++ standard: '''''hosted''''' and '''''freestanding''''' implementations. For ''hosted'' implementations the set of standard library headers required by the C++ standard is much larger than for ''freestanding'' ones. In a ''freestanding'' implementation execution may happen without an operating system. | + | There are two kinds of implementations defined by the C++ standard: '''''hosted''''' and '''''freestanding''''' implementations. For ''hosted'' implementations, the set of standard library headers required by the C++ standard is much larger than for ''freestanding'' ones. In a ''freestanding'' implementation, execution may happen without an operating system. |
The kind of the implementation is implementation-defined. {{rev inl|since=c++11|The macro {{tt|__STDC_HOSTED__}} is predefined to {{tt|1}} for hosted implementations and {{tt|0}} for freestanding implementations.}} | The kind of the implementation is implementation-defined. {{rev inl|since=c++11|The macro {{tt|__STDC_HOSTED__}} is predefined to {{tt|1}} for hosted implementations and {{tt|0}} for freestanding implementations.}} | ||
| Line 86: | Line 86: | ||
===Notes=== | ===Notes=== | ||
| − | Compiler vendors | + | Compiler vendors might not correctly support freestanding implementation, for either implementation issues, or just ignoring freestanding as a whole (LLVM libcxx and msvc stl). |
Many features will be freestanding in C++23 but with partial headers. Whether array would be freestanding in the future is under discussion. | Many features will be freestanding in C++23 but with partial headers. Whether array would be freestanding in the future is under discussion. | ||
Revision as of 13:26, 20 September 2022
There are two kinds of implementations defined by the C++ standard: hosted and freestanding implementations. For hosted implementations, the set of standard library headers required by the C++ standard is much larger than for freestanding ones. In a freestanding implementation, execution may happen without an operating system.
The kind of the implementation is implementation-defined. The macro __STDC_HOSTED__ is predefined to 1 for hosted implementations and 0 for freestanding implementations.(since C++11)
Requirements on multi-threaded executions and data races
|
(since C++11) |
Requirements on the main function
| freestanding | hosted |
|---|---|
| In a freestanding implementation, it is implementation-defined whether a program is required to define a main function. Start-up and termination is implementation-defined; start-up contains the execution of constructors for objects of namespace scope with static storage duration; termination contains the execution of destructors for objects with static storage duration. | In a hosted implementation, a program must contain a global function called main. Executing a program starts a main thread of execution in which the main function is invoked, and in which variables of static storage duration might be initialized and destroyed.
|
Requirements on standard library headers
A freestanding implementation has an implementation-defined set of headers. This set includes at least the headers in the following table:
| Types | <cstddef> |
| Implementation properties | <limits> <cfloat> <climits> (since C++11) <version> (since C++20) |
| Integer types | <cstdint> (since C++11) |
| Start and termination | <cstdlib> (partial)[1] |
| Dynamic memory management | <new> |
| Type identification | <typeinfo> |
| Source location | <source_location> (since C++20) |
| Exception handling | <exception> |
| Initializer lists | <initializer_list> (since C++11) |
| Comparisons | <compare> (since C++20) |
| Coroutines support | <coroutine> (since C++20) |
| Other runtime support | <cstdarg> |
| Fundamental library concepts | <concepts> (since C++20) |
| Type traits | <type_traits> (since C++11) |
| Bit manipulation | <bit> (since C++20) |
| Atomics | <atomic> (since C++11)[2] |
| Utility components | <utility> (since C++23) |
| Tuples | <tuple> (since C++23) |
| Memory | <memory> (since C++23) (partial) |
| Function objects | <functional> (since C++23) (partial) |
| Compile-time rational arithmetic | <ratio> (since C++23) |
| Iterators library | <iterator> (since C++23) (partial) |
| Ranges library | <ranges> (since C++23) (partial) |
| Deprecated headers | <ciso646> <cstdalign> <cstdbool> (since C++11)(until C++20) |
- ↑ The supplied version of the header
<cstdlib>shall declare at least the functions std::abort, std::atexit, std::exit, std::at_quick_exit and std::quick_exit(since C++11). - ↑ Support for always lock-free integral atomic types and presence of type aliases std::atomic_signed_lock_free and std::atomic_unsigned_lock_free are implementation-defined in a freestanding implementation.(since C++20)
Notes
Compiler vendors might not correctly support freestanding implementation, for either implementation issues, or just ignoring freestanding as a whole (LLVM libcxx and msvc stl).
Many features will be freestanding in C++23 but with partial headers. Whether array would be freestanding in the future is under discussion.
References
- C++23 standard (ISO/IEC 14882:2024):
- 4.1 Implementation compliance [intro.compliance] (p: 10)
- 6.9.2 Multi-threaded executions and data races [intro.multithread] (p: 84)
- 6.9.3.1 main function [basic.start.main] (p: 89)
- 16.4.2.5 Freestanding implementations [compliance] (p: 483)
- C++20 standard (ISO/IEC 14882:2020):
- 4.1 Implementation compliance [intro.compliance] (p: 7)
- 6.9.2 Multi-threaded executions and data races [intro.multithread] (p: 77)
- 6.9.3.1 main function [basic.start.main] (p: 82)
- 16.5.1.3 Freestanding implementations [compliance] (p: 470)
- C++17 standard (ISO/IEC 14882:2017):
- 4.1 Implementation compliance [intro.compliance] (p: 5)
- 4.7 Multi-threaded executions and data races [intro.multithread] (p: 15)
- 6.6.1 main function [basic.start.main] (p: 66)
- 20.5.1.3 Freestanding implementations [compliance] (p: 458)
- C++14 standard (ISO/IEC 14882:2014):
- 1.4 Implementation compliance [intro.compliance] (p: 5)
- 1.10 Multi-threaded executions and data races [intro.multithread] (p: 11)
- 3.6.1 Main function [basic.start.main] (p: 62)
- 17.6.1.3 Freestanding implementations [compliance] (p: 441)
- C++11 standard (ISO/IEC 14882:2011):
- 1.4 Implementation compliance [intro.compliance] (p: 5)
- 1.10 Multi-threaded executions and data races [intro.multithread] (p: 11)
- 3.6.1 Main function [basic.start.main] (p: 58)
- 17.6.1.3 Freestanding implementations [compliance] (p: 408)
- C++03 standard (ISO/IEC 14882:2003):
- 1.4 Implementation compliance [intro.compliance] (p: 3)
- 3.6.1 Main function [basic.start.main] (p: 43)
- 17.4.1.3 Freestanding implementations [lib.compliance] (p: 326)
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| CWG 1938 | C++98 | an implementation did not need to document whether it is hosted |
made the implementation kind implementation- defined (thus requires a documentation) |
| LWG 3653 | C++20 | <coroutine> is freestanding, but uses std::hash which is not |
Fixed in C++23 with <functional> being partial freestanding |
See also
| C documentation for Conformance
|
