[cinttypes.syn] - C++14 → C++17

Files changed (1) hide show

tmp/tmp97aae5vo/{from.md → to.md} +537 -0

tmp/tmp97aae5vo/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,537 @@

+### Header `<cinttypes>` synopsis <a id="cinttypes.syn">[[cinttypes.syn]]</a>
+``` cpp
+#include <cstdint>  // see [cstdint.syn]
+namespace std {
+  using imaxdiv_t = see below;
+  intmax_t imaxabs(intmax_t j);
+  imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
+  intmax_t strtoimax(const char* nptr, char** endptr, int base);
+  uintmax_t strtoumax(const char* nptr, char** endptr, int base);
+  intmax_t wcstoimax(const wchar_t* nptr, wchar_t** endptr, int base);
+  uintmax_t wcstoumax(const wchar_t* nptr, wchar_t** endptr, int base);
+  intmax_t abs(intmax_t);  // optional, see below
+  imaxdiv_t div(intmax_t, intmax_t);  // optional, see below
+}
+#define PRIdN see below
+#define PRIiN see below
+#define PRIoN see below
+#define PRIuN see below
+#define PRIxN see below
+#define PRIXN see below
+#define SCNdN see below
+#define SCNiN see below
+#define SCNoN see below
+#define SCNuN see below
+#define SCNxN see below
+#define PRIdLEASTN see below
+#define PRIiLEASTN see below
+#define PRIoLEASTN see below
+#define PRIuLEASTN see below
+#define PRIxLEASTN see below
+#define PRIXLEASTN see below
+#define SCNdLEASTN see below
+#define SCNiLEASTN see below
+#define SCNoLEASTN see below
+#define SCNuLEASTN see below
+#define SCNxLEASTN see below
+#define PRIdFASTN see below
+#define PRIiFASTN see below
+#define PRIoFASTN see below
+#define PRIuFASTN see below
+#define PRIxFASTN see below
+#define PRIXFASTN see below
+#define SCNdFASTN see below
+#define SCNiFASTN see below
+#define SCNoFASTN see below
+#define SCNuFASTN see below
+#define SCNxFASTN see below
+#define PRIdMAX see below
+#define PRIiMAX see below
+#define PRIoMAX see below
+#define PRIuMAX see below
+#define PRIxMAX see below
+#define PRIXMAX see below
+#define SCNdMAX see below
+#define SCNiMAX see below
+#define SCNoMAX see below
+#define SCNuMAX see below
+#define SCNxMAX see below
+#define PRIdPTR see below
+#define PRIiPTR see below
+#define PRIoPTR see below
+#define PRIuPTR see below
+#define PRIxPTR see below
+#define PRIXPTR see below
+#define SCNdPTR see below
+#define SCNiPTR see below
+#define SCNoPTR see below
+#define SCNuPTR see below
+#define SCNxPTR see below
+```
+The contents and meaning of the header `<cinttypes>` are the same as the
+C standard library header `<inttypes.h>`, with the following changes:
+- The header `<cinttypes>` includes the header `<cstdint>` instead of
+  `<stdint.h>`, and
+- if and only if the type `intmax_t` designates an extended integer
+  type ([[basic.fundamental]]), the following function signatures are
+  added:
+  ``` cpp
+  intmax_t abs(intmax_t);
+  imaxdiv_t div(intmax_t, intmax_t);
+  ```
+  which shall have the same semantics as the function signatures
+  `intmax_t imaxabs(intmax_t)` and
+  `imaxdiv_t imaxdiv(intmax_t, intmax_t)`, respectively.
+ISO C 7.8.
+<!-- Link reference definitions -->
+[adjustfield.manip]: #adjustfield.manip
+[allocator.requirements]: library.md#allocator.requirements
+[basefield.manip]: #basefield.manip
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.ios.cons]: #basic.ios.cons
+[basic.ios.members]: #basic.ios.members
+[basic.start.main]: basic.md#basic.start.main
+[bidirectional.iterators]: iterators.md#bidirectional.iterators
+[bitmask.types]: library.md#bitmask.types
+[c.files]: #c.files
+[cinttypes.syn]: #cinttypes.syn
+[cstdio.syn]: #cstdio.syn
+[defns.ntcts]: library.md#defns.ntcts
+[enumerated.types]: library.md#enumerated.types
+[error.reporting]: #error.reporting
+[ext.manip]: #ext.manip
+[fig:streampos]: #fig:streampos
+[file.streams]: #file.streams
+[filebuf]: #filebuf
+[filebuf.assign]: #filebuf.assign
+[filebuf.cons]: #filebuf.cons
+[filebuf.members]: #filebuf.members
+[filebuf.virtuals]: #filebuf.virtuals
+[filesystem_error.members]: #filesystem_error.members
+[filesystems]: #filesystems
+[floatfield.manip]: #floatfield.manip
+[fmtflags.manip]: #fmtflags.manip
+[fmtflags.state]: #fmtflags.state
+[fpos]: #fpos
+[fpos.members]: #fpos.members
+[fpos.operations]: #fpos.operations
+[fs.class.directory_entry]: #fs.class.directory_entry
+[fs.class.directory_iterator]: #fs.class.directory_iterator
+[fs.class.file_status]: #fs.class.file_status
+[fs.class.filesystem_error]: #fs.class.filesystem_error
+[fs.class.path]: #fs.class.path
+[fs.class.rec.dir.itr]: #fs.class.rec.dir.itr
+[fs.conform.9945]: #fs.conform.9945
+[fs.conform.os]: #fs.conform.os
+[fs.conformance]: #fs.conformance
+[fs.def.absolute.path]: #fs.def.absolute.path
+[fs.def.filename]: #fs.def.filename
+[fs.def.link]: #fs.def.link
+[fs.def.native]: #fs.def.native
+[fs.def.native.encode]: #fs.def.native.encode
+[fs.def.normal.form]: #fs.def.normal.form
+[fs.def.osdep]: #fs.def.osdep
+[fs.def.path]: #fs.def.path
+[fs.def.pathname]: #fs.def.pathname
+[fs.def.pathres]: #fs.def.pathres
+[fs.def.race]: #fs.def.race
+[fs.def.symlink]: #fs.def.symlink
+[fs.definitions]: #fs.definitions
+[fs.dir.entry.cons]: #fs.dir.entry.cons
+[fs.dir.entry.mods]: #fs.dir.entry.mods
+[fs.dir.entry.obs]: #fs.dir.entry.obs
+[fs.dir.itr.members]: #fs.dir.itr.members
+[fs.dir.itr.nonmembers]: #fs.dir.itr.nonmembers
+[fs.enum]: #fs.enum
+[fs.enum.copy.opts]: #fs.enum.copy.opts
+[fs.enum.dir.opts]: #fs.enum.dir.opts
+[fs.enum.file_type]: #fs.enum.file_type
+[fs.enum.path.format]: #fs.enum.path.format
+[fs.enum.perm.opts]: #fs.enum.perm.opts
+[fs.enum.perms]: #fs.enum.perms
+[fs.err.report]: #fs.err.report
+[fs.file_status.cons]: #fs.file_status.cons
+[fs.file_status.mods]: #fs.file_status.mods
+[fs.file_status.obs]: #fs.file_status.obs
+[fs.filesystem.syn]: #fs.filesystem.syn
+[fs.general]: #fs.general
+[fs.norm.ref]: #fs.norm.ref
+[fs.op.absolute]: #fs.op.absolute
+[fs.op.canonical]: #fs.op.canonical
+[fs.op.copy]: #fs.op.copy
+[fs.op.copy_file]: #fs.op.copy_file
+[fs.op.copy_symlink]: #fs.op.copy_symlink
+[fs.op.create_dir_symlk]: #fs.op.create_dir_symlk
+[fs.op.create_directories]: #fs.op.create_directories
+[fs.op.create_directory]: #fs.op.create_directory
+[fs.op.create_hard_lk]: #fs.op.create_hard_lk
+[fs.op.create_symlink]: #fs.op.create_symlink
+[fs.op.current_path]: #fs.op.current_path
+[fs.op.equivalent]: #fs.op.equivalent
+[fs.op.exists]: #fs.op.exists
+[fs.op.file_size]: #fs.op.file_size
+[fs.op.funcs]: #fs.op.funcs
+[fs.op.hard_lk_ct]: #fs.op.hard_lk_ct
+[fs.op.is_block_file]: #fs.op.is_block_file
+[fs.op.is_char_file]: #fs.op.is_char_file
+[fs.op.is_directory]: #fs.op.is_directory
+[fs.op.is_empty]: #fs.op.is_empty
+[fs.op.is_fifo]: #fs.op.is_fifo
+[fs.op.is_other]: #fs.op.is_other
+[fs.op.is_regular_file]: #fs.op.is_regular_file
+[fs.op.is_socket]: #fs.op.is_socket
+[fs.op.is_symlink]: #fs.op.is_symlink
+[fs.op.last_write_time]: #fs.op.last_write_time
+[fs.op.permissions]: #fs.op.permissions
+[fs.op.proximate]: #fs.op.proximate
+[fs.op.read_symlink]: #fs.op.read_symlink
+[fs.op.relative]: #fs.op.relative
+[fs.op.remove]: #fs.op.remove
+[fs.op.remove_all]: #fs.op.remove_all
+[fs.op.rename]: #fs.op.rename
+[fs.op.resize_file]: #fs.op.resize_file
+[fs.op.space]: #fs.op.space
+[fs.op.status]: #fs.op.status
+[fs.op.status_known]: #fs.op.status_known
+[fs.op.symlink_status]: #fs.op.symlink_status
+[fs.op.temp_dir_path]: #fs.op.temp_dir_path
+[fs.op.weakly_canonical]: #fs.op.weakly_canonical
+[fs.path.append]: #fs.path.append
+[fs.path.assign]: #fs.path.assign
+[fs.path.compare]: #fs.path.compare
+[fs.path.concat]: #fs.path.concat
+[fs.path.construct]: #fs.path.construct
+[fs.path.cvt]: #fs.path.cvt
+[fs.path.decompose]: #fs.path.decompose
+[fs.path.factory]: #fs.path.factory
+[fs.path.fmt.cvt]: #fs.path.fmt.cvt
+[fs.path.gen]: #fs.path.gen
+[fs.path.generic]: #fs.path.generic
+[fs.path.generic.obs]: #fs.path.generic.obs
+[fs.path.io]: #fs.path.io
+[fs.path.itr]: #fs.path.itr
+[fs.path.member]: #fs.path.member
+[fs.path.modifiers]: #fs.path.modifiers
+[fs.path.native.obs]: #fs.path.native.obs
+[fs.path.nonmember]: #fs.path.nonmember
+[fs.path.query]: #fs.path.query
+[fs.path.req]: #fs.path.req
+[fs.path.type.cvt]: #fs.path.type.cvt
+[fs.race.behavior]: #fs.race.behavior
+[fs.rec.dir.itr.members]: #fs.rec.dir.itr.members
+[fs.rec.dir.itr.nonmembers]: #fs.rec.dir.itr.nonmembers
+[fs.req]: #fs.req
+[fs.req.namespace]: #fs.req.namespace
+[fstream]: #fstream
+[fstream.assign]: #fstream.assign
+[fstream.cons]: #fstream.cons
+[fstream.members]: #fstream.members
+[fstream.syn]: #fstream.syn
+[ifstream]: #ifstream
+[ifstream.assign]: #ifstream.assign
+[ifstream.cons]: #ifstream.cons
+[ifstream.members]: #ifstream.members
+[input.iterators]: iterators.md#input.iterators
+[input.output]: #input.output
+[input.output.general]: #input.output.general
+[input.streams]: #input.streams
+[intro.multithread]: intro.md#intro.multithread
+[iomanip.syn]: #iomanip.syn
+[ios]: #ios
+[ios.base]: #ios.base
+[ios.base.callback]: #ios.base.callback
+[ios.base.cons]: #ios.base.cons
+[ios.base.locales]: #ios.base.locales
+[ios.base.storage]: #ios.base.storage
+[ios.members.static]: #ios.members.static
+[ios.overview]: #ios.overview
+[ios.syn]: #ios.syn
+[ios.types]: #ios.types
+[ios::Init]: #ios::Init
+[ios::failure]: #ios::failure
+[ios::fmtflags]: #ios::fmtflags
+[ios::iostate]: #ios::iostate
+[ios::openmode]: #ios::openmode
+[ios::seekdir]: #ios::seekdir
+[iosfwd.syn]: #iosfwd.syn
+[iostate.flags]: #iostate.flags
+[iostream.assign]: #iostream.assign
+[iostream.cons]: #iostream.cons
+[iostream.dest]: #iostream.dest
+[iostream.format]: #iostream.format
+[iostream.forward]: #iostream.forward
+[iostream.forward.overview]: #iostream.forward.overview
+[iostream.limits.imbue]: #iostream.limits.imbue
+[iostream.objects]: #iostream.objects
+[iostream.objects.overview]: #iostream.objects.overview
+[iostream.syn]: #iostream.syn
+[iostreamclass]: #iostreamclass
+[iostreams.base]: #iostreams.base
+[iostreams.limits.pos]: #iostreams.limits.pos
+[iostreams.requirements]: #iostreams.requirements
+[iostreams.threadsafety]: #iostreams.threadsafety
+[istream]: #istream
+[istream.assign]: #istream.assign
+[istream.cons]: #istream.cons
+[istream.extractors]: #istream.extractors
+[istream.formatted]: #istream.formatted
+[istream.formatted.arithmetic]: #istream.formatted.arithmetic
+[istream.formatted.reqmts]: #istream.formatted.reqmts
+[istream.manip]: #istream.manip
+[istream.rvalue]: #istream.rvalue
+[istream.syn]: #istream.syn
+[istream.unformatted]: #istream.unformatted
+[istream::sentry]: #istream::sentry
+[istringstream]: #istringstream
+[istringstream.assign]: #istringstream.assign
+[istringstream.cons]: #istringstream.cons
+[istringstream.members]: #istringstream.members
+[lex.charset]: lex.md#lex.charset
+[locale.codecvt.virtuals]: localization.md#locale.codecvt.virtuals
+[locale.num.get]: localization.md#locale.num.get
+[narrow.stream.objects]: #narrow.stream.objects
+[numeric.limits]: language.md#numeric.limits
+[ofstream]: #ofstream
+[ofstream.assign]: #ofstream.assign
+[ofstream.cons]: #ofstream.cons
+[ofstream.members]: #ofstream.members
+[ostream]: #ostream
+[ostream.assign]: #ostream.assign
+[ostream.cons]: #ostream.cons
+[ostream.formatted]: #ostream.formatted
+[ostream.formatted.reqmts]: #ostream.formatted.reqmts
+[ostream.inserters]: #ostream.inserters
+[ostream.inserters.arithmetic]: #ostream.inserters.arithmetic
+[ostream.inserters.character]: #ostream.inserters.character
+[ostream.manip]: #ostream.manip
+[ostream.rvalue]: #ostream.rvalue
+[ostream.seeks]: #ostream.seeks
+[ostream.syn]: #ostream.syn
+[ostream.unformatted]: #ostream.unformatted
+[ostream::sentry]: #ostream::sentry
+[ostringstream]: #ostringstream
+[ostringstream.assign]: #ostringstream.assign
+[ostringstream.cons]: #ostringstream.cons
+[ostringstream.members]: #ostringstream.members
+[output.streams]: #output.streams
+[quoted.manip]: #quoted.manip
+[res.on.data.races]: library.md#res.on.data.races
+[res.on.exception.handling]: library.md#res.on.exception.handling
+[sstream.syn]: #sstream.syn
+[std.ios.manip]: #std.ios.manip
+[std.manip]: #std.manip
+[stream.buffers]: #stream.buffers
+[stream.types]: #stream.types
+[streambuf]: #streambuf
+[streambuf.assign]: #streambuf.assign
+[streambuf.buffer]: #streambuf.buffer
+[streambuf.cons]: #streambuf.cons
+[streambuf.get.area]: #streambuf.get.area
+[streambuf.locales]: #streambuf.locales
+[streambuf.members]: #streambuf.members
+[streambuf.protected]: #streambuf.protected
+[streambuf.pub.get]: #streambuf.pub.get
+[streambuf.pub.pback]: #streambuf.pub.pback
+[streambuf.pub.put]: #streambuf.pub.put
+[streambuf.put.area]: #streambuf.put.area
+[streambuf.reqts]: #streambuf.reqts
+[streambuf.syn]: #streambuf.syn
+[streambuf.virt.buffer]: #streambuf.virt.buffer
+[streambuf.virt.get]: #streambuf.virt.get
+[streambuf.virt.locales]: #streambuf.virt.locales
+[streambuf.virt.pback]: #streambuf.virt.pback
+[streambuf.virt.put]: #streambuf.virt.put
+[streambuf.virtuals]: #streambuf.virtuals
+[string.classes]: strings.md#string.classes
+[string.streams]: #string.streams
+[stringbuf]: #stringbuf
+[stringbuf.assign]: #stringbuf.assign
+[stringbuf.cons]: #stringbuf.cons
+[stringbuf.members]: #stringbuf.members
+[stringbuf.virtuals]: #stringbuf.virtuals
+[strings]: strings.md#strings
+[stringstream]: #stringstream
+[stringstream.assign]: #stringstream.assign
+[stringstream.cons]: #stringstream.cons
+[stringstream.members]: #stringstream.members
+[tab:enum.path.format]: #tab:enum.path.format
+[tab:enum.perm_options]: #tab:enum.perm_options
+[tab:filesystem_error.1]: #tab:filesystem_error.1
+[tab:filesystem_error.2]: #tab:filesystem_error.2
+[tab:filesystem_error.3]: #tab:filesystem_error.3
+[tab:fs.enum.copy_options]: #tab:fs.enum.copy_options
+[tab:fs.enum.directory_options]: #tab:fs.enum.directory_options
+[tab:fs.enum.file_type]: #tab:fs.enum.file_type
+[tab:fs.enum.perms]: #tab:fs.enum.perms
+[tab:iostreams.basicios.init.effects]: #tab:iostreams.basicios.init.effects
+[tab:iostreams.copyfmt.effects]: #tab:iostreams.copyfmt.effects
+[tab:iostreams.file.open.modes]: #tab:iostreams.file.open.modes
+[tab:iostreams.fmtflags.constants]: #tab:iostreams.fmtflags.constants
+[tab:iostreams.fmtflags.effects]: #tab:iostreams.fmtflags.effects
+[tab:iostreams.iostate.effects]: #tab:iostreams.iostate.effects
+[tab:iostreams.lib.summary]: #tab:iostreams.lib.summary
+[tab:iostreams.newoff.values]: #tab:iostreams.newoff.values
+[tab:iostreams.openmode.effects]: #tab:iostreams.openmode.effects
+[tab:iostreams.position.requirements]: #tab:iostreams.position.requirements
+[tab:iostreams.seekdir.effects]: #tab:iostreams.seekdir.effects
+[tab:iostreams.seekoff.effects]: #tab:iostreams.seekoff.effects
+[tab:iostreams.seekoff.positioning]: #tab:iostreams.seekoff.positioning
+[temp.deduct]: temp.md#temp.deduct
+[time.clock.req]: utilities.md#time.clock.req
+[wide.stream.objects]: #wide.stream.objects
+[^1]: It is the implementation’s responsibility to implement headers so
+    that including `<iosfwd>` and other headers does not violate the
+    rules about multiple occurrences of default arguments.
+[^2]: If it is possible for them to do so, implementations are
+    encouraged to initialize the objects earlier than required.
+[^3]: Constructors and destructors for static objects can access these
+    objects to read input from `stdin` or write output to `stdout` or
+    `stderr`.
+[^4]: Typically `long long`.
+[^5]: `streamsize` is used in most places where ISO C would use
+    `size_t`. Most of the uses of `streamsize` could use `size_t`,
+    except for the `strstreambuf` constructors, which require negative
+    values. It should probably be the signed type corresponding to
+    `size_t` (which is what Posix.2 calls `ssize_t`).
+[^6]: This implies that operations on a standard iostream object can be
+    mixed arbitrarily with operations on the corresponding stdio stream.
+    In practical terms, synchronization usually means that a standard
+    iostream object and a standard stdio object share a buffer.
+[^7]: An implementation is free to implement both the integer array
+    pointed at by `iarray` and the pointer array pointed at by `parray`
+    as sparse data structures, possibly with a one-element cache for
+    each.
+[^8]: for example, because it cannot allocate space.
+[^9]: for example, because it cannot allocate space.
+[^10]: This suggests an infinite amount of copying, but the
+    implementation can keep track of the maximum element of the arrays
+    that is nonzero.
+[^11]: Checking `badbit` also for `fail()` is historical practice.
+[^12]: The function signature `dec(ios_base&)` can be called by the
+    function signature
+    `basic_ostream& stream::operator<<(ios_base& (*)(ios_base&))` to
+    permit expressions of the form `cout << dec` to change the format
+    flags stored in `cout`.
+[^13]: The default constructor is protected for class `basic_streambuf`
+    to assure that only objects for classes derived from this class may
+    be constructed.
+[^14]: `underflow` or `uflow` might fail by throwing an exception
+    prematurely. The intention is not only that the calls will not
+    return `eof()` but that they will return “immediately”.
+[^15]: Classes derived from `basic_streambuf` can provide more efficient
+    ways to implement `xsgetn()` and `xsputn()` by overriding these
+    definitions from the base class.
+[^16]: That is, for each class derived from an instance of
+    `basic_streambuf` in this Clause ([[stringbuf]],
+    [[filebuf]]), a specification of how consuming a character
+    effects the associated output sequence is given. There is no
+    requirement on a program-defined class.
+[^17]: Typically, `overflow` returns `c` to indicate success, except
+    when `traits::eq_int_type(c, traits::eof())` returns `true`, in
+    which case it returns `traits::not_eof(c)`.
+[^18]: This will be possible only in functions that are part of the
+    library. The semantics of the constructor used in user code is as
+    specified.
+[^19]: The sentry constructor and destructor can also perform additional
+    implementation-dependent operations.
+[^20]: This is done without causing an `ios::failure` to be thrown.
+[^21]: See, for example, the function signature
+    `ws(basic_istream&)` ([[istream.manip]]).
+[^22]: See, for example, the function signature
+    `dec(ios_base&)` ([[basefield.manip]]).
+[^23]: This is done without causing an `ios::failure` to be thrown.
+[^24]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^25]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^26]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^27]: Since the final input character is “extracted”, it is counted in
+    the `gcount()`, even though it is not stored.
+[^28]: This allows an input line which exactly fills the buffer, without
+    setting `failbit`. This is different behavior than the historical
+    AT&T implementation.
+[^29]: This implies an empty input line will not cause `failbit` to be
+    set.
+[^30]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^31]: The call `os.tie()->flush()` does not necessarily occur if the
+    function can determine that no synchronization is necessary.
+[^32]: The `sentry` constructor and destructor can also perform
+    additional implementation-dependent operations.
+[^33]: without causing an `ios::failure` to be thrown.
+[^34]: See, for example, the function signature
+    `endl(basic_ostream&)` ([[ostream.manip]]).
+[^35]: See, for example, the function signature
+    `dec(ios_base&)` ([[basefield.manip]]).
+[^36]: without causing an `ios::failure` to be thrown.
+[^37]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^38]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^39]: The expression `cin >> resetiosflags(ios_base::skipws)` clears
+    `ios_base::skipws` in the format flags stored in the
+    `basic_istream<charT, traits>` object `cin` (the same as
+    `cin >> noskipws`), and the expression
+    `cout << resetiosflags(ios_base::showbase)` clears
+    `ios_base::showbase` in the format flags stored in the
+    `basic_ostream<charT, traits>` object `cout` (the same as
+    `cout << noshowbase`).
+[^40]: The macro `SEEK_END` is defined, and the function signatures
+    `fopen(const char*, const char*)` and `fseek(FILE*, long, int)` are
+    declared, in `<cstdio>` ([[cstdio.syn]]).
+[^41]: POSIX® is a registered trademark of The IEEE. Windows® is a
+    registered trademark of Microsoft Corporation. This information is
+    given for the convenience of users of this document and does not
+    constitute an endorsement by ISO or IEC of these products.

Diff to HTML by rtfpessoa