Namespaces
Variants
Views
Actions

Freestanding and hosted implementations

From cppreference.com
< cpp
Revision as of 21:16, 15 September 2022 by Cqwrteur (Talk | contribs)

 
C++
 

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)

Contents

Requirements on multi-threaded executions and data races

freestanding hosted
Under a freestanding implementation, it is implementation-defined whether a program can have more than one thread of execution. Under a hosted implementation, a C++ program can have more than one thread running concurrently.
(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:

Headers required for a freestanding implementation
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)
  1. ↑ 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).
  2. ↑ 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 may not correctly support freestanding implementation, for either implementation issues (see: GCC bug 100057) 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
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/freestanding&oldid=143204"