C ++

from Wikipedia, the free encyclopedia
C ++
ISO C ++ Logo.svg
Basic data
Paradigms : Multiparadigms ( generic , imperative , object-oriented , procedural , structured , functional )
Publishing year: 1985
Designer: Bjarne Stroustrup
Developer: Bjarne Stroustrup
Current  version : C ++ 17   (December 1, 2017)
Current preliminary version: C ++ 20   ()
Typing : static (dynamic type checking possible) , implicit, strong
Important implementations : C ++ Builder , GCC , MS Visual C ++ , Intel C ++ Compiler , Clang / LLVM
Standardizations: ISO / IEC 14882: 1998,
ISO / IEC 14882: 2003,
ISO / IEC TR 19768: 2007,
ISO / IEC 14882: 2011,
ISO / IEC 14882: 2014
ISO / IEC 14882: 2017
Influenced by: C , Simula , Ada , ALGOL 68 , CLU , ML
Affected: Ada 95 , Chapel , C # , D , Go , Java , Nim , Perl , PHP , Python , Vala , Rust , Seed7

C ++ is a programming language standardized by the ISO . It was developed from 1979 by Bjarne Stroustrup at AT&T as an extension of the C programming language . C ++ enables efficient and machine-oriented programming as well as programming at a high level of abstraction. The standard also defines a standard library for which various implementations exist.

Areas of application

C ++ is used both in system programming and in application programming and is one of the most common programming languages ​​in both areas.

System programming

Typical fields of application in system programming are operating systems , embedded systems , virtual machines , drivers and signal processors . C ++ often takes the place here that was previously reserved exclusively for assembly languages and the C programming language .

Application programming

In application programming, C ++ is mainly used where high demands are placed on efficiency in order to make the best possible use of the performance limits specified by technical framework conditions. From the year 2000, C ++ was pushed back from the domain of application programming by the languages Java and C # .


Language design

The C ++ language only uses around 60 key words (“language core”), some are used multiple times in different contexts ( static, default). It receives its actual functionality, similar to the C language, from the C ++ standard library , which provides the language with missing important functionalities (arrays, vectors, lists, ...) as well as establishing the connection to the operating system (iostream, fopen, exit , ...). Additional libraries and frameworks are added depending on the area of ​​application. C ++ focuses on the language resources for developing libraries. As a result, it favors generalized mechanisms for typical problems and has hardly any individual solutions integrated into the language.

One of the strengths of C ++ is the ability to combine efficient, machine-level programming with powerful language resources that summarize simple to complex implementation details and largely hide them behind abstract command sequences. The template metaprogramming comes into play here: a technique that allows an almost uncompromising combination of efficiency and abstraction.

However, some design decisions are also often criticized:

Resource management

C ++ does not have garbage collection , but efforts are being made to enable garbage collection through libraries or through inclusion in the language standard. See also Boehm Garbage Collection .

However, it is possible to manage memory in the program; it is necessary to implement low-level libraries such as the C ++ standard library . However, this is strongly discouraged in high-level code.

Instead, it is customary there to let the C ++ standard library take over the memory management by using the container classes offered. Other resources, e.g. B. File handles or network sockets are usually managed in C ++ in separate classes with the RAII principle in order to ensure automatic cleanup after use.

If you refer to other objects yourself in objects, you usually work with smart pointers as an alternative to a garbage collector, which then take over the resource management. The standard library mostly uses internal reference counting .

Incomplete object orientation

Visibility of private elements

In C ++, private properties (variables and methods) are usually part of the interface, which is published in the header file. This creates dependencies between the objects and the places they use at compile time and runtime .

These dependencies can be avoided by using certain constructions, such as the pimpl idiom ( pointer to implementation idiom ). The private fields of the class ( example_class ) are moved to a private, forward-declared auxiliary class, and a pointer to an object of this auxiliary class ( example_class :: impl * impl_ptr ) remains in the actual class. The definition of the implementing class takes place during the implementation of the public class and is therefore invisible to the user of the class (who only knows the header file). Because the auxiliary class is only referenced by a pointer, all source code changes to private fields remain transparent and binary compatibility is maintained.

Incomplete encapsulation

In C ++, the memory areas of the individual objects are not protected against (intentional or accidental) mutual changes at runtime.

Undefined behavior

The behavior of many language constructs is not defined. This means that the standard neither dictates nor recommends what happens in such a case. The effects range from implementation dependency (i.e. the construct can behave differently depending on the target computer and compiler) to nonsensical results or program crashes to dangerous security holes. Some of these compiler freedoms allow additional code optimization, but some are of no practical use and are unnecessarily undefined. A third group represents code that can be written as code with defined behavior without loss of performance.

Undefined behavior leads to different behavior

  • different compilers
  • different compiler versions
  • selected architecture (ARM, x86, x64)
  • various optimization settings (debug, release, optimization)
  • Selected instruction set, calling conventions, etc. v. a. m.
  • In the case of multi-threaded programs, the timing plays a further role.

Source code with code passages with undefined behavior can show unexpected and absurd behavior after compilation. Checks carried out too late are optimized away or loops that access an invalid index of an array are replaced by empty endless loops.

In order to understand undefined behavior, it is particularly important that a single operation is never invalid, but that the entire program becomes invalid and no longer represents well-formed C ++. The reason is that some types of "undefined behavior" have effects on completely different parts of the program, which are also correct in themselves, and can influence their behavior, for example in the case of buffer overflows or the unintentional change of processor flags caused by an invalid arithmetic operation and can influence the following calculations.

Examples of undefined behavior :

  • Overflow of signed integers (also e.g. when converting from unsigned intto int)
  • Null pointer referencing
  • Array access with invalid index
  • Shift operations with a shift width that is negative or greater than or equal to the number of bits of the type to be shifted
  • Division by zero with integral data types
  • Omission of the returnstatement in functions with a return value (the main function mainis the only exception)
  • A side effect changes a variable that occurs more than once in the expression ( v[i] = i++;) or in the argument list ( f(i, i++);) (the evaluation order of partial expressions and function arguments is not fixed)

On the one hand, the resulting nondeterministic runtime behavior, especially in the case of small changes to the platform, is at least to be classified as a risk, but in practice it is often a clear disadvantage. On the other hand, this enables faster programs, since validity checks can be omitted and the compiler can also often optimize program parts to a greater extent by ignoring edge cases that are excluded by definition.

Another advantage that is often not perceived is that, because undefined behavior only occurs in extremely questionable constructs, which, however, are not necessarily ascertainable during compilation, unsemantic or otherwise suboptimal code is to a certain extent forbidden.

