cpp_new_features
1.0.0
The history of the C++ programming language goes back to 1979 , when Bjarne Stroustrup carried out some development for his doctoral thesis. Of all the languages that Stroustrup can use, there is one called Simula, which, as the name suggests, may be a language designed primarily for simulation. The Simula 67 language is a variant used by Stroustrup and is considered the primary language supporting the object-oriented programming paradigm. Stroustrup finds this paradigm helpful in packaging development. However, the Simula language is too slow for practical and practical use. Shortly thereafter, Bjarne Stroustrup wanted to enhance C by supporting the object-oriented paradigm. He delved into Smalltalk's OO implementation to get implementation ideas. But he was unwilling to give up performance for this, so he started working on "C with Classes (C with classes)", hoping that C++ code should have similar (or better) performance to C code when running.
In 1983 , the name of the language was changed from "C with Classes" to C++. The ++ operator in C is the operator for incrementing variables, which gives you some insight into how Stroustrup views the language. Many new features were added during this period, the most notable of which are virtual functions, function overloading, references with an ampersand, the const keyword, and single-line comments using two forward slashes.
In 1985 , Stroustrup published a book called "The C++ Programming Language". In the same year, C++ was implemented as a commercial product. The language has not been formally standardized, making this book a very important reference. The language was updated again in 1989 to include protected and static members, as well as inheritance from multiple classes.
In 1990 , the Annotated C++ Reference Manual was released. That same year, Borland's Turbo C++ compiler would be released as a commercial product. Turbo C++ adds many other libraries that can have a considerable impact on C++ development. Although the last stable version of Turbo C++ was in 2006, the compiler is still widely used.
In 1998 , the C++ Standards Committee published the first C++ ISO/IEC 14882:1998 International Standard, informally known as C++98. It is said that the "Annotated C++ Reference Manual" had a great influence on the formulation of the standard. Also included is the Standard Template Library, which concept development began in 1979. In 2003, the committee responded to several issues reported in the 1998 standards and revised them accordingly. The changed language is called C++03.
In 2005 , the C++ Standards Committee published a technical report (called TR1) detailing various features they planned to add to the latest C++ standard. The new standard is informally known as C++0x because it is expected to be released sometime before the end of the first decade. Ironically, the new standard won't be released until mid-2011. Up to that point, several technical reports had been published, and some compilers had begun adding experimental support for new features.
In mid-2011 , the new C++ standard (called C++11) was completed. The Boost library project had a significant impact on the new standard, with some of the new modules coming directly from the corresponding Boost libraries. Some of the new features include regular expression support, a comprehensive randomization library, a new C++ timing library, atomic support, a standard threading library, a new for loop syntax that provides functionality similar to foreach loops in some other languages, auto keyword, new container classes, better support for union and array initializer lists, and variadic templates.
In 2014 , C++ 14 (also known as C++ 1y) was released as a small extension of C++11. Its main functions are bug fixes and small improvements. The draft international standard voting procedure was completed in mid-August 2014 to strengthen the lambda function. constexpr and type inference features.
In 2017 , the C17 standard was released. C17 offers a lot. Enhancements to the core language and libraries.
In 2020 , the C++20 standard was released, launching many heavyweight features, the more important of which are:
Concepts: Concepts change the way we think about and program templates. They are semantic categories of template parameters. They allow you to express your intentions directly in the type system. If something goes wrong, you'll receive clear error messages.
Ranges library: The new ranges library makes it possible to execute algorithms directly on containers, compose them with pipe notation, and apply them to infinite data streams.
Coroutines: Asynchronous programming in C++ goes mainstream thanks to coroutines. Coroutines are the basis for collaborative tasks, event loops, infinite data streams or pipelines.
Modules: Modules overcome the limitations of header files. The separation of header files and source files has become as obsolete as preprocessors. Finally, we have faster build times and an easier way to build packages.
Concurrency: Atomic Smart Pointers, Joining & Cancellable Threads, The C20 Synchronization Library, which enhances C++ concurrent programming capabilities;
C++ tutorial
Introduction to C++
C++ environment settings
C++ basic syntax
C++ comments
C++ data types
C++ variable types
C++ variable scope
C++ constants
C++ modifier types
C++ storage class
C++ operators
C++ loop
C++ judgment
C++ function
C++ numbers
C++ array
C++ string
C++ pointers
C++ references
C++ Date & Time
C++ basic input and output
C++ data structures
C++ classes & objects
C++ inheritance
C++ overloaded operators and overloaded functions
C++ polymorphism
C++ data abstraction
C++ data encapsulation
C++ interface (abstract class)
C++ files and streams
C++ exception handling
C++ dynamic memory
C++ namespace
C++ template
C++ preprocessor
C++ signal processing
C++ multithreading
C++ Web Programming
C++ STL Tutorial
C++ standard library
1. Basic knowledge
8.1 Basic concepts of structures
8.2 Structure definition and usage
8.3 Structure array
8.4 Structure pointer
8.5 Structure Nested Structure
8.6 Structure as function parameter
8.7 Const usage scenarios in structures
7.1 Basic concepts of pointers
7.2 Definition and use of pointer variables
7.3 Memory space occupied by pointers
7.4 Null pointers and wild pointers
7.5 const modified pointer
7.6 Pointers and arrays
7.7 Pointers and functions
7.8 Pointers, arrays, functions
1. goto statement (not recommended)
2. One-dimensional array
3. Two-dimensional array
4. Value transfer in functions
5. Function declaration
6. Writing functions in separate files
7. Pointer
8. Structure
2. Core Programming
3.1 Function default parameters
3.2 Function place parameters
3.3 Function overloading
2.1 Basic use of references
2.2 Notes on citation
2.3 Reference as function parameter
2.4 Reference as function return value
2.5 The nature of citations
2.6 Constant references
1.1 Before running the program
1.2 After running the program
1.3 new operator
1. Memory partition model
2. Quote
3. Function
"In-depth understanding of C++11: Analysis and application of new features of C++11"
"C++ Introductory Classic (10th Edition)"
"C++ Primer Plus 6th Edition Chinese Version (produced by Asynchronous Books)"
"Tsinghua Computer Book Translation Series: Mastering C++ (9th Edition)"
"Advanced Programming in C++ (4th Edition)"
"Introduction to C++ Game Programming (4th Edition) (produced by Asynchronous Books)"
"STL Source Code Analysis"
"C++ Programming: Principles and Practice (Basics) (Original Book 2nd Edition)"
"Accelerated C++ Chinese version"
"C++ Programming Thoughts (Two Volumes)"
"Chinese version of Effective STL: 50 experiences in using STL effectively"
"Anatomy of C++ Programming: Problems, Solutions, and Design Guidelines"
"C++ Templates Chinese version"
"New Thinking in C++ Design"
"C++ Template Metaprogramming"
"C++ Concurrent Programming Practice"
"C++ Programming Language (Part 1-3) (Original Book 4th Edition)"
"C++ Standard Library (2nd Edition)"
"Essential C++"
"The Design and Evolution of the C++ Language"
"In-depth exploration of the C++ object model"
"Generic Programming and STL"
10 C++11 features every C++ developer should use
15 C++11 features you must actually use in your C++ projects
How to use Lambda expressions in C++11
Deep understanding of C++11
Blood vomiting sorting: new features of C++11
C++11 new features auto and decltype knowledge points
C++11 new features: lvalue reference, rvalue reference, move semantics, perfect forwarding
C++11 new features list initialization
C++11 new features std::function and lambda expressions
C++11 new features: template improvements
C++11 new features and thread-related knowledge points
C++11 new features asynchronous operations-async
C++11 new features smart pointers
Common new features of C++11 (1)
Common new features of C++11 (2)
A brief discussion on the new features of C++14
All the knowledge points about the new features of C++14 are here
Summary: New features of C++17
C++20 language features
P1 Introduction to C++ Programming
P2 header file and class declaration
P3 constructor
P4 parameter transfer and return value
P5 operator overloading and temporary objects
P6 Review the implementation process of Complex class
P7 three major functions: copy construction, copy replication, and destruction
P8 Heap, stack and memory management
P9 Review the implementation process of String class
P10 extensions: class templates, function templates, and others
P11 Composition and inheritance
P13 Commission related designs
P14 1 Introduction
P15 2 conversion function
P16 3 non explicit one argument constructor
P17 4 pointer like classes
P18 5 function like classes
P19 6 namespace experience discussion
P20 7 class template
P21 8 Function Template
P22 9 Member Template
P23 10 specialization
P24 11 Template Partial Specialization
P25 12 template template parameters
P26 13 About the C++ standard library
P27 14 Three themes
P28 15 Reference
P29 16 Construction and destruction under composite & inheritance relationship
P30 17 About vptr and vtbl
P31 18 About this
P32 19 0 About Dynamic Binding
P33 19 1 About Dynamic Binding
P34 20 About New,Delete
P35 21 Operator new, operator delete
P36 22 Example
P37 23 Overloading new,delete$ example
P38 24 Basic String uses newextra to expand application volume
C++ Standard Library - a collection of classes and functions written in the core language and part of the C++ ISO standard itself
Standard Template Library - Standard Template Library
C POSIX library - C standard library specification for POSIX systems
ISO C++ Standards Committee - C++ Standards Committee
C++ FAQ − C++ Frequently Asked Questions
Free Country − Free Country provides free C++ source code and C++ libraries that cover C++ programming fields such as compression, archiving, game programming, standard template libraries, and GUI programming.
C and C++ Users Group − The C and C++ user group provides free source code for C++ projects covering various programming fields, including AI, animation, compilers, databases, debugging, encryption, games, graphics, GUI, language tools, System programming, etc.
LearnCpp - Learn c++ programming for free
CodeCogs - CodeCogs is a collaborative open source library of numerical components for C/C++
codeproject - C/C++ resource code project provided by codeproject
thoughtco - game-related C++ source code
Free C/C++ Libraries - Free C++ source code and other useful tools
The C++ Standard Library - This is a webpage that collects a list of links to several C/C++ websites
cplusplus - C++ learning website
C++ Source Codes - This is a comprehensive list of 345 source codes for C++
Apache C++ Standard Library: is a collection of algorithms, containers, iterators and other basic components
ASL: Adobe Source Code Library provides a peer-reviewed and portable C++ source code library.
Boost: A large collection of general-purpose C++ libraries.
BDE: Development environment from Bloomberg Intelligence Labs.
Cinder: An open source development community that provides professional-quality creative coding.
Bxxomfort: A lightweight, header-only library that ports some of the new features of C++11 to C++03.
Dlib: A universal cross-platform C++ library designed using contract programming and modern C++ technology.
EASTL: EA-STL public part
ffead-cpp: Enterprise application development framework
Folly: An open source C++ library developed and used by Facebook.
JUCE: A comprehensive C++ library for developing cross-platform software
libphenom: An event framework for building high-performance and highly scalable systems.
LibSourcey: C++11 evented IO for real-time video streaming and high-performance network applications
Loki: The design of a C++ library, including implementation of common design patterns and idioms.
MiLi: A small header-only C++ library
openFrameworks: Develop C++ toolkit for creative coding.
Qt: Cross-platform application and user interface framework
Reason: A cross-platform framework that makes it easier for developers to use Java, .Net and Python, while also meeting their needs for the performance and advantages of C++.
ROOT: A set of object-oriented frameworks with all the functionality to process and analyze large amounts of data very efficiently, used by CERN.
STLport: is a representative version of STL
STXXL: Standard template library for additional large data sets.
Ultimate++: C++ cross-platform rapid application development framework
Windows Template Library : C++ library for developing Windows applications and UI components
Yomm11: Open multi-methods for C++11.
Boost.Asio: Cross-platform C++ library for network and low-level I/O programming.
libev: Full-featured, high-performance time loop, slightly modeled after libevent, but no longer has the same limitations as libevent, and some of its bugs have been fixed.
libevent: event notification library
libuv: Cross-platform asynchronous I/O.
libco: coroutine, WeChat’s underlying IO library that supports 800 million users online at the same time. Powerful
libgo: Golang-style concurrency framework, C++11 implementation coroutine library
ACE: C++ Object-Oriented Networking Toolkit
Casablanca: C++ REST SDK
cpp-netlib: A collection of open source libraries for advanced network programming
libCurl: multi-protocol file transfer library
Mongoose: Very lightweight web server
Muduo: C++ non-blocking network library for Linux multi-threaded servers
net_skeleton: TCP client/server library for C/C++
POCO: C++ class library for building network and Internet-based applications that can run on desktop, server, mobile and embedded systems.
RakNet: A cross-platform, open source C++ network engine for game developers.
Tufao: An asynchronous web framework built in C++ on top of Qt.
WebSocket++: websocket client/server library based on C++/Boost Aiso
ZeroMQ: High-speed, modular asynchronous communication library
f-stack: Tencent’s open source protocol stack, a high-performance user-mode protocol stack based on DPDK.
NtyTcp: Single-threaded protocol stack, based on netmap, DPDK, rawSocket implementation.
LWIP: A streamlined version of the TCP/IP protocol stack implementation for the RAM platform.
mTCP: A highly scalable user-space TCP/IP protocol stack for multi-core systems.
4.4BSD: * The nix protocol stack is derived from 4.4BSD.
Nginx: A high-performance HTTP and reverse proxy web server that also provides IMAP/POP3/SMTP services.
Lighttpd: An open source web server software that is secure, fast, compliant with industry standards, highly adaptable and optimized for high-configuration environments.
Libmicrohttpd: A simple c library web server under GNU software. The API is simple and fast.
shttpd: Mongoose-based web server framework.
CivetWeb: Provides an easy-to-use, powerful, C/C++ embedded web server with optional CGI, SSL and Lua support.
CppCMS: Free high-performance web development framework (not a CMS).
Crow: A C++ micro web framework (inspired by Python Flask)
Kore: Ultra-fast and flexible web server/framework for web applications developed in C.
libOnion: A lightweight library that helps you create web servers using the C programming language.
QDjango: A web framework written in C++ and based on the Qt library, trying to emulate the Django API, hence the name.
Wt: C++ library for developing web applications.
C++ Standard Library: It is a collection of classes and functions written in the core language and is part of the C++ ISO standard itself.
Standard Template Library: Standard Template Library, STL
ISO C++ Standards Committee : C++ Standards Committee
FMOD: Easy-to-use cross-platform audio engine and audio content game creation tool.
Maximilian: C++ audio and music digital signal processing library
OpenAL: Open source audio library—cross-platform audio API
Opus: a completely open, royalty-free, highly versatile audio codec
Speex: Free codec, deprecated by Opus
Tonic: Easy-to-use and efficient audio synthesis in C++
Vorbis: Ogg Vorbis is a completely open, non-proprietary, royalty-free universal compressed audio format.
lisequence : A C++ library for representing and analyzing population genetics data.
SeqAn: Focuses on algorithms and data structures for sequence analysis of biological data.
Vcflib: C++ library for parsing and processing VCF files
Wham: Apply association testing directly to genetic structural variants in BAM files.
bzip2 : A completely free, patent-free and high-quality data compression
doboz: compression library for fast decompression
PhysicsFS: A library that provides abstract access to various archives, mainly used in video games. The design was partly inspired by Quake3's file subsystem.
KArchive: A library for creating, reading, writing, and manipulating file archives (such as zip and tar), which provides transparent compression and decompression of data using the gzip format through a series of subclasses of QIODevice.
LZ4: Very fast compression algorithm
LZHAM: Lossless compression database, the compression ratio is close to LZMA, but the decompression speed is much faster.
LZMA: The default and common compression method for the 7z format.
LZMAT: and its fast real-time lossless data compression library
Minizip: Zlib's latest bug fix, supports PKWARE disk spanning, AES encryption and IO buffering.
Snappy: fast compression and decompression
ZLib: Very compact data stream compression library
ZZIPlib: Provides read access to ZIP archives.
Boost.Compute: C++ GPU computing library for OpenCL
Bolt: A C++ template library optimized for GPUs
C++React: Reactive programming library for C++11
Intel TBB: Intel Threading Building Blocks
Libclsph: GPU-accelerated SPH fluid simulation library based on OpenCL
OpenCL: An open standard for parallel programming of heterogeneous systems
OpenMP: OpenMP API
Thrust: A parallel algorithm library similar to the C++ Standard Template Library
HPX: A universal C++ runtime system for parallel and distributed applications of any size
VexCL: C++ vector expression template library for OpenCL/CUDA.
Bcrypt: A cross-platform file encryption tool, encrypted files are portable to all supported operating systems and processors.
BeeCrypt: A fast encryption graphics library with powerful functions and convenient interface.
Botan: C++ encryption library
Crypto++ : A free C++ library for encryption schemes
GnuPG: A complete implementation of the OpenPGP standard
GnuTLS: A secure communication library that implements SSL, TLS and DTLS protocols
Libgcrypt: GnuPG-based encryption graphics library.
Libmcrypt: Thread-safe, providing a unified API.
LibreSSL: Free SSL/TLS protocol, a fork of 2014 OpenSSL
LibTomCrypt: A very comprehensive, modular, and portable encryption tool
libsodium: NaCI-based encryption library that is opinionated and easy to use
Nettle: the underlying encryption library
OpenSSL: A powerful, commercial, full-featured, open source encryption library.
hiberlite: C++ object-relational mapping for Sqlite3
LevelDB: fast key-value store
LMDB: an embedded key-value store that conforms to the four basic elements of a database
MySQL++ : A C++ wrapper that encapsulates the C API of MySql
RocksDB: Fast storage of embedded key-values from Facebook
SQLite : A fully embedded, full-featured relational database that is only a few hundred KB and can be included correctly into your project.
MongoDB: a database based on distributed file storage
Boost.Test: Boost testing library
Catch: A very stylish, C++ native framework that only contains header files for unit testing, test-driven development and behavior-driven development.
CppUnit: C++ testing framework ported from JUnit
GoogleTest: Google C++ testing framework
ig-debugheap: Multi-platform debug heap for tracking memory errors
MemTrack: for tracking memory allocations in C++
MicroProfile: Cross-platform network attempt profiler
UnitTest++: lightweight C++ unit testing framework
C++ B-Tree: A template library that implements command memory containers based on the B-tree data structure
Hashmaps: Implementation of open addressing hash table algorithm in C++
Cocos2d-x: A cross-platform framework for building 2D games, interactive books, presentations and other graphics applications.
Grit: A community project to build a free game engine for open-world 3D games.
lrrlicht: an open source high-performance real-time #D engine written in C++ language
PolyCode: An open source framework for creating games implemented in C++ (bundled with Lua).
bgfx: cross-platform rendering library
Cairo: 2D graphics library supporting multiple output devices
Horde3D: A small 3D rendering and animation engine
magnum: C++11 and OpenGL 2D/3D graphics engine
Ogre 3D: A scene-oriented, real-time, flexible 3D rendering engine written in C++ (not a game engine)
OpenSceneGraph: High-performance open source 3D graphics toolkit
Panda3D: Framework for 3D rendering and game development, written in Python and C++.
Skia: A complete 2D graphics library for drawing text, graphics and images
urho3d: Cross-platform rendering and game engine.
Boost.GIL: General image library
CImg: A small open source C++ toolkit for image processing
FreeImage: An open source library that supports common image formats and other formats required by today's multimedia applications.
GDCM: Grassroots DICOM library
ITK: Cross-platform open source image analysis system
Magick++: C++ interface to the ImageMagick program
OpenCV: Open source computer vision library
tesseract-ocr: OCR engine
VIGRA: General-purpose C++ computer vision library for image analysis
VTK: Open source free software system for 3D computer graphics, image processing and visualization.
gettext : GNU gettext
IBM ICU: C, C++ and Java libraries providing Unicode and globalization support
libiconv: encoding conversion library between different character encodings
frozen: Jason parsing generator for C/C++
Jansson: C language library for encoding, decoding and processing Jason data
jbson: A library for building and iterating BSON data, and Json documents in C++14
JeayeSON: A very robust C++ JSON library that only contains header files
JSON++ : C++ JSON parser
json-parser : JSON parser written in portable ANSI C with very low memory footprint
json11 : A mini C++11 JSON library
jute : Very simple C++ JSON parser
ibjson: JSON parsing and printing library in C, easily integrated with any model
libjson: lightweight JSON library
PicoJSON: JSON parsing and serialization in C++, including only header files
Qt-Json: A simple class for parsing between JSON data and QVariant hierarchies
QJson : Qt-based library for mapping JSON data to QVariant objects
RepidJSON: A fast JSON parsing generator for C++, including SAX and DOM style APIs
Boost.Log: Designed to be very modular and extensible
easyloggingpp: C++ logging library, containing only a single header file.
Log4cpp: A series of C++ libraries that flexibly add logs to files, system logs, IDSA and other places.
templog : A lightweight C++ library that can add logging to your C++ applications
btsk: Game behavior tree launcher tool
Evolving Objects: Template-based, ANSI C++ evolutionary computing library that can help you write your own stochastic optimization algorithms very quickly.
Caffe: a fast neural network framework
CCV: A modern computer vision library with C language as its core
mlpack: Extensible C++ machine learning library
OpenCV: Open source computer vision library
Recommender: A C library for product recommendations/suggestions using collaborative filtering.
SHOGUN: Shogun machine learning tool
sofia-ml: A suite of fast incremental algorithms for machine learning
Armadillo: A high-quality C++ linear algebra library that strikes a good balance between speed and ease of use. The syntax is very similar to MatlAB
blaze: High-performance C++ math library for dense and sparse algorithms.
ceres-solver: A C++ library from Google for modeling and solving large complex nonlinear least squares problems.
CGal: A collection of efficient, reliable set algorithms
CML: Free C++ math library for games and graphics
Eigen: A high-level C++ template header library covering linear algebra, matrix, vector operations, numerical solving and other related algorithms.
GMTL: Mathematical Graphics Template Library is a set of tools for implementing basic graphics extensively.
GMP: A C/C++ library for high-precision calculations, dealing with signed integers, rational numbers and floating point numbers.
GStreamer: A library for building graphs of media processing components
LIVE555 Streaming Media: Multimedia streaming library using open standard protocols (RTP/RTCP, RTSP, SIP)
libVLC: libVLC (VLC SDK) media framework
QtAV: A multimedia playback framework based on Qt and FFmpeg that can help you easily write a player
SDL: Simple direct control of the media layer
SFML: Fast, simple multimedia library
Box2D: 2D game physics engine.
Bullet: 3D game physics engine.
Chipmunk: Fast, lightweight 2D game physics library
LiquidFun: 2D game physics engine
ODE: Open Dynamics Engine - an open source, high-performance library for simulating rigid body dynamics.
ofxBox2D: Box2D open source framework wrapper.
Simbody: A high-performance C++ multibody dynamics/physics library for simulating joint biomechanics and mechanical systems like vehicles, robots, and human skeletons.
MOOS-Ivp: A set of open source C++ modules that provide autonomy for robotic platforms, specifically autonomous marine vehicles.
MRPT: Mobile Robot Programming Toolkit
PCL: Point Cloud Library is an independent, large-scale open project for 2D/3D image and point cloud processing.
Robotics Library: A stand-alone C++ library including robot dynamics, motion planning and control.
RobWork: A collection of C++ libraries for simulation and control of robotic systems.
ROS: Robot Operating System, which provides libraries and tools to help software developers create robot applications.
ChaiScript: An easy-to-use embedded scripting language for C++.
Lua: A small and fast scripting engine for configuration files and basic application scripts.
luacxx : C++11 API for creating Lua bindings
SWIG : A wrapper/interface generator that lets your C++ code link to JavaScript, Perl, PHP, Python, Tcl and Ruby
V7: Embedded JavaScript engine.
V8: Google's fast JavaScript engine that can be embedded into any C++ application.
Cap'n Proto: Fast data exchange format and RPC system.
cereal : C++11 serialization library
FlatBuffers: Memory-efficient serialization library
MessagePack: Efficient binary serialization library for C/C++, such as JSON
ProtoBuf: Protocol buffer, Google's data exchange format.
SimpleBinaryEncoding : Encoding and decoding of application information in binary format for low-latency applications.
Thrift: Efficient cross-language IPC/RPC, used in C++, Java, Python, PHP, C# and many other languages, originally developed by Facebook.
libvpx: VP8/VP9 encoding and decoding SDK
FFMpeg: A complete, cross-platform solution for recording, converting video and audio streams.
libde265: Open implementation of the h.265 video codec.
OpenH264: Open source H.364 codec.
Theora: Free and open source video compression format.
LibXml++: xml parser for C++
PugiXML: A lightweight, simple and fast XML parser for C++ that supports XPath.
RapidXML: Attempts to create the fastest XML parser while maintaining ease of use, portability, and reasonable W3C compatibility.
TinyXML: A simple and small C++ XML parser that can be easily integrated into other projects.
TinyXML2: A simple and fast C++ CML parser that can be easily integrated into other projects.
TinyXML++ : A completely new interface to TinyXML that takes advantage of many of the advantages of C++, templates, exceptions and better exception handling.
Xerces-C++: XML validation parser written in a subset of portable C++.
thread_local
static_assert
nullptr
noexcept
decltype
constexpr
char16_t
char32_t
alignof
alignas
auto
class
default
delete
export
extern
inline
mutable
sizeof
struct
using
is_void
is_integral
is_floating_point
is_array
is_enum
is_union
is_class
is_function
is_pointer
is_lvalue_reference
is_rvalue_reference
is_member_object_pointer
is_member_function_pointer
is_fundamental
is_arithmetic
is_scalar
is_object
is_compound
is_reference
is_member_pointer
is_const
is_volatile
is_trivial
is_trivially_copyable
is_standard_layout
is_literal_type
is_empty
is_polymorphic
is_abstract
is_signed
is_unsigned
is_constructible
is_trivially_constructible
is_nothrow_constructible
is_default_constructible
is_trivially_default_constructible
is_nothrow_default_constructible
is_copy_constructible
is_trivially_copy_constructible
is_nothrow_copy_constructible
is_move_constructible
is_trivially_move_constructible
is_nothrow_move_constructible
is_assignable
is_trivially_assignable
is_nothrow_assignable
is_copy_assignable
is_trivially_copy_assignable
is_nothrow_copy_assignable
is_move_assignable
is_trivially_move_assignable
is_nothrow_move_assignable
is_destructible
is_trivially_destructible
is_nothrow_destructible
has_virtual_destructor
std::array
std::forward_list
std::begin
std::end
std::move
Container initialization
emplace
std::unordered_map
std::unordered_multimap
std::unordered_set
std::unordered_multiset
std::make_tuple
std::get
std::tie
std::hash<std::string>
std::hash<std::u16string>
std::hash<std::u32string>
std::hash<std::wstring>
std::hash<std::error_code>
std::hash<std::bitset>
std::hash<std::type_index>
std::hash<std::vector<bool>>
std::shared_ptr
std::weak_ptr
std::unique_ptr
auto_ptr (deprecated)
basic_regex
sub_match
match_results
cv qualified function
quotation qualification
std::function
std::bind
std::bad_function_call
mem_fn
type alias
Class member initialization
functor
delegate constructor
Inherit constructor
move constructor
move assignment operator
Angle brackets ">"
Alias template
external template
variadic template
Default template parameters
std::atomic<bool>
std::atomic<char>
std::atomic<signed char>
std::atomic<unsigned char>
std::atomic<short>
std::atomic<unsigned short>
std::atomic<int>
std::atomic<unsigned int>
std::atomic<long>
std::atomic<unsigned long>
std::atomic<long long>
std::atomic<unsigned long long>
std::atomic<char8_t>
std::atomic<char16_t>
std::atomic<char32_t>
std::atomic<wchar_t>
std::atomic<std::int8_t>
std::atomic<std::uint8_t>
std::atomic<std::int16_t>
std::atomic<std::uint16_t>
std::atomic<std::int32_t>
std::atomic<std::uint32_t>
std::atomic<std::int64_t>
std::atomic<std::uint64_t>
std::atomic<std::int_least8_t>
std::atomic<std::uint_least8_t>
std::atomic<std::int_least16_t>
std::atomic<std::uint_least16_t>
std::atomic<std::int_least32_t>
std::atomic<std::uint_least32_t>
std::atomic<std::int_least64_t>
std::atomic<std::uint_least64_t>
std::atomic<std::int_fast8_t>
std::atomic<std::uint_fast8_t>
std::atomic<std::int_fast16_t>
std::atomic<std::uint_fast16_t>
std::atomic<std::int_fast32_t>
std::atomic<std::uint_fast32_t>
std::atomic<std::int_fast64_t>
std::atomic<std::uint_fast64_t>
std::thread
std::mutex
std::lock
std::call_once
std::atomic
std::cond_ition_variable
std::async
volatile
std::future
std::thread_local
std::exception_ptr
std::make_exception_ptr
std::current_exception
std::rethrow_exception
std::nested_exception
std::throw_with_nested
std::rethrow_if_nested
std::error_category
std::generic_category
std::error_condition
std::errc
std::error_code
std::system_error
Syntax: __pragma (string literal)
_Pragma operator
_cplusplus macro
for loop for(x:range)
alignof
alignas
std::alignment_of
std::aligned_storage
std::max_align_t
std::align
explicit keyword
Syntax: static_assert(constant expression, "prompt string")
static assert
numerical limit
raw string
Trace return type syntax
Extended friend syntax
extended integer
unrestricted association
inline namespace
user-defined literal
Strongly typed enums
random device
std::ref and std::cref
constexpr
lambda expression
nullptr
Prevent type narrowing
Initializer List——Initializer List
initializer_list (as input parameter)
Unified initialization syntax and semantics
POD
long long
move semantics
rvalue reference
c99 features
generalized SFINAE rules
Check if the type is std::nullptr_t
is_final (check whether the type is final class type)
exchange(replace the actual parameter with a new value and return its previous value)
integer_sequence (implementation of compile-time integer sequence)
rbegin (returns a reverse iterator pointing to a container or array)
crbegin (returns a reverse iterator pointing to a container or array)
rend (returns the reverse tail iterator of the container or array)
crend (returns the reverse tail iterator of the container or array)
make_reverse_iterator (Create std::reverse_iterator with types deduced from arguments)
Begin
CBegin
end
CEND (back to the iterator ending at the container or the end of the array)
RBegin
CRBEGIN
REND (Return to container or the reverse tail iterator of the array)
Crend (Return to container or reverse tail iterator of an array)
register
byte (byte type)
is_aggregate (Check whether the type of aggregation)
IS_SWAppable_with (Check whether an object of a type can be exchanged with the same type or different types of objects)
IS_SWAPPABL
is_nothrow_swappable_with (Check whether an object of a type can be exchanged with the same type or different types of objects)
is_nothrow_swappable (Check whether an object of a type can be exchanged with the same type or different types of objects)
Is_invocable (check whether the type can be called in a given solid type type (like std :: invoke))
is_invocable_r (the check type can be called in a given solid type type (like std :: Invoke))
is_nothrow_invocable (check whether the type can be called in a given solid parameter type (like std :: Invoke))
Is_nothRow_inVocable_r (Check the type can be called in a given solid parameter type (like std :: invoke))
Invoke_result
void_t
Conjunction
disjunch
NDISJUNCTIONEGATION
Integral_Constant
as_const
Apply (call the function with a solid parameter)
Make_from_tuple
Optional
Make_optingal (Create an Optional object)
STD :: SWAP (STD :: Optional) (Specialized STD :: SWAP algorithm)
STD :: Hash <std :: Optional> (Specialized STD :: Hash Algorithm)
NULLOPT_T
bad_optingal_access (indicated that there are inspection and access of Optional that is not included in Optional)
nullopt (NULLOPT_T type object)
Variant (type safe recognizable consortium)
VISIT
Holds_alternative
STD :: get (std :: variant) (to read the value of variant with a given index or type (if the type is unique), throw abnormality when the error is wrong)
Get_if (if the index or type (if its only), get a pointer pointed to the value pointed to the value of the Variant, return the empty pointer when the error is wrong)
STD :: SWAP (STD :: Variant) (Specialized STD :: SWAP algorithm)
Monostate
BAD_VARIANT_ACCESS (the exception thrown when illegally visited the value of Variant)
variant_size
variant_size_v (The size of the Variant option list when compiling)
variant_alternative
variant_alternative_t
STD :: Hash <std :: variant> (Specialized STD :: Hash Algorithm)
Variant_npos
Any
STD :: SWAP (STD :: ANY) (Specialized STD :: SWAP algorithm)
Any_cast (Safety access to the type of the object of the accommodation)
make_any (Create any object)
BAD_ANY_CAST (the exception thrown by the form when the type is not matched by the value)
To_Chars (converted integer or floating point value to character sequences)
From_chaars (converted character sequence to integer or floating point value)
chars_Format
Empty (check whether the container is empty)
Data
Insert_or_assign (inserted element, or if the key exists, it is assigned to the current element)
Try_emplace (if the key does not exist, insert it in place, if the key exists, you will not do anything)
Extract (release node from another container)
Merge (from another container joint node)
Insert_or_assign (inserted element, or if the key exists, it is assigned to the current element)
Try_emplace (if the key does not exist, insert it in place, if the key exists, you will not do anything)
Extract (release node from another container)
Merge (from another container joint node)
<h5 id = "user-confp_headfile_initializer_list" tabindex = "-1" class = "head