For example, there is an illegal way of checking whether the sum of two positive integers and of the type 'int' can be mapped again in an 'int' without loss, by looking to see whether their sum is greater than 0 (overflow occurs on most computers with two's complement arithmetic a negative number). Such a check is not particularly useful from a mathematical point of view. A better (more semantic) approach here is to use the actual question of whether , where the largest number that can be represented in an 'int', should be used after the mathematically valid transformation .

Compatibility with C

In order to build on the spread of the C programming language, C ++ was designed as an extension of C in accordance with the status of 1990 ( ISO / IEC 9899: 1990 , also called C90 for short).

Compatibility with C forces C ++ to continue with some of the disadvantages it has inherited. This includes the sometimes difficult to understand C syntax, the preprocessor , which is considered obsolete, as well as various details of the language that depend on the respective platform and make it difficult to port C ++ programs between different computer types, operating systems and compilers.

Some C language constructs have a slightly different meaning or syntax in C ++, so that some C programs must first be adapted in order to be compiled as C ++ programs. Further changes to C took place in 1999 ( ISO / IEC 9899: 1999 , aka C99) and 2011 ( ISO / IEC 9899: 2011 , aka C11), i.e. after the first standardization of C ++, so that changes incorporated there are not in C ++ 98 could be considered. Some of the new features of C99 were adopted in the 2011 C ++ revision; on the other hand, new features have been added to the C standard that are not compatible with C ++ 11 either.

Language features in detail

C ++ is based on the C programming language as described in ISO / IEC 9899: 1990. In addition to the options available in C, C ++ offers other data types and new type conversion options , classes with multiple inheritance and virtual functions , exception handling , templates , namespaces , inline functions , overloading of operators and function names , references , operators for managing dynamic memory and an extended library with the C ++ standard library .

Sample program

The following source code is a simple C ++ program that contains the text Hello world! " In the standard output stream , usually the terminal , writes:

#include <iostream>

int main() {
    std::cout << "Hallo Welt!" << std::endl;
    return 0;

The preprocessor command or also called preprocessor directive #includeincludes header files that typically contain declarations of variables, types and functions. In contrast to C, headers in the C ++ standard library do not have a file extension.

The header <iostream>is part of the C ++ standard library and declares, among other things, the standard input stream std::cinand the standard output streams std::coutand std::cerrfor the objects known from the C standard library stdin, stdoutand stderr.

This main()is the function that is the entry point of every C ++ program. The program is executed by calling the function main(), which in turn can call other functions. However, the function main()itself must not be called recursively in a C ++ program .

The standard requires implementations to support two signatures for the function main(): One without function parameters as in the example, and one that characcepts an integer and a pointer to pointer to in order to be able to access command line parameters (which is not required in all programs) : int main(int argc, char **argv). Implementations may also support further signatures for main(), but all must have the return type int( integer ), i.e. return an integer. Would main()not return a value, the C ++ standard dictates the implementation to return 0;accept. main()so returns 0 if there is no returnstatement to the contrary in it.

std::coutis an instance of the class std::basic_ostream<char> which, like the entire C ++ standard library, is located in the namespace std . Identifiers in namespaces are ::addressed with the area operator ( ).

The operator handles the output of the character string "Hallo Welt" literal <<. In C ++, character string literals are of the type array made up of N constant chars ( char const[N]), where N is the length of the character string + 1 for the terminating zero termination . Since the default type conversions of C ++ as pointer-to-array decay known implicit conversion of an array T[N]to a pointer T*provide and therefore char const[N]in a char const*decays that fits overloaded operator template<class traits> basic_ostream<char,traits>& operator<<(std::basic_ostream<char,traits>&, char const *); of <ostream>and is called accordingly ( operator<<( std::cout, "Hallo Welt!" );) and returns the string. std::endlAn end-of-line character is output by the output manipulator .

When return 0the operating system is informed of the execution of the program was successful.

File extensions

Typical file extensions are .C, .cc, .cpp, .cxx, .c ++ , .h, .hh, .hpp, .hxx, .h ++ .


C ++ compiler

The implementation of a C ++ compiler is considered expensive. After the language standard was completed in 1998, it took several years for the language to be largely supported by C ++ compilers.

The most popular C ++ compilers include:

Visual C ++
The compiler included in Microsoft Visual C ++ is the most widely used for the Windows operating system . Microsoft provides the Community Edition free of charge.
The g ++ is the C ++ version of the GNU Compiler Collection (GCC); g ++ is open source and freely available. The g ++ supports a variety of operating systems (including Unix , Linux , macOS , Windows and AmigaOS ) and processor platforms. GNU C ++ has existed since 1987, making it one of the oldest C ++ compilers.
Intel C ++ compiler
The Intel C ++ compiler also uses the mentioned C ++ front-end from EDG. The Intel C ++ Compiler generates machine code for the Intel processors under the Windows, Linux and macOS operating systems. Since the programs generated with the Intel C ++ compiler make particularly good use of the instruction set of the Intel processors, they generate particularly efficient programs for this platform. (Compilates of the Intel compiler also usually run faster on AMD chips than compilations of the alternative compilers, but Intel locks corresponding optimization flags, whereby the lock can be canceled.) The Intel C ++ compiler uses essential parts of the g ++ in the substructure and replaces and expands parts of code optimization and code generation.
Clang , a front end for the cross-platform compiler infrastructure LLVM promoted by Apple , which is also used in the integrated development environment Xcode .
Oracle Solaris Studio
Oracle Solaris Studio ( Wikipedia entry ) is available free of charge from Oracle.
Comeau C ++
The Comeau C ++ . The so-called “front end” of the compiler, i.e. the part that implements the analysis phase, was developed by the Edison Design Group (EDG), which specializes in the development of compiler front ends and their C ++ - Front-end is also built into many other commercial C ++ compilers. The Comeau compiler can also be tried out on the Internet.
Turbo C ++
Another compiler is available with Turbo C ++ / C ++ Builder .

Integrated development environments

Free development environments

Proprietary development environments

Comparison with other languages


C ++ was not the only approach to add features to the C programming language that simplify object-oriented programming. In the 1980s, the programming language Objective-C was created , which, in contrast to C ++, was based on Smalltalk and not on Simula in terms of syntax and functional principle . The syntax of Objective-C (C influenced by Smalltalk) differs considerably from C ++ (C influenced by Simula with its own syntactic extensions). In the late 1980s, Objective-C was first used commercially in NeXTSTEP , in which it is a central component. Nowadays it is used in the OpenStep programming interface and in the Apple iOS and macOS operating systems .

Java and C #

The programming languages Java and C # have a similar syntax, also based on C, as C ++, are also object-oriented and have supported type parameters for some time. Despite their external similarities, they differ conceptually from C ++ in some cases considerably.

Generic techniques supplement object-oriented programming with type parameters and thus increase the reusability of algorithms that have been coded once. The generic Java extensions are only applicable to classes, not to primitive types or data constants. In contrast, the generic language extensions of C # also include the primitive types. However, this is an extension for generics at runtime, which can usefully supplement the C ++ templates tailored to compilation time, but cannot replace them.

Generic programming in particular makes C ++ a powerful programming tool. While object-oriented programming in Java and C # is still the central abstraction mechanism, this type of programming in C ++ is on the decline. In this way, deep class hierarchies are avoided, and in favor of efficiency and the minimization of resource consumption, polymorphism , one of the fundamental components of object-oriented programming , is dispensed with in many cases .

Creation and further development

History of origin

Stroustrup came up with the idea for a new programming language through experience with the programming language Simula during his doctoral thesis at Cambridge University . Simula appeared to be suitable for use in large software projects, but the structure of the language made it difficult to create highly efficient programs . In contrast, although efficient programs could be written using the BCPL language , BCPL was again unsuitable for large projects.

With the experience from his doctoral thesis, Stroustrup expanded the programming language C from 1979 onwards at the AT&T Bell Laboratories as part of investigations into the Unix operating system kernel with regard to distributed computing . The C programming language was chosen because C was a general-purpose language that produced code quickly and was easy to port to other platforms . As the language accompanying the Unix operating system, C was also widely used.

One of the first extensions was a class concept with data encapsulation, for which the Simula-67 language was the primary model. Then there were derived classes, a stricter type system , inline functions and standard arguments.

While Stroustrup " C with Classes " ( " C with Classes ") developed (which later became C ++), he also wrote cfront , a compiler from C with Classes initially generated C code as an intermediate result. The first commercial version of cfront appeared in October 1985.

In 1983, C with Classes was renamed C ++ . Enhancements were: overloading of function names and operators, virtual functions, references, constants, a changeable heap management and an improved type check. The option of comments that are tied to the end of a line was adopted from BCPL ( //).

In 1985 the first version of C ++ appeared, which was an important reference version because the language was not yet standardized at the time. In 1989 version 2.0 of C ++ appeared. New in it were multiple inheritance , abstract classes, static member functions, constant member functions and the extension of the access model protected. In 1990 the book The Annotated C ++ Reference Manual was published , which served as the basis for the standardization process that followed.

Templates , exception handling , namespaces , novel type conversions and Boolean types were added to the language relatively late .

In the course of the further development of the C ++ language, a standard library that was expanded compared to C was also created. The first addition was the Stream I / O library , which replaces traditional C functions such as printf()and scanf(). One of the major enhancements to the standard library came later with the integration of large parts of the Standard Template Library ( STL ) developed by Hewlett-Packard .


After years of work, the final version of the C ++ language (ISO / IEC 14882: 1998) was finally standardized in 1998. In retrospect, when other versions of the language appeared, this version was also called C ++ 98 . In 2003, ISO / IEC 14882: 2003 was passed, an amendment to the 1998 standard that eliminated some misunderstandings and clarified several details. This version is also known colloquially as C ++ 03 .

Further development of the programming language C ++ after 2005

In order to keep pace with the current developments in rapidly changing computer technology, but also to correct known weaknesses, the C ++ standardization committee developed the next major revision of C ++, which was unofficially abbreviated as C ++ 0x , in which the sequence of digits was a rough one Should indicate an estimate of the possible publication date. Later, when a release date could no longer be kept until the end of 2009, the unofficial name was changed to C ++ 1x .

The primary goals for the further development of C ++ were improvements in terms of system programming and the creation of program libraries. In addition, the learnability of the language for beginners should be improved.

In November 2006, the target date for completion was set for 2009. In July 2009 this date was changed to 2010 at the earliest. The revision was unanimously adopted by ISO in August 2011 and officially published as ISO / IEC 14882: 2011 on October 11, 2011. Unofficially the version is called C ++ 11 .

Improvements to the language core

C ++ 98 did not yet sufficiently cover some typical problem areas in programming, for example the support of concurrency ( threads ), the integration of which in C ++, especially for use in multiprocessor environments, made a revision of the language inevitable. Through the introduction of a memory model, guarantees of the language for the concurrent operation were established in order to both resolve ambiguities in the processing sequence and to maintain them in certain cases, thereby creating scope for optimization.

To the broader language extensions belonged further, the automatic type derivative for the derivation of result types of expressions and the so-called R-value references , as an addition to the already existing with the help of copying then objects also a displacement can be realized also range-based for-loops ( foreach ) via containers and built-in fields.

Extension of the program library

In April 2006, the C ++ standardization committee published the so-called first technical report (TR1), a non-normative addition to the currently valid library defined in 1998, with which extension proposals are to be examined for their practical suitability before they can be transferred to the C ++ standard library . Many compiler manufacturers delivered the TR1 with their products.

In TR1 were u. a. Regular expressions , various intelligent pointers , unordered associative containers , a random number library , tools for C ++ metaprogramming, tuples, and numeric and mathematical libraries. Most of these extensions came from the Boost library , from which they were taken with minimal changes. In addition, all library extensions of the 1999 revised programming language C (C99) were included in a form adapted to C ++.

With the exception of the numerical and mathematical libraries, all TR1 extensions have been incorporated into the C ++ 11 language standard. A separate library to support threads was also introduced.

C ++ 11

With the ISO / IEC 14882: 2011 standard, also known as C ++ 11 , many far-reaching innovations were introduced in C ++, such as in extracts:

  • Lambdas ( anonymous functions ), some of which were widely used in other languages before the C ++ 11 standard was adopted, expand the language, especially in the area of ​​functional programming.
  • A simplified type handling with type inference is now possible via the keyword auto(which is no longer a storage class specifier) ​​on the one hand and the keyword decltype(which statically returns the type of an expression at compile time, if it can be determined) on the other. Both key words also show their strengths when combined. In this way, entire functions whose return types are difficult to see for the programmer, for example because they are located within more complex class templates, can be comfortably defined:
    template <typename Factory>
    auto createObject(const Factory& creator) -> decltype(creator.makeObject()) {
        return creator.makeObject();
  • Strictly typed enums ( enum class) eliminate problems with name collisions and reduce the susceptibility to errors with regard to implicit type conversions.
  • So-called "range-based loops" using a modified forstatement make working with containers and arrays easier in such a way that iterators when traversing objects of these data types are superfluous for many applications:
    #include <iostream>
    #include <string>
    #include <vector>
    using namespace std;
    void printNames(const vector<string>& names) {
        for (const string& singleName: names)
            cout << singleName << endl;
  • It may be used in templates directly consecutive angle brackets: .map<int, vector<int>>
  • In addition, the introduction of “variadic templates” resulted in a large-scale expansion of the possibilities for using templates. These now allow a non-fixed number of template arguments template<typename... Values> class VariadicExampleClass;, which enables wide-ranging options and simplifications in the code or algorithm structure and the code structure in general. Furthermore, like many other C ++ 11 extensions, they have the potential to further reduce the need to use macros, some of which are error-prone and not robust.
  • The explicit usability of so-called rvalue references, based on what is known as movement semantics, among other things, enables a wide range of code simplifications, runtime optimizations and exception-proof programming. With the Rvalue references, the so-called universal references were also introduced, which make the problem of “perfect forwarding” robust and easy to solve at the language level (the consistent forwarding of types within template constructs, which were resolved by “type deduction”, to further templates ). Before the C ++ 11 standard was adopted, this was not possible, at least at the language level, and, depending on the problem, required more or less self-direction from the programmer with, in some cases, corresponding code inflation and duplication.
  • In addition, some features have been taken over from C11, for example integers with at least 64 bits ( long long) or assurances at compilation time using static_assert(in C11:) _Static_assert.

C ++ language topics relating to computing time and memory space were dealt with in the so-called technical report ISO / IEC TR 18015: 2006.

At the time of the introduction of the standard and for a comparatively long time afterwards, many common compilers did not fully support it or sometimes incorrectly with regard to some extensions. In this regard, Microsoft, for example, showed particularly severe restrictions with Visual C ++ 2012 . With Visual C ++ 2015 , however, almost all major, major language extensions have now been taken into account.

C ++ 14

C ++ 14, described in the ISO / IEC 14882: 2014 standard, expands the possible uses of autoand decltype, weakens the prerequisites for constexpr, allows variable templates to be defined (e.g. to define several versions of π with different degrees of accuracy depending on the type), introduces binary literals (0b ...), introduces quotation marks as separators in numbers, allows generic lambdas, extends lambda capture expressions and introduces the attribute deprecated.

In addition, the standard library was supplemented by a few functions that were “forgotten” or “overlooked” in C ++ 11 (e.g. std::make_unique) and several function constexprdeclarations have now been redeclared, which allows the compiler to make more aggressive optimizations.

During the development phase , C ++ 14 was also called C ++ 1y to indicate that it will be the successor version of the version previously known as C ++ 0x.

C ++ 17

In March 2017, the ISO-C ++ committee technically completed the language standard C ++ 17. For the new version, among other things std::byte, it was decided to include the guy . This is explicitly intended for byte-wise access to the memory. New, generic containers have been introduced: std::anyas an alternative to void*with type checking at runtime, std::variantas an alternative to the union with runtime type checking carried over from C and std::optional, a container that can contain exactly one element, but does not have to.

Until it was officially adopted, the version was also referred to as C ++ 1z .

After the summer meeting in mid-July, the C ++ expert Herb Sutter , who is responsible for convening the committee, already revealed initial plans for C ++ 20 on his blog.

C ++ 20

A significant number of features that will likely come with C ++ 20 are already known.

  • Concepts
  • certain initializers (first in C99 )
  • [=, this] in lambdas
  • Template parameter lists in parameters
  • Coroutines
  • a module system for code encapsulation and shorter compilation times
  • Transactional storage

C ++ 23/26

  • Reflection
  • Executors
  • Pattern matching
  • Networking

The name "C ++"

The name C ++ is a word created by Rick Mascitti, a Stroustrup employee, and was first used in December 1983. The name comes from the connection of the previous language C and the increment operator "++", which increments the value of a variable (increases by one). The inventor of C ++, Bjarne Stroustrup, C ++ called first "C with Classes" ( C with classes ).


Often criticized language includes, for example:

  • C ++ is very complex and error-prone to program. You have to learn and practice a lot to master it well, and many features are considered extremely complex.
  • C ++ is designed to be too low-level ; while it has many features of higher-level languages ​​(classes, generic classes / functions etc.), things that are perceived as important, in particular garbage collection , are not available.
  • C ++ is considered to be fast, for example because of the possibility to work freely with pointers, but this performance is only necessary in exceptional cases on today's fast computer systems: While it makes sense to use operating systems or the like. To write in C ++, from a software point of view, it is much cheaper to write application programs in higher languages, since these are easier to maintain and still have sufficient performance.
  • Typical in connection with C ++ is the quote from Bjarne Stroustrup:

"In C ++ it's harder to shoot yourself in the foot, but when you do, you blow off your whole leg."

"It's harder to shoot yourself in the foot in C ++, but if you do, your whole leg is gone."

In other words: C ++ initially makes a lot of things easier, but at the same time it brings with it a lot of resources that have to be used with care. For example, dynamic memory allocation without automatic memory release can result in memory leaks . Pointers can refer to incorrect memory areas and cause hidden malfunctions ( hanging pointer ).

See also


  • Bjarne Stroustrup : The C ++ programming language: Current to C ++ 11 . Carl Hanser, 2015, ISBN 978-3-446-43961-0 (standard work on C ++, basic knowledge of C is an advantage).
  • Bjarne Stroustrup: The Design and Evolution of C ++ . Addison-Wesley, 1994, ISBN 0-201-54330-3 (book describes the development and design of C ++; written by the language designer).
  • Bjarne Stroustrup: Programming - Principles and Practice Using C ++ . Addison-Wesley, 2008, ISBN 978-0-321-54372-1 (Introduction to Programming; standard reference for entry-level programming courses at the University of Texas A&M).
  • Herb Sutter : Exceptional C ++ . 1st edition. Addison-Wesley, 2000, ISBN 3-8273-1711-8 (consolidation of existing C ++ knowledge.).
  • Andrei Alexandrescu : Modern C ++ Design - Generic programming and design patterns applied . 1st edition. Mitp-Verlag, 2003, ISBN 3-8266-1347-3 (A standard work on C ++ metaprogramming , requires a deep understanding of C ++.).
  • Ulrich Breymann : Learn C ++ - apply it professionally - use solutions . 4th revised edition. Addison-Wesley, 2015, ISBN 978-3-446-44346-4 (C ++ - Introduction from the University Environment).
  • Sibylle Schupp : A Semantic Definition of Separate Type Checking in C ++ with Concepts . (scientific article). In: Journal of Object Technology . tape 8 , no. 5 , 2009, p. 105-132 , doi : 10.5381 / jot.2009.8.5.a2 .

Web links

Wikibooks: C ++ programming  - learning and teaching materials
Wiktionary: C ++  - explanations of meanings, word origins, synonyms, translations

Individual evidence

  1. Herb Sutter: Trip report: Summer ISO C ++ standards meeting (Oulu). In: Sutter's Mill. June 30, 2016, accessed April 4, 2020 .
  2. a b c ISO / IEC 14882: 2014 - Information technology - Programming languages ​​- C ++. In: www.iso.org. December 2014, accessed September 22, 2018 .
  3. ISO / IEC 14882: 2017 - Programming languages ​​- C ++. In: www.iso.org. December 2017. Retrieved September 22, 2018 .
  4. 9. Classes - Python 3.6.4 documentation. In: docs.python.org. Retrieved May 17, 2018 .
  5. ^ The Programming Languages ​​Beacon. In: lextrait.com. Retrieved January 21, 2018 .
  6. a b Bjarne Stroustrup: Proposal to Acknowledge that Garbage Collection for C ++ is Possible. (PDF) 1996, accessed on June 6, 2015 (English): “The most loudly proclaimed fundamental weakness of C ++ these days is the absence of automatic garbage collection. This criticism is harming C ++ 's reputation, scaring potential users away, and restricting the range of applications for which C ++ is a strong contender as an implementation language. For many applications automatic garbage collection is indeed a very powerful tool and the right tool for the job. "
  7. Hans-J. Boehm, Mike Spertus, Clark Nelson: N2670: Minimal Support for Garbage Collection and Reachability-Based Leak Detection (revised). In: open-std.org. June 13, 2008, accessed January 21, 2018 .
  8. Transparent Programmer-Directed Garbage Collection for C ++ (PDF).
  9. Bjarne Stroustrup: C ++ FAQ about memory leaks (English); Retrieved May 3, 2013.
  10. std :: shared_ptr on cppreference.com , section Notes on implementation; accessed on June 5, 2020
  11. The d pointer idiom. on heise developer.
  12. Undefined behavior in the case of multiple assignments. ( Memento of August 22, 2014 in the Internet Archive ), accessed on August 20, 2014.
  13. ^ Scott Meyers: Effective C ++ Programming. Addison-Wesley, pp. 22/23, 43/44 and 46, from Google Books , accessed on August 20, 2014.
  14. Myths and Missconceptions about C ++, Section Undefined Behavior , accessed February 20, 2015.
  15. Bjarne Stroustrup's C ++ Style and Technique FAQ. In: www.stroustrup.com. September 30, 2017, accessed September 22, 2018 .
  16. ^ Bjarne Stroustrup: Evolving a language in and for the real world: C ++ 1991-2006. (PDF; 690 kB).
  17. ^ Clang: a C language family frontend for LLVM. In: clang.llvm.org. Retrieved September 22, 2018 .
  18. Oracle Developer Studio. In: www.oracle.com. Retrieved September 22, 2018 .
  19. Turbo C ++ Community. In: www.turboexplorer.com. Retrieved September 22, 2018 .
  20. Java - A Bit of History or Peter Drayton, Ted Neward, Ben Albahari: C # in a Nutshell: A Desktop Quick Reference . 2nd Edition. O'Reilly, 2003, ISBN 978-0-596-00526-9 .
  21. C ++ 11 unanimously adopted as the standard. on Heise online , August 13, 2011.
  22. New C ++ version published as ISO / IEC standard. Heise online, October 11, 2011.
  23. Programming language: ISO publishes C ++ 11. Golem.de , October 11, 2011.
  24. C ++ 11 - the new ISO C ++ standard. In: www.stroustrup.com. Retrieved September 22, 2018 .
  25. ^ A Proposal to add Regular Expressions to the Standard Library. at Open Standards. March 3, 2003 (English).
  26. ^ A Proposal to Add General Purpose Smart Pointers to the Library Technical Report . at Open Standards. March 27, 2003
  27. ^ A Proposal to Add Hash Tables to the Standard Library. at Open Standards. April 9, 2003 (English).
  28. ^ A Proposal to Add an Extensible Random Number Facility to the Standard Library. at Open Standards. April 10, 2003 (English).
  29. proposal for adding tuple types into the standard library. (PDF; 164 kB) at Open Standards. November 8, 2002 (English).
  30. ^ A Proposal to Add Mathematical Special Functions to the C ++ Standard Library. at Open Standards. February 24, 2003 (English).
  31. ISO / IEC JTC1 / SC22 / WG21 N1568. at Open Standards , from 2004 (English).
  32. ^ B. Stroustrup: C ++ 11 FAQ
  33. ISO Technical Report on C ++ Performance (PDF; 1.2 MB)
  34. MSDN: Support for C ++ 11/14/17 functions (Modern C ++) Support for C ++ 11/14/17 features by Microsoft compilers
  35. The GNU Compiler Collection: Status of Experimental C ++ 11 Support in GCC 4.7 Support of C ++ 11 features by the gcc
  36. Programming languages: C ++ 17 is technically ready. heise.de, accessed on July 17, 2017 .
  37. C ++ support in Clang. C ++ 17 implementation status. In: clang.llvm.org. September 22, 2018, accessed on September 22, 2018 .
  38. Trip report: Summer ISO C ++ standards meeting (Toronto). herbsutter.com, accessed July 17, 2017 .
  39. C ++ Modules Might Be Dead-on-Arrival. In: vector-of-bool.github.io. Retrieved May 21, 2019 .
  40. r / cpp - 2019-02 Kona ISO C ++ Committee Trip Report (C ++ 20 design is complete; Modules in C ++ 20; Coroutines in C ++ 20; Reflection TS v1 published; work begins on a C ++ Ecosystem Technical Report ). Retrieved on August 22, 2019 .
  41. When was C ++ invented? (English) - FAQ entry at AT&T Labs Research ; As of July 4, 2011.
  42. ^ Ian Joyner: C ++ ?? A Critique of C ++. (PDF) November 1992, pp. 27–29 , accessed on June 6, 2015 (English).
  43. ^ The Problem With C ++. In: www.codinghorror.com. January 12, 2007, accessed September 22, 2018 .
  44. Bjarne Stroustrup's FAQ. Did you really say that? In: www.stroustrup.com. March 18, 2018, accessed on September 22, 2018 .