C++

C++ (/ˌsiːˌplʌsˈplʌs/) is a general-purpose programming language that was developed by Bjarne Stroustrup as an extension of the C language, or "C with Classes". It has imperative, object-oriented and generic programming features, while also providing facilities for low-level memory manipulation. It is almost always implemented as a compiled language, and many vendors provide C++ compilers, including the Free Software Foundation, Microsoft, Intel, and IBM, so it is available on many platforms.

C++ was designed with a bias toward system programming and embedded, resource-constrained software and large systems, with performance, efficiency and flexibility of use as its design highlights.[7] C++ has also been found useful in many other contexts, with key strengths being software infrastructure and resource-constrained applications,[7] including desktop applications, servers (e.g. e-commerce, Web search or SQL servers), and performance-critical applications (e.g. telephone switches or space probes).[8]

C++ is standardized by the International Organization for Standardization (ISO), with the latest standard version ratified and published by ISO in December 2017 as ISO/IEC 14882:2017 (informally known as C++17).[9] The C++ programming language was initially standardized in 1998 as ISO/IEC 14882:1998, which was then amended by the C++03, C++11 and C++14 standards. The current C++17 standard supersedes these with new features and an enlarged standard library. Before the initial standardization in 1998, C++ was developed by Danish computer scientist Bjarne Stroustrup at Bell Labs since 1979 as an extension of the C language; he wanted an efficient and flexible language similar to C that also provided high-level features for program organization.[10] C++20 is the next planned standard, keeping with the current trend of a new version every three years[11].

C++
ISO C++ Logo
ParadigmMulti-paradigm: procedural, functional, object-oriented, generic[1]
Designed byBjarne Stroustrup
First appeared1985
Stable release
ISO/IEC 14882:2017 / 1 December 2017
Typing disciplineStatic, nominative, partially inferred
Implementation languageC++ or C
Filename extensions.C, .cc, .cpp, .cxx, .c++, .h, .hh, .hpp, .hxx, .h++
Websiteisocpp.org
Major implementations
LLVM Clang, GCC, Microsoft Visual C++, Embarcadero C++Builder, Intel C++ Compiler, IBM XL C++, EDG
Influenced by
Ada, ALGOL 68, C, CLU, ML, Simula
Influenced
Ada 95, C#,[2] C99, Chapel,[3] Clojure,[4] D, Java,[5] Lua, Nim, Perl, PHP, Python,[6] Rust

History

BjarneStroustrup
Bjarne Stroustrup, the creator of C++

In 1979, Bjarne Stroustrup, a Danish computer scientist, began work on "C with Classes", the predecessor to C++.[12] The motivation for creating a new language originated from Stroustrup's experience in programming for his Ph.D. thesis. Stroustrup found that Simula had features that were very helpful for large software development, but the language was too slow for practical use, while BCPL was fast but too low-level to be suitable for large software development. When Stroustrup started working in AT&T Bell Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing. Remembering his Ph.D. experience, Stroustrup set out to enhance the C language with Simula-like features.[13] C was chosen because it was general-purpose, fast, portable and widely used. As well as C and Simula's influences, other languages also influenced C++, including ALGOL 68, Ada, CLU and ML.

Initially, Stroustrup's "C with Classes" added features to the C compiler, Cpre, including classes, derived classes, strong typing, inlining and default arguments.[14]

In 1983, "C with Classes" was renamed to "C++" (++ being the increment operator in C), adding new features that included virtual functions, function name and operator overloading, references, constants, type-safe free-store memory allocation (new/delete), improved type checking, and BCPL style single-line comments with two forward slashes (//). Furthermore, it included the development of a standalone compiler for C++, Cfront.

In 1985, the first edition of The C++ Programming Language was released, which became the definitive reference for the language, as there was not yet an official standard.[15] The first commercial implementation of C++ was released in October of the same year.[12]

In 1989, C++ 2.0 was released, followed by the updated second edition of The C++ Programming Language in 1991.[16] New features in 2.0 included multiple inheritance, abstract classes, static member functions, const member functions, and protected members. In 1990, The Annotated C++ Reference Manual was published. This work became the basis for the future standard. Later feature additions included templates, exceptions, namespaces, new casts, and a boolean type.

After the 2.0 update, C++ evolved relatively slowly until, in 2011, the C++11 standard was released, adding numerous new features, enlarging the standard library further, and providing more facilities to C++ programmers. After a minor C++14 update released in December 2014, various new additions were introduced in C++17, and further changes planned for 2020.[17]

As of 2017, C++ remains the third most popular programming language, behind Java and C.[18][19]

On January 3, 2018, Stroustrup was announced as the 2018 winner of the Charles Stark Draper Prize for Engineering, "for conceptualizing and developing the C++ programming language".[20]

Etymology

According to Stroustrup: "the name signifies the evolutionary nature of the changes from C".[21] This name is credited to Rick Mascitti (mid-1983)[14] and was first used in December 1983. When Mascitti was questioned informally in 1992 about the naming, he indicated that it was given in a tongue-in-cheek spirit. The name comes from C's ++ operator (which increments the value of a variable) and a common naming convention of using "+" to indicate an enhanced computer program.

During C++'s development period, the language had been referred to as "new C" and "C with Classes"[14][22] before acquiring its final name.

Philosophy

Throughout C++'s life, its development and evolution has been guided by a set of principles:[13]

  • It must be driven by actual problems and its features should be immediately useful in real world programs.
  • Every feature should be implementable (with a reasonably obvious way to do so).
  • Programmers should be free to pick their own programming style, and that style should be fully supported by C++.
  • Allowing a useful feature is more important than preventing every possible misuse of C++.
  • It should provide facilities for organising programs into separate, well-defined parts, and provide facilities for combining separately developed parts.
  • No implicit violations of the type system (but allow explicit violations; that is, those explicitly requested by the programmer).
  • User-created types need to have the same support and performance as built-in types.
  • Unused features should not negatively impact created executables (e.g. in lower performance).
  • There should be no language beneath C++ (except assembly language).
  • C++ should work alongside other existing programming languages, rather than fostering its own separate and incompatible programming environment.
  • If the programmer's intent is unknown, allow the programmer to specify it by providing manual control.

Standardization

Year C++ Standard Informal name
1998 ISO/IEC 14882:1998[23] C++98
2003 ISO/IEC 14882:2003[24] C++03
2011 ISO/IEC 14882:2011[25] C++11, C++0x
2014 ISO/IEC 14882:2014[26] C++14, C++1y
2017 ISO/IEC 14882:2017[9] C++17, C++1z
2020 to be determined C++20[17], C++2a

C++ is standardized by an ISO working group known as JTC1/SC22/WG21. So far, it has published five revisions of the C++ standard and is currently working on the next revision, C++20.

In 1998, the ISO working group standardized C++ for the first time as ISO/IEC 14882:1998, which is informally known as C++98. In 2003, it published a new version of the C++ standard called ISO/IEC 14882:2003, which fixed problems identified in C++98.

The next major revision of the standard was informally referred to as "C++0x", but it was not released until 2011.[27] C++11 (14882:2011) included many additions to both the core language and the standard library.[25]

In 2014, C++14 (also known as C++1y) was released as a small extension to C++11, featuring mainly bug fixes and small improvements.[28] The Draft International Standard ballot procedures completed in mid-August 2014.[29]

After C++14, a major revision C++17, informally known as C++1z, was completed by the ISO C++ Committee in mid July 2017 and was approved and published in December 2017.[30]

As part of the standardization process, ISO also publishes technical reports and specifications:

  • ISO/IEC TR 18015:2006[31] on the use of C++ in embedded systems and on performance implications of C++ language and library features,
  • ISO/IEC TR 19768:2007[32] (also known as the C++ Technical Report 1) on library extensions mostly integrated into C++11,
  • ISO/IEC TR 29124:2010[33] on special mathematical functions,
  • ISO/IEC TR 24733:2011[34] on decimal floating point arithmetic,
  • ISO/IEC TS 18822:2015[35] on the standard filesystem library,
  • ISO/IEC TS 19570:2015[36] on parallel versions of the standard library algorithms,
  • ISO/IEC TS 19841:2015[37] on software transactional memory,
  • ISO/IEC TS 19568:2015[38] on a new set of library extensions, some of which are already integrated into C++17,
  • ISO/IEC TS 19217:2015[39] on the C++ concepts, integrated into C++20
  • ISO/IEC TS 19571:2016[40] on the library extensions for concurrency
  • ISO/IEC TS 19568:2017[41] on a new set of general-purpose library extensions
  • ISO/IEC TS 21425:2017[42] on the library extensions for ranges, integrated into C++20
  • ISO/IEC TS 22277:2017[43] on coroutines
  • ISO/IEC TS 19216:2018[44] on the networking library
  • ISO/IEC TS 21544:2018[45] on modules
  • ISO/IEC TS 19570:2018[46] on a new set of library extensions for parallelism

More technical specifications are in development and pending approval, including static reflection.[47]

Language

The C++ language has two main components: a direct mapping of hardware features provided primarily by the C subset, and zero-overhead abstractions based on those mappings. Stroustrup describes C++ as "a light-weight abstraction programming language [designed] for building and using efficient and elegant abstractions";[7] and "offering both hardware access and abstraction is the basis of C++. Doing it efficiently is what distinguishes it from other languages".[48]

C++ inherits most of C's syntax. The following is Bjarne Stroustrup's version of the Hello world program that uses the C++ Standard Library stream facility to write a message to standard output:[49][50]

1 #include <iostream>
2 
3 int main()
4 {
5     std::cout << "Hello, world!\n";
6 }

Object storage

As in C, C++ supports four types of memory management: static storage duration objects, thread storage duration objects, automatic storage duration objects, and dynamic storage duration objects.[51]

Static storage duration objects

Static storage duration objects are created before main() is entered (see exceptions below) and destroyed in reverse order of creation after main() exits. The exact order of creation is not specified by the standard (though there are some rules defined below) to allow implementations some freedom in how to organize their implementation. More formally, objects of this type have a lifespan that "shall last for the duration of the program".[52]

Static storage duration objects are initialized in two phases. First, "static initialization" is performed, and only after all static initialization is performed, "dynamic initialization" is performed. In static initialization, all objects are first initialized with zeros; after that, all objects that have a constant initialization phase are initialized with the constant expression (i.e. variables initialized with a literal or constexpr). Though it is not specified in the standard, the static initialization phase can be completed at compile time and saved in the data partition of the executable. Dynamic initialization involves all object initialization done via a constructor or function call (unless the function is marked with constexpr, in C++11). The dynamic initialization order is defined as the order of declaration within the compilation unit (i.e. the same file). No guarantees are provided about the order of initialization between compilation units.

Thread storage duration objects

Variables of this type are very similar to static storage duration objects. The main difference is the creation time is just prior to thread creation and destruction is done after the thread has been joined.[53]

Automatic storage duration objects

The most common variable types in C++ are local variables inside a function or block, and temporary variables.[54] The common feature about automatic variables is that they have a lifetime that is limited to the scope of the variable. They are created and potentially initialized at the point of declaration (see below for details) and destroyed in the reverse order of creation when the scope is left. This is implemented by allocation on the stack.

Local variables are created as the point of execution passes the declaration point. If the variable has a constructor or initializer this is used to define the initial state of the object. Local variables are destroyed when the local block or function that they are declared in is closed. C++ destructors for local variables are called at the end of the object lifetime, allowing a discipline for automatic resource management termed RAII, which is widely used in C++.

Member variables are created when the parent object is created. Array members are initialized from 0 to the last member of the array in order. Member variables are destroyed when the parent object is destroyed in the reverse order of creation. i.e. If the parent is an "automatic object" then it will be destroyed when it goes out of scope which triggers the destruction of all its members.

Temporary variables are created as the result of expression evaluation and are destroyed when the statement containing the expression has been fully evaluated (usually at the ; at the end of a statement).

Dynamic storage duration objects

These objects have a dynamic lifespan and are created with a call to new and destroyed explicitly with a call to delete.[55]

Templates

C++ templates enable generic programming. C++ supports function, class, alias and variable templates. Templates may be parameterized by types, compile-time constants, and other templates. Templates are implemented by instantiation at compile-time. To instantiate a template, compilers substitute specific arguments for a template's parameters to generate a concrete function or class instance. Some substitutions are not possible; these are eliminated by an overload resolution policy described by the phrase "Substitution failure is not an error" (SFINAE). Templates are a powerful tool that can be used for generic programming, template metaprogramming, and code optimization, but this power implies a cost. Template use may increase code size, because each template instantiation produces a copy of the template code: one for each set of template arguments, however, this is the same or smaller amount of code that would be generated if the code was written by hand.[56] This is in contrast to run-time generics seen in other languages (e.g., Java) where at compile-time the type is erased and a single template body is preserved.

Templates are different from macros: while both of these compile-time language features enable conditional compilation, templates are not restricted to lexical substitution. Templates are aware of the semantics and type system of their companion language, as well as all compile-time type definitions, and can perform high-level operations including programmatic flow control based on evaluation of strictly type-checked parameters. Macros are capable of conditional control over compilation based on predetermined criteria, but cannot instantiate new types, recurse, or perform type evaluation and in effect are limited to pre-compilation text-substitution and text-inclusion/exclusion. In other words, macros can control compilation flow based on pre-defined symbols but cannot, unlike templates, independently instantiate new symbols. Templates are a tool for static polymorphism (see below) and generic programming.

In addition, templates are a compile time mechanism in C++ that is Turing-complete, meaning that any computation expressible by a computer program can be computed, in some form, by a template metaprogram prior to runtime.

In summary, a template is a compile-time parameterized function or class written without knowledge of the specific arguments used to instantiate it. After instantiation, the resulting code is equivalent to code written specifically for the passed arguments. In this manner, templates provide a way to decouple generic, broadly applicable aspects of functions and classes (encoded in templates) from specific aspects (encoded in template parameters) without sacrificing performance due to abstraction.

Objects

C++ introduces object-oriented programming (OOP) features to C. It offers classes, which provide the four features commonly present in OOP (and some non-OOP) languages: abstraction, encapsulation, inheritance, and polymorphism. One distinguishing feature of C++ classes compared to classes in other programming languages is support for deterministic destructors, which in turn provide support for the Resource Acquisition is Initialization (RAII) concept.

Encapsulation

Encapsulation is the hiding of information to ensure that data structures and operators are used as intended and to make the usage model more obvious to the developer. C++ provides the ability to define classes and functions as its primary encapsulation mechanisms. Within a class, members can be declared as either public, protected, or private to explicitly enforce encapsulation. A public member of the class is accessible to any function. A private member is accessible only to functions that are members of that class and to functions and classes explicitly granted access permission by the class ("friends"). A protected member is accessible to members of classes that inherit from the class in addition to the class itself and any friends.

The object-oriented principle ensures the encapsulation of all and only the functions that access the internal representation of a type. C++ supports this principle via member functions and friend functions, but it does not enforce it. Programmers can declare parts or all of the representation of a type to be public, and they are allowed to make public entities not part of the representation of a type. Therefore, C++ supports not just object-oriented programming, but other decomposition paradigms such as modular programming.

It is generally considered good practice to make all data private or protected, and to make public only those functions that are part of a minimal interface for users of the class. This can hide the details of data implementation, allowing the designer to later fundamentally change the implementation without changing the interface in any way.[57][58]

Inheritance

Inheritance allows one data type to acquire properties of other data types. Inheritance from a base class may be declared as public, protected, or private. This access specifier determines whether unrelated and derived classes can access the inherited public and protected members of the base class. Only public inheritance corresponds to what is usually meant by "inheritance". The other two forms are much less frequently used. If the access specifier is omitted, a "class" inherits privately, while a "struct" inherits publicly. Base classes may be declared as virtual; this is called virtual inheritance. Virtual inheritance ensures that only one instance of a base class exists in the inheritance graph, avoiding some of the ambiguity problems of multiple inheritance.

Multiple inheritance is a C++ feature not found in most other languages, allowing a class to be derived from more than one base class; this allows for more elaborate inheritance relationships. For example, a "Flying Cat" class can inherit from both "Cat" and "Flying Mammal". Some other languages, such as C# or Java, accomplish something similar (although more limited) by allowing inheritance of multiple interfaces while restricting the number of base classes to one (interfaces, unlike classes, provide only declarations of member functions, no implementation or member data). An interface as in C# and Java can be defined in C++ as a class containing only pure virtual functions, often known as an abstract base class or "ABC". The member functions of such an abstract base class are normally explicitly defined in the derived class, not inherited implicitly. C++ virtual inheritance exhibits an ambiguity resolution feature called dominance.

Operators and operator overloading

Operators that cannot be overloaded
Operator Symbol
Scope resolution operator ::
Conditional operator ?:
dot operator .
Member selection operator .*
"sizeof" operator sizeof
"typeid" operator typeid

C++ provides more than 35 operators, covering basic arithmetic, bit manipulation, indirection, comparisons, logical operations and others. Almost all operators can be overloaded for user-defined types, with a few notable exceptions such as member access (. and .*) as well as the conditional operator. The rich set of overloadable operators is central to making user-defined types in C++ seem like built-in types.

Overloadable operators are also an essential part of many advanced C++ programming techniques, such as smart pointers. Overloading an operator does not change the precedence of calculations involving the operator, nor does it change the number of operands that the operator uses (any operand may however be ignored by the operator, though it will be evaluated prior to execution). Overloaded "&&" and "||" operators lose their short-circuit evaluation property.

Polymorphism

Polymorphism enables one common interface for many implementations, and for objects to act differently under different circumstances.

C++ supports several kinds of static (resolved at compile-time) and dynamic (resolved at run-time) polymorphisms, supported by the language features described above. Compile-time polymorphism does not allow for certain run-time decisions, while runtime polymorphism typically incurs a performance penalty.

Static polymorphism

Function overloading allows programs to declare multiple functions having the same name but with different arguments (i.e. ad hoc polymorphism). The functions are distinguished by the number or types of their formal parameters. Thus, the same function name can refer to different functions depending on the context in which it is used. The type returned by the function is not used to distinguish overloaded functions and would result in a compile-time error message.

When declaring a function, a programmer can specify for one or more parameters a default value. Doing so allows the parameters with defaults to optionally be omitted when the function is called, in which case the default arguments will be used. When a function is called with fewer arguments than there are declared parameters, explicit arguments are matched to parameters in left-to-right order, with any unmatched parameters at the end of the parameter list being assigned their default arguments. In many cases, specifying default arguments in a single function declaration is preferable to providing overloaded function definitions with different numbers of parameters.

Templates in C++ provide a sophisticated mechanism for writing generic, polymorphic code (i.e. parametric polymorphism). In particular, through the curiously recurring template pattern, it's possible to implement a form of static polymorphism that closely mimics the syntax for overriding virtual functions. Because C++ templates are type-aware and Turing-complete, they can also be used to let the compiler resolve recursive conditionals and generate substantial programs through template metaprogramming. Contrary to some opinion, template code will not generate a bulk code after compilation with the proper compiler settings.[56]

Dynamic polymorphism

Variable pointers and references to a base class type in C++ can also refer to objects of any derived classes of that type. This allows arrays and other kinds of containers to hold pointers to objects of differing types (references cannot be directly held in containers). This enables dynamic (run-time) polymorphism, where the referred objects can behave differently depending on their (actual, derived) types.

C++ also provides the dynamic_cast operator, which allows code to safely attempt conversion of an object, via a base reference/pointer, to a more derived type: downcasting. The attempt is necessary as often one does not know which derived type is referenced. (Upcasting, conversion to a more general type, can always be checked/performed at compile-time via static_cast, as ancestral classes are specified in the derived class's interface, visible to all callers.) dynamic_cast relies on run-time type information (RTTI), metadata in the program that enables differentiating types and their relationships. If a dynamic_cast to a pointer fails, the result is the nullptr constant, whereas if the destination is a reference (which cannot be null), the cast throws an exception. Objects known to be of a certain derived type can be cast to that with static_cast, bypassing RTTI and the safe runtime type-checking of dynamic_cast, so this should be used only if the programmer is very confident the cast is, and will always be, valid.

Ordinarily, when a function in a derived class overrides a function in a base class, the function to call is determined by the type of the object. A given function is overridden when there exists no difference in the number or type of parameters between two or more definitions of that function. Hence, at compile time, it may not be possible to determine the type of the object and therefore the correct function to call, given only a base class pointer; the decision is therefore put off until runtime. This is called dynamic dispatch. Virtual member functions or methods[59] allow the most specific implementation of the function to be called, according to the actual run-time type of the object. In C++ implementations, this is commonly done using virtual function tables. If the object type is known, this may be bypassed by prepending a fully qualified class name before the function call, but in general calls to virtual functions are resolved at run time.

In addition to standard member functions, operator overloads and destructors can be virtual. As a rule of thumb, if any function in the class is virtual, the destructor should be as well. As the type of an object at its creation is known at compile time, constructors, and by extension copy constructors, cannot be virtual. Nonetheless a situation may arise where a copy of an object needs to be created when a pointer to a derived object is passed as a pointer to a base object. In such a case, a common solution is to create a clone() (or similar) virtual function that creates and returns a copy of the derived class when called.

A member function can also be made "pure virtual" by appending it with = 0 after the closing parenthesis and before the semicolon. A class containing a pure virtual function is called an abstract class. Objects cannot be created from an abstract class; they can only be derived from. Any derived class inherits the virtual function as pure and must provide a non-pure definition of it (and all other pure virtual functions) before objects of the derived class can be created. A program that attempts to create an object of a class with a pure virtual member function or inherited pure virtual member function is ill-formed.

Lambda expressions

C++ provides support for anonymous functions, also known as lambda expressions, with the following form:

[capture](parameters) -> return_type { function_body }

The [capture] list supports the definition of closures. Such lambda expressions are defined in the standard as syntactic sugar for an unnamed function object. An example lambda function may be defined as follows:

[](int x, int y) -> int { return x + y; }

Exception handling

Exception handling is used to communicate the existence of a runtime problem or error from where it was detected to where the issue can be handled.[60] It permits this to be done in a uniform manner and separately from the main code, while detecting all errors.[61] Should an error occur, an exception is thrown (raised), which is then caught by the nearest suitable exception handler. The exception causes the current scope to be exited, and also each outer scope (propagation) until a suitable handler is found, calling in turn the destructors of any objects in these exited scopes.[62] At the same time, an exception is presented as an object carrying the data about the detected problem.[63]

Note that many C++ "styles" like Google's,[64] forbid usage of exceptions in C++ programs.

The exception-causing code is placed inside a try block. The exceptions are handled in separate catch blocks (the handlers); each try block can have multiple exception handlers, as it is visible in the example below.[65]

 1 #include <iostream>
 2 #include <vector>
 3 #include <stdexcept>
 4 
 5 int main() {
 6     try {
 7         std::vector<int> vec{3, 4, 3, 1};
 8         int i{vec.at(4)}; // Throws an exception, std::out_of_range (indexing for vec is from 0-3 not 1-4)
 9     }
10     // An exception handler, catches std::out_of_range, which is thrown by vec.at(4)
11     catch (std::out_of_range &e) {
12         std::cerr << "Accessing a non-existent element: " << e.what() << '\n';
13     }
14     // To catch any other standard library exceptions (they derive from std::exception)
15     catch (std::exception &e) {
16         std::cerr << "Exception thrown: " << e.what() << '\n';
17     }
18     // Catch any unrecognised exceptions (i.e. those which don't derive from std::exception)
19     catch (...) {
20         std::cerr << "Some fatal error\n";
21     }
22 }

It is also possible to raise exceptions purposefully, using the throw keyword; these exceptions are handled in the usual way. In some cases, exceptions cannot be used due to technical reasons. One such example is a critical component of an embedded system, where every operation must be guaranteed to complete within a specified amount of time. This cannot be determined with exceptions as no tools exist to determine the maximum time required for an exception to be handled.[66]

Standard library

The C++ standard consists of two parts: the core language and the standard library. C++ programmers expect the latter on every major implementation of C++; it includes aggregate types (vectors, lists, maps, sets, queues, stacks, arrays, tuples), algorithms (find, for_each, binary_search, random_shuffle, etc.), input/output facilities (iostream, for reading from and writing to the console and files), filesystem library, localisation support, smart pointers for automatic memory management, regular expression support, multi-threading library, atomics support (allowing a variable to be read or written to by at most one thread at a time without any external synchronisation), time utilities (measurement, getting current time, etc.), a system for converting error reporting that doesn't use C++ exceptions into C++ exceptions, a random number generator and a slightly modified version of the C standard library (to make it comply with the C++ type system).

A large part of the C++ library is based on the Standard Template Library (STL). Useful tools provided by the STL include containers as the collections of objects (such as vectors and lists), iterators that provide array-like access to containers, and algorithms that perform operations such as searching and sorting.

Furthermore, (multi)maps (associative arrays) and (multi)sets are provided, all of which export compatible interfaces. Therefore, using templates it is possible to write generic algorithms that work with any container or on any sequence defined by iterators. As in C, the features of the library are accessed by using the #include directive to include a standard header. The C++ Standard Library provides 105 standard headers, of which 27 are deprecated.

The standard incorporates the STL that was originally designed by Alexander Stepanov, who experimented with generic algorithms and containers for many years. When he started with C++, he finally found a language where it was possible to create generic algorithms (e.g., STL sort) that perform even better than, for example, the C standard library qsort, thanks to C++ features like using inlining and compile-time binding instead of function pointers. The standard does not refer to it as "STL", as it is merely a part of the standard library, but the term is still widely used to distinguish it from the rest of the standard library (input/output streams, internationalization, diagnostics, the C library subset, etc.).[67]

Most C++ compilers, and all major ones, provide a standards-conforming implementation of the C++ standard library.

Compatibility

To give compiler vendors greater freedom, the C++ standards committee decided not to dictate the implementation of name mangling, exception handling, and other implementation-specific features. The downside of this decision is that object code produced by different compilers is expected to be incompatible. There were, however, attempts to standardize compilers for particular machines or operating systems (for example C++ ABI),[68] though they seem to be largely abandoned now.

With C

C++ is often considered to be a superset of C but this is not strictly true.[69] Most C code can easily be made to compile correctly in C++ but there are a few differences that cause some valid C code to be invalid or behave differently in C++. For example, C allows implicit conversion from void* to other pointer types but C++ does not (for type safety reasons). Also, C++ defines many new keywords, such as new and class, which may be used as identifiers (for example, variable names) in a C program.

Some incompatibilities have been removed by the 1999 revision of the C standard (C99), which now supports C++ features such as line comments (//) and declarations mixed with code. On the other hand, C99 introduced a number of new features that C++ did not support that were incompatible or redundant in C++, such as variable-length arrays, native complex-number types (however, the std::complex class in the C++ standard library provides similar functionality, although not code-compatible), designated initializers, compound literals, and the restrict keyword.[70] Some of the C99-introduced features were included in the subsequent version of the C++ standard, C++11 (out of those which were not redundant).[71][72][73] However, the C++11 standard introduces new incompatibilities, such as disallowing assignment of a string literal to a character pointer, which remains valid C.

To intermix C and C++ code, any function declaration or definition that is to be called from/used both in C and C++ must be declared with C linkage by placing it within an extern "C" {/*...*/} block. Such a function may not rely on features depending on name mangling (i.e., function overloading).

Criticism

Despite its widespread adoption, some notable programmers have criticized the C++ language, including Linus Torvalds,[74] Richard Stallman,[75] Joshua Bloch, Ken Thompson,[76][77][78] and Donald Knuth.[79][80]

One of the most often criticised points of C++ is its perceived complexity as a language, with the criticism that a large number of non-orthogonal features in practice necessitates restricting code to subset of C++, thus eschewing the readability benefits of common style and idioms. As expressed by Joshua Bloch:

I think C++ was pushed well beyond its complexity threshold and yet there are a lot of people programming it. But what you do is you force people to subset it. So almost every shop that I know of that uses C++ says, “Yes, we’re using C++ but we’re not doing multiple-implementation inheritance and we’re not using operator overloading.” There are just a bunch of features that you’re not going to use because the complexity of the resulting code is too high. And I don’t think it’s good when you have to start doing that. You lose this programmer portability where everyone can read everyone else’s code, which I think is such a good thing.

Donald Knuth (1993, commenting on pre-standardized C++), who said of Edsger Dijkstra that "to think of programming in C++" "would make him physically ill":[79][80]

The problem that I have with them today is that... C++ is too complicated. At the moment, it's impossible for me to write portable code that I believe would work on lots of different systems, unless I avoid all exotic features. Whenever the C++ language designers had two competing ideas as to how they should solve some problem, they said "OK, we'll do them both". So the language is too baroque for my taste.

Ken Thompson, who was a colleague of Stroustrup at Bell Labs, gives his assessment:[77][78]

It certainly has its good points. But by and large I think it’s a bad language. It does a lot of things half well and it’s just a garbage heap of ideas that are mutually exclusive. Everybody I know, whether it’s personal or corporate, selects a subset and these subsets are different. So it’s not a good language to transport an algorithm—to say, “I wrote it; here, take it.” It’s way too big, way too complex. And it’s obviously built by a committee. Stroustrup campaigned for years and years and years, way beyond any sort of technical contributions he made to the language, to get it adopted and used. And he sort of ran all the standards committees with a whip and a chair. And he said “no” to no one. He put every feature in that language that ever existed. It wasn’t cleanly designed—it was just the union of everything that came along. And I think it suffered drastically from that.

However Brian Kernighan, also a colleague at Bell Labs, disputes this assessment:[81]

C++ has been enormously influential. ... Lots of people say C++ is too big and too complicated etc. etc. but in fact it is a very powerful language and pretty much everything that is in there is there for a really sound reason: it is not somebody doing random invention, it is actually people trying to solve real world problems. Now a lot of the programs that we take for granted today, that we just use, are C++ programs.

Stroustrup himself comments that C++ semantics are much cleaner than its syntax: "within C++, there is a much smaller and cleaner language struggling to get out".[82]

Other complaints may include a lack of reflection or garbage collection, slow compilation times, perceived feature creep,[83] and verbose error messages, particularly from template metaprogramming.[84]

See also

References

  1. ^ Stroustrup, Bjarne (1997). "1". The C++ Programming Language (Third ed.). ISBN 0-201-88954-4. OCLC 59193992.
  2. ^ Naugler, David (May 2007). "C# 2.0 for C++ and Java programmer: conference workshop". Journal of Computing Sciences in Colleges. 22 (5). Although C# has been strongly influenced by Java it has also been strongly influenced by C++ and is best viewed as a descendant of both C++ and Java.
  3. ^ "Chapel spec (Acknowledgements)" (PDF). Cray Inc. 1 October 2015. Retrieved 14 January 2016.
  4. ^ "Rich Hickey Q&A by Michael Fogus". Archived from the original on 2017-01-11. Retrieved 2017-01-11.
  5. ^ Harry. H. Chaudhary (28 July 2014). "Cracking The Java Programming Interview :: 2000+ Java Interview Que/Ans". Retrieved 29 May 2016.
  6. ^ "9. Classes — Python 3.6.4 documentation". docs.python.org. Retrieved 2018-01-09.
  7. ^ a b c Stroustrup, B. (6 May 2014). "Lecture:The essence of C++. University of Edinburgh". Retrieved 12 June 2015.
  8. ^ Stroustrup, Bjarne (17 February 2014). "C++ Applications". stroustrup.com. Retrieved 5 May 2014.
  9. ^ a b "ISO/IEC 14882:2017". International Organization for Standardization.
  10. ^ "Bjarne Stroustrup's Homepage". www.stroustrup.com.
  11. ^ "C++; Where it's heading".
  12. ^ a b Stroustrup, Bjarne (7 March 2010). "Bjarne Stroustrup's FAQ: When was C++ invented?". stroustrup.com. Retrieved 16 September 2010.
  13. ^ a b Stroustrup, Bjarne. "Evolving a language in and for the real world: C++ 1991-2006" (PDF).
  14. ^ a b c Stroustrup, Bjarne. "A History of C ++ : 1979− 1991" (PDF).
  15. ^ Stroustrup, Bjarne. "The C++ Programming Language" (First ed.). Retrieved 16 September 2010.
  16. ^ Stroustrup, Bjarne. "The C++ Programming Language" (Second ed.). Retrieved 16 September 2010.
  17. ^ a b https://herbsutter.com/2016/06/30/trip-report-summer-iso-c-standards-meeting-oulu/ "the next standard after C++17 will be C++20"
  18. ^ "Latest news." TIOBE Index | TIOBE - The Software Quality Company. N.p., n.d. Web. 5 June 2017.
  19. ^ Krill, Paul. "Java, C, C face growing competition in popularity." InfoWorld. InfoWorld, 10 February 2017. Web. 5 June 2017.
  20. ^ https://www.nae.edu/177355.aspx "Computer Science Pioneer Bjarne Stroustrup to Receive the 2018 Charles Stark Draper Prize for Engineering"
  21. ^ "Bjarne Stroustrup's FAQ – Where did the name "C++" come from?". Retrieved 16 January 2008.
  22. ^ "C For C++ Programmers". Northeastern University. Archived from the original on 17 November 2010. Retrieved 7 September 2015.
  23. ^ "ISO/IEC 14882:1998". International Organization for Standardization.
  24. ^ "ISO/IEC 14882:2003". International Organization for Standardization.
  25. ^ a b "ISO/IEC 14882:2011". International Organization for Standardization.
  26. ^ "ISO/IEC 14882:2014". International Organization for Standardization.
  27. ^ "We have an international standard: C++0x is unanimously approved". Sutter's Mill.
  28. ^ "The Future of C++".
  29. ^ "We have C++14! : Standard C++".
  30. ^ Trip report: Summer ISO C++ standards meeting (Toronto)
  31. ^ "ISO/IEC TR 18015:2006". International Organization for Standardization.
  32. ^ "ISO/IEC TR 19768:2007". International Organization for Standardization.
  33. ^ "ISO/IEC TR 29124:2010". International Organization for Standardization.
  34. ^ "ISO/IEC TR 24733:2011". International Organization for Standardization.
  35. ^ "ISO/IEC TS 18822:2015". International Organization for Standardization.
  36. ^ "ISO/IEC TS 19570:2015". International Organization for Standardization.
  37. ^ "ISO/IEC TS 19841:2015". International Organization for Standardization.
  38. ^ "ISO/IEC TS 19568:2015". International Organization for Standardization.
  39. ^ "ISO/IEC TS 19217:2015". International Organization for Standardization.
  40. ^ "ISO/IEC TS 19571:2016". International Organization for Standardization.
  41. ^ "ISO/IEC TS 19568:2017". International Organization for Standardization.
  42. ^ "ISO/IEC TS 21425:2017". International Organization for Standardization.
  43. ^ "ISO/IEC TS 22277:2017". International Organization for Standardization.
  44. ^ "ISO/IEC TS 19216:2018". International Organization for Standardization.
  45. ^ "ISO/IEC TS 21544:2018". International Organization for Standardization.
  46. ^ "ISO/IEC TS 19570:2018". International Organization for Standardization.
  47. ^ See a list at https://en.cppreference.com/w/cpp/experimental visited 15 February 2019.
  48. ^ B. Stroustrup (interviewed by Sergio De Simone) (30 April 2015). "Stroustrup: Thoughts on C++17 - An Interview". Retrieved 8 July 2015.
  49. ^ Stroustrup, Bjarne (2000). The C++ Programming Language (Special ed.). Addison-Wesley. p. 46. ISBN 0-201-70073-5.
  50. ^ Stroustrup, Bjarne. "Open issues for The C++ Programming Language (3rd Edition)". This code is copied directly from Bjarne Stroustrup's errata page (p. 633). He addresses the use of '\n' rather than std::endl. Also see Can I write "void main()"? for an explanation of the implicit return 0; in the main function. This implicit return is not available in other functions.
  51. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) §3.7 Storage duration [basic.stc]
  52. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) §3.7.1 Static Storage duration [basic.stc.static]
  53. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) §3.7.2 Thread Storage duration [basic.stc.thread]
  54. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) §3.7.3 Automatic Storage duration [basic.stc.auto]
  55. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) §3.7.4 Dynamic Storage duration [basic.stc.dynamic]
  56. ^ a b "Nobody Understands C++: Part 5: Template Code Bloat". articles.emptycrate.com/: EmptyCrate Software. Travel. Stuff. 6 May 2008. Retrieved 8 March 2010. On occasion you will read or hear someone talking about C++ templates causing code bloat. I was thinking about it the other day and thought to myself, "self, if the code does exactly the same thing then the compiled code cannot really be any bigger, can it?" [...] And what about compiled code size? Each were compiled with the command g++ <filename>.cpp -O3. Non-template version: 8140 bytes, template version: 8028 bytes!
  57. ^ Sutter, Herb; Alexandrescu, Andrei (2004). C++ Coding Standards: 101 Rules, Guidelines, and Best Practices. Addison-Wesley.
  58. ^ Henricson, Mats; Nyquist, Erik (1997). Industrial Strength C++. Prentice Hall. ISBN 0-13-120965-5.
  59. ^ Stroustrup, Bjarne (2000). The C++ Programming Language (Special ed.). Addison-Wesley. p. 310. ISBN 0-201-70073-5. A virtual member function is sometimes called a method.
  60. ^ Mycroft, Alan (2013). "C and C++ Exceptions | Templates" (PDF). Cambridge Computer Laboratory - Course Materials 2013-14. Retrieved 30 August 2016.
  61. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. p. 345. ISBN 9780321563842.
  62. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. pp. 363–365. ISBN 9780321563842.
  63. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. pp. 345, 363. ISBN 9780321563842.
  64. ^ https://google.github.io/styleguide/cppguide.html#Exceptions
  65. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. pp. 344, 370. ISBN 9780321563842.
  66. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. p. 349. ISBN 9780321563842.
  67. ^ Graziano Lo Russo (2008). "An Interview with A. Stepanov". stlport.org. Retrieved 8 October 2015.
  68. ^ "C++ ABI Summary". 20 March 2001. Retrieved 30 May 2006.
  69. ^ "Bjarne Stroustrup's FAQ – Is C a subset of C++?". Retrieved 5 May 2014.
  70. ^ "C9X – The New C Standard". Retrieved 27 December 2008.
  71. ^ "C++0x Support in GCC". Retrieved 12 October 2010.
  72. ^ "C++0x Core Language Features In VC10: The Table". Retrieved 12 October 2010.
  73. ^ "Clang - C++98, C++11, and C++14 Status". Clang.llvm.org. 12 May 2013. Retrieved 10 June 2013.
  74. ^ "Re: [RFC] Convert builin-mailinfo.c to use The Better String Library" (Mailing list). 6 September 2007. Retrieved 31 March 2015.
  75. ^ "Re: Efforts to attract more users?" (Mailing list). 12 July 2010. Retrieved 31 March 2015.
  76. ^ Andrew Binstock (18 May 2011). "Dr. Dobb's: Interview with Ken Thompson". Retrieved 7 February 2014.
  77. ^ a b Peter Seibel (16 September 2009). Coders at Work: Reflections on the Craft of Programming. Apress. pp. 475–476. ISBN 978-1-4302-1948-4.
  78. ^ a b https://gigamonkeys.wordpress.com/2009/10/16/coders-c-plus-plus/
  79. ^ a b https://www.drdobbs.com/architecture-and-design/an-interview-with-donald-knuth/228700500
  80. ^ a b http://tex.loria.fr/litte/knuth-interview
  81. ^ Brian Kernighan (July 18, 2018). Brian Kernighan Q&A - Computerphile.
  82. ^ http://www.stroustrup.com/bs_faq.html#really-say-that
  83. ^ Pike, Rob (2012). "Less is exponentially more".
  84. ^ Kreinin, Yossi (13 October 2009). "Defective C++". Retrieved 3 February 2016.

Further reading

  • Abrahams, David; Gurtovoy, Aleksey. C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond. Addison-Wesley. ISBN 0-321-22725-5.
  • Alexandrescu, Andrei (2001). Modern C++ Design: Generic Programming and Design Patterns Applied. Addison-Wesley. ISBN 0-201-70431-5.
  • Alexandrescu, Andrei; Sutter, Herb (2004). C++ Design and Coding Standards: Rules and Guidelines for Writing Programs. Addison-Wesley. ISBN 0-321-11358-6.
  • Becker, Pete (2006). The C++ Standard Library Extensions : A Tutorial and Reference. Addison-Wesley. ISBN 0-321-41299-0.
  • Brokken, Frank (2010). C++ Annotations. University of Groningen. ISBN 90-367-0470-7.
  • Coplien, James O. (1994) [reprinted with corrections, original year of publication 1992]. Advanced C++: Programming Styles and Idioms. ISBN 0-201-54855-0.
  • Dewhurst, Stephen C. (2005). C++ Common Knowledge: Essential Intermediate Programming. Addison-Wesley. ISBN 0-321-32192-8.
  • Information Technology Industry Council (15 October 2003). Programming languages – C++ (Second ed.). Geneva: ISO/IEC. 14882:2003(E).
  • Josuttis, Nicolai M. (2012). The C++ Standard Library, A Tutorial and Reference (Second ed.). Addison-Wesley. ISBN 0-321-62321-5.
  • Koenig, Andrew; Moo, Barbara E. (2000). Accelerated C++ – Practical Programming by Example. Addison-Wesley. ISBN 0-201-70353-X.
  • Lippman, Stanley B.; Lajoie, Josée; Moo, Barbara E. (2011). C++ Primer (Fifth ed.). Addison-Wesley. ISBN 0-321-71411-3.
  • Lippman, Stanley B. (1996). Inside the C++ Object Model. Addison-Wesley. ISBN 0-201-83454-5.
  • Meyers, Scott (2005). Effective C++ (Third ed.). Addison-Wesley. ISBN 0-321-33487-6.
  • Stroustrup, Bjarne (2013). The C++ Programming Language (Fourth ed.). Addison-Wesley. ISBN 978-0-321-56384-2.
  • Stroustrup, Bjarne (1994). The Design and Evolution of C++. Addison-Wesley. ISBN 0-201-54330-3.
  • Stroustrup, Bjarne (2014). Programming Principles and Practice Using C++ (Second ed.). Addison-Wesley. ISBN 978-0-321-99278-9.
  • Sutter, Herb (2001). More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions. Addison-Wesley. ISBN 0-201-70434-X.
  • Sutter, Herb (2004). Exceptional C++ Style. Addison-Wesley. ISBN 0-201-76042-8.
  • Vandevoorde, David; Josuttis, Nicolai M. (2003). C++ Templates: The complete Guide. Addison-Wesley. ISBN 0-201-73484-2.

External links

  • JTC1/SC22/WG21 – the ISO/IEC C++ Standard Working Group
  • Standard C++ Foundation – a non-profit organization that promotes the use and understanding of standard C++. Bjarne Stroustrup is a director of the organization.
A.F.C. Bournemouth

A.F.C. Bournemouth ( (listen)) is a professional football club in Bournemouth, Dorset, that play in the Premier League, the top tier of the English football league system. Formed in 1890 as Boscombe St. John's Institute F.C., the club adopted their current name in 1972. Nicknamed The Cherries, since 1910 Bournemouth have played their home games at Dean Court. Their home colours are red and black striped shirts, with black shorts and socks.

A.F.C. Bournemouth have won the second and third tiers of English football, and were twice runners-up of the fourth tier. They have also won the Football League Trophy, and the Football League Third Division South Cup.

Bournemouth have spent the majority of their history bouncing between the third and fourth tier of English football. Under manager Eddie Howe, they have risen through the pyramid; the 2015–16 season was A.F.C. Bournemouth's first ever in England's top division.

The club is currently owned by Maxim Demin, a Russian multi-millionaire involved in the petrochemicals trading industry.

Boeing C-17 Globemaster III

The Boeing C-17 Globemaster III is a large military transport aircraft. It was developed for the United States Air Force (USAF) from the 1980s to the early 1990s by McDonnell Douglas. The C-17 carries forward the name of two previous piston-engined military cargo aircraft, the Douglas C-74 Globemaster and the Douglas C-124 Globemaster II. The C-17 commonly performs tactical and strategic airlift missions, transporting troops and cargo throughout the world; additional roles include medical evacuation and airdrop duties. It was designed to replace the Lockheed C-141 Starlifter, and also fulfill some of the duties of the Lockheed C-5 Galaxy, freeing the C-5 fleet for outsize cargo.Boeing, which merged with McDonnell Douglas in 1997, continued to manufacture C-17s for export customers following the end of deliveries to the U.S. Air Force. Aside from the United States, the C-17 is in service with the United Kingdom, Australia, Canada, Qatar, United Arab Emirates, NATO Heavy Airlift Wing, India, and Kuwait. The final C-17 was completed at the Long Beach, California plant and flown on 29 November 2015.

C. S. Lewis

Clive Staples Lewis (29 November 1898 – 22 November 1963) was a British writer and lay theologian. He held academic positions in English literature at both Oxford University (Magdalen College, 1925–1954) and Cambridge University (Magdalene College, 1954–1963). He is best known for his works of fiction, especially The Screwtape Letters, The Chronicles of Narnia, and The Space Trilogy, and for his non-fiction Christian apologetics, such as Mere Christianity, Miracles, and The Problem of Pain.

Lewis and fellow novelist J. R. R. Tolkien were close friends. They both served on the English faculty at Oxford University and were active in the informal Oxford literary group known as the Inklings. According to Lewis's memoir Surprised by Joy, he was baptised in the Church of Ireland, but fell away from his faith during adolescence. Lewis returned to Anglicanism at the age of 32, owing to the influence of Tolkien and other friends, and he became an "ordinary layman of the Church of England". Lewis's faith profoundly affected his work, and his wartime radio broadcasts on the subject of Christianity brought him wide acclaim.

Lewis wrote more than 30 books which have been translated into more than 30 languages and have sold millions of copies. The books that make up The Chronicles of Narnia have sold the most and have been popularised on stage, TV, radio, and cinema. His philosophical writings are widely cited by Christian apologists from many denominations.

In 1956, Lewis married American writer Joy Davidman; she died of cancer four years later at the age of 45. Lewis died on 22 November 1963 from renal failure, one week before his 65th birthday. In 2013, on the 50th anniversary of his death, Lewis was honoured with a memorial in Poets' Corner in Westminster Abbey.

C (programming language)

C (, as in the letter c) is a general-purpose, imperative computer programming language, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations. By design, C provides constructs that map efficiently to typical machine instructions, and it has therefore found lasting use in applications that were previously coded in assembly language. Such applications include operating systems, as well as various application software for computers ranging from supercomputers to embedded systems.

C was originally developed at Bell Labs by Dennis Ritchie, between 1972 and 1973. It was created to make utilities running on Unix. Later, it was applied to re-implementing the kernel of the Unix operating system. During the 1980s, C gradually gained popularity. Nowadays, it is one of the most widely used programming languages, with C compilers from various vendors available for the majority of existing computer architectures and operating systems. C has been standardized by the American National Standards Institute (ANSI) since 1989 (see ANSI C) and subsequently by the International Organization for Standardization (ISO).

C is an imperative procedural language. It was designed to be compiled using a relatively straightforward compiler, to provide low-level access to memory, to provide language constructs that map efficiently to machine instructions, and to require minimal runtime support. Despite its low-level capabilities, the language was designed to encourage cross-platform programming. A standards-compliant C program that is written with portability in mind can be compiled for a wide variety of computer platforms and operating systems with few changes to its source code; the language has become available on various platforms, from embedded microcontrollers to supercomputers.

C Sharp (programming language)

C# (pronounced C sharp) is a general-purpose, multi-paradigm programming language encompassing strong typing, lexically scoped, imperative, declarative, functional, generic, object-oriented (class-based), and component-oriented programming disciplines. It was developed around 2000 by Microsoft within its .NET initiative and later approved as a standard by Ecma (ECMA-334) and ISO (ISO/IEC 23270:2018). C# is one of the programming languages designed for the Common Language Infrastructure.

C# was designed by Anders Hejlsberg, and its development team is currently led by Mads Torgersen. The most recent version is C# 7.3, which was released in 2018 alongside Visual Studio 2017 version 15.7.2.

Celsius

The Celsius scale, also known as the centigrade scale, is a temperature scale used by the International System of Units (SI). As an SI derived unit, it is used by all countries except the United States, the Bahamas, Belize, the Cayman Islands and Liberia. It is named after the Swedish astronomer Anders Celsius (1701–1744), who developed a similar temperature scale. The degree Celsius (°C) can refer to a specific temperature on the Celsius scale or a unit to indicate a difference between two temperatures or an uncertainty. Before being renamed to honor Anders Celsius in 1948, the unit was called centigrade, from the Latin centum, which means 100, and gradus, which means steps.

From 1743, the Celsius scale is based on 0 °C for the freezing point of water and 100 °C for the boiling point of water at 1 atm pressure. Prior to 1743, the scale was also based on the boiling and melting points of water, but the values were reversed (i.e. the boiling point was at 0 degrees and the melting point was at 100 degrees). The 1743 scale reversal was proposed by Jean-Pierre Christin.

By international agreement, since 1954 the unit degree Celsius and the Celsius scale are defined by absolute zero and the triple point of Vienna Standard Mean Ocean Water (VSMOW), a specially purified water. This definition also precisely relates the Celsius scale to the Kelvin scale, which defines the SI base unit of thermodynamic temperature with symbol K. Absolute zero, the lowest temperature possible, is defined as being exactly 0 K and −273.15 °C. The temperature of the triple point of water is defined as exactly 273.16 K (0.01 °C). This means that a temperature difference of one degree Celsius and that of one kelvin are exactly the same.On May 20, 2019, the degree Kelvin, and along with it the degree Celsius, will again be re-defined so that its value will be determined by definition of the Boltzmann constant.

Circumference

In geometry, the circumference (from Latin circumferens, meaning "carrying around") of a circle is the (linear) distance around it. That is, the circumference would be the length of the circle if it were opened up and straightened out to a line segment. Since a circle is the edge (boundary) of a disk, circumference is a special case of perimeter. The perimeter is the length around any closed figure and is the term used for most figures excepting the circle and some circular-like figures such as ellipses.

Informally, "circumference" may also refer to the edge itself rather than to the length of the edge.

D.C. United

D.C. United is an American professional soccer club based in Washington, D.C. The club competes as a member of the Eastern Conference in Major League Soccer (MLS), the top level of professional American soccer. The franchise began play in 1996 as one of the ten charter clubs of the league. The club was one of the most successful clubs in the early years of MLS, winning eight of its thirteen titles between 1996 and 1998 under then head coach Bruce Arena. United holds the joint MLS record for most Supporters' Shields, has four MLS Cups, and been crowned U.S. Open Cup champions three times. It is also the first club to win both the MLS Supporters' Shield and MLS Cup consecutively.On the international stage, D.C. United has competed in both the CONCACAF Champions League and its predecessor, the CONCACAF Champions' Cup. The club won the 1998 CONCACAF Champions' Cup, making them one of only two MLS teams to ever win a CONCACAF tournament. Subsequently, United won the now-defunct Copa Interamericana in 1998 against Vasco da Gama of Brazil. This is the only intercontinental title won by an MLS club.The team's home field from 1996 to 2017 was the 45,596-seat Robert F. Kennedy Memorial Stadium, owned by the District of Columbia. The team moved into the new Audi Field, a soccer-specific stadium with a capacity of 20,000 at Buzzard Point just a few blocks from Nationals Park in July 2018. The team is owned by the consortium D.C. United Holdings. The team's head coach is former long-time starting midfielder Ben Olsen, who has coached the team since 2010.

Jaime Moreno, Marco Etcheverry, and Eddie Pope are among the team's most successful stars. D.C. United's fan base includes four supporters' clubs. The club's official nickname is the "Black-and-Red" and home uniforms are black and white with accents of red. The team's name alludes to the "United" appellation commonly found in the names of soccer teams in the United Kingdom and elsewhere.

Douglas C-47 Skytrain

The Douglas C-47 Skytrain or Dakota (RAF designation) is a military transport aircraft developed from the civilian Douglas DC-3 airliner. It was used extensively by the Allies during World War II and remains in front line service with various military operators.

Douglas DC-3

The Douglas DC-3 is a fixed-wing propeller-driven airliner that revolutionized air transport in the 1930s and 1940s. Its lasting effect on the airline industry and World War II makes it one of the most significant transport aircraft ever produced. It has a cruise speed of 207 mph (333 km/h), capacity of 21 to 32 passengers or 6,000 lbs (2,700 kg) of cargo and a range of 1,500 mi (2,400 km).

The DC-3 is a twin-engine metal monoplane with a tailwheel-type landing gear and was developed as a larger, improved 14-bed sleeper version of the Douglas DC-2. It had many exceptional qualities compared to previous aircraft. It was fast, had good range and could operate from short runways. It was reliable and easy to maintain and carried passengers in greater comfort. Before the war it pioneered many air travel routes. It could cross the continental United States and made worldwide flights possible. It is considered the first airliner that could profitably carry just passengers.Civil DC-3 production ended in 1942 at 607 aircraft. Military versions, including the C-47 Skytrain (designated the Dakota in British Royal Air Force (RAF) service), and Russian- and Japanese-built versions, brought total production to over 16,000. Following the war, the airliner market was flooded with surplus C-47s and other ex-military transport aircraft, and Douglas' attempts to produce an upgraded DC-3 failed due to cost.

Post-war, the DC-3 was made obsolete on main routes by more advanced types such as the Douglas DC-6 and Lockheed Constellation, but the design proved exceptionally adaptable and useful. Large numbers continue to see service in a wide variety of niche roles well into the 21st century. In 2013 it was estimated that approximately 2,000 DC-3s and military derivatives were still flying, a testament to the durability of the design.

Halley's Comet

Halley's Comet or Comet Halley, officially designated 1P/Halley, is a short-period comet visible from Earth every 75–76 years. Halley is the only known short-period comet that is regularly visible to the naked eye from Earth, and the only naked-eye comet that might appear twice in a human lifetime. Halley last appeared in the inner parts of the Solar System in 1986 and will next appear in mid-2061.Halley's returns to the inner Solar System have been observed and recorded by astronomers since at least 240 BC. Clear records of the comet's appearances were made by Chinese, Babylonian, and medieval European chroniclers, but were not recognized as reappearances of the same object at the time. The comet's periodicity was first determined in 1705 by English astronomer Edmond Halley, after whom it is now named.

During its 1986 apparition, Halley's Comet became the first comet to be observed in detail by spacecraft, providing the first observational data on the structure of a comet nucleus and the mechanism of coma and tail formation. These observations supported a number of longstanding hypotheses about comet construction, particularly Fred Whipple's "dirty snowball" model, which correctly predicted that Halley would be composed of a mixture of volatile ices—such as water, carbon dioxide, and ammonia—and dust. The missions also provided data that substantially reformed and reconfigured these ideas; for instance, it is now understood that the surface of Halley is largely composed of dusty, non-volatile materials, and that only a small portion of it is icy.

Hepatitis C

Hepatitis C is an infectious disease caused by the hepatitis C virus (HCV) that primarily affects the liver. During the initial infection people often have mild or no symptoms. Occasionally a fever, dark urine, abdominal pain, and yellow tinged skin occurs. The virus persists in the liver in about 75% to 85% of those initially infected. Early on chronic infection typically has no symptoms. Over many years however, it often leads to liver disease and occasionally cirrhosis. In some cases, those with cirrhosis will develop serious complications such as liver failure, liver cancer, or dilated blood vessels in the esophagus and stomach.HCV is spread primarily by blood-to-blood contact associated with intravenous drug use, poorly sterilized medical equipment, needlestick injuries in healthcare, and transfusions. Using blood screening, the risk from a transfusion is less than one per two million. It may also be spread from an infected mother to her baby during birth. It is not spread by superficial contact. It is one of five known hepatitis viruses: A, B, C, D, and E. Diagnosis is by blood testing to look for either antibodies to the virus or its RNA. Testing is recommended in all people who are at risk.There is no vaccine against hepatitis C. Prevention includes harm reduction efforts among people who use intravenous drugs and testing donated blood. Chronic infection can be cured about 95% of the time with antiviral medications such as sofosbuvir or simeprevir. Peginterferon and ribavirin were earlier generation treatments that had a cure rate of less than 50% and greater side effects. Getting access to the newer treatments however can be expensive. Those who develop cirrhosis or liver cancer may require a liver transplant. Hepatitis C is the leading reason for liver transplantation, though the virus usually recurs after transplantation.An estimated 143 million people (2%) worldwide are infected with hepatitis C as of 2015. In 2013 about 11 million new cases occurred. It occurs most commonly in Africa and Central and East Asia. About 167,000 deaths due to liver cancer and 326,000 deaths due to cirrhosis occurred in 2015 due to hepatitis C. The existence of hepatitis C – originally identifiable only as a type of non-A non-B hepatitis – was suggested in the 1970s and proven in 1989. Hepatitis C infects only humans and chimpanzees.

Lockheed C-130 Hercules

The Lockheed C-130 Hercules is an American four-engine turboprop military transport aircraft designed and built originally by Lockheed (now Lockheed Martin). Capable of using unprepared runways for takeoffs and landings, the C-130 was originally designed as a troop, medevac, and cargo transport aircraft. The versatile airframe has found uses in a variety of other roles, including as a gunship (AC-130), for airborne assault, search and rescue, scientific research support, weather reconnaissance, aerial refueling, maritime patrol, and aerial firefighting. It is now the main tactical airlifter for many military forces worldwide. More than 40 variants of the Hercules, including a civilian one marketed as the Lockheed L-100, operate in more than 60 nations.

The C-130 entered service with the U.S. in 1956, followed by Australia and many other nations. During its years of service, the Hercules family has participated in numerous military, civilian and humanitarian aid operations. In 2007, the C-130 became the fifth aircraft to mark 50 years of continuous service with its original primary customer, which for the C-130 is the United States Air Force. The C-130 Hercules is the longest continuously produced military aircraft at over 60 years, with the updated Lockheed Martin C-130J Super Hercules currently being produced.

Louis C.K.

Louis Székely () (born September 12, 1967), better known by his stage name Louis C.K. (), is an American-Mexican stand-up comedian, writer, actor, and filmmaker. In 2012, C.K. won a Peabody Award and has received six Primetime Emmy Awards, as well as numerous awards for The Chris Rock Show, Louie, and his stand-up specials Live at the Beacon Theater (2011) and Oh My God (2013). He has won the Grammy Award for Best Comedy Album twice. Rolling Stone ranked C.K.'s stand-up special Shameless number three on their "Divine Comedy: 25 Best Stand-Up Specials and Movies of All Time" list and ranked him fourth on its 2017 list of the 50 best stand-up comics of all time.C.K. began his career in the 1990s writing for comedians including David Letterman, Conan O'Brien, Dana Carvey, Chris Rock, and also for other comedy shows. He was also directing surreal short films and went on to direct two features—Tomorrow Night (1998) and Pootie Tang (2001).

In 2001, C.K. released his debut comedy album, Live in Houston, directly through his website and became among the first performers to offer direct-to-fan sales of tickets to his stand-up shows, as well as DRM-free video concert downloads, via his website. He has released nine comedy albums, often directing and editing his specials as well.

He had supporting acting roles in the films American Hustle, Blue Jasmine (both 2013), and Trumbo (2015). C.K. created, directed, executive produced, starred in, wrote, and was the primary editor of Louie, an acclaimed semi-autobiographical comedy-drama series aired from 2010 to 2015 on FX. In 2016, C.K. created and starred in his self-funded web series Horace and Pete. He also co-created the shows Baskets and Better Things for FX and voiced the protagonist Max in the animated film The Secret Life of Pets in the same year. His 2017 film, I Love You, Daddy, was pulled from distribution prior to its scheduled release date after he was accused of past sexual misconduct, to which he admitted.

Radiocarbon dating

Radiocarbon dating (also referred to as carbon dating or carbon-14 dating) is a method for determining the age of an object containing organic material by using the properties of radiocarbon, a radioactive isotope of carbon.

The method was developed in the late 1940s by Willard Libby, who received the Nobel Prize in Chemistry for his work in 1960. It is based on the fact that radiocarbon (14C) is constantly being created in the atmosphere by the interaction of cosmic rays with atmospheric nitrogen. The resulting 14C combines with atmospheric oxygen to form radioactive carbon dioxide, which is incorporated into plants by photosynthesis; animals then acquire 14C by eating the plants. When the animal or plant dies, it stops exchanging carbon with its environment, and from that point onwards the amount of 14C it contains begins to decrease as the 14C undergoes radioactive decay. Measuring the amount of 14C in a sample from a dead plant or animal such as a piece of wood or a fragment of bone provides information that can be used to calculate when the animal or plant died. The older a sample is, the less 14C there is to be detected, and because the half-life of 14C (the period of time after which half of a given sample will have decayed) is about 5,730 years, the oldest dates that can be reliably measured by this process date to around 50,000 years ago, although special preparation methods occasionally permit accurate analysis of older samples.

Research has been ongoing since the 1960s to determine what the proportion of 14C in the atmosphere has been over the past fifty thousand years. The resulting data, in the form of a calibration curve, is now used to convert a given measurement of radiocarbon in a sample into an estimate of the sample's calendar age. Other corrections must be made to account for the proportion of 14C in different types of organisms (fractionation), and the varying levels of 14C throughout the biosphere (reservoir effects). Additional complications come from the burning of fossil fuels such as coal and oil, and from the above-ground nuclear tests done in the 1950s and 1960s. Because the time it takes to convert biological materials to fossil fuels is substantially longer than the time it takes for its 14C to decay below detectable levels, fossil fuels contain almost no 14C, and as a result there was a noticeable drop in the proportion of 14C in the atmosphere beginning in the late 19th century. Conversely, nuclear testing increased the amount of 14C in the atmosphere, which attained a maximum in about 1965 of almost twice what it had been before the testing began.

Measurement of radiocarbon was originally done by beta-counting devices, which counted the amount of beta radiation emitted by decaying 14C atoms in a sample. More recently, accelerator mass spectrometry has become the method of choice; it counts all the 14C atoms in the sample and not just the few that happen to decay during the measurements; it can therefore be used with much smaller samples (as small as individual plant seeds), and gives results much more quickly. The development of radiocarbon dating has had a profound impact on archaeology. In addition to permitting more accurate dating within archaeological sites than previous methods, it allows comparison of dates of events across great distances. Histories of archaeology often refer to its impact as the "radiocarbon revolution". Radiocarbon dating has allowed key transitions in prehistory to be dated, such as the end of the last ice age, and the beginning of the Neolithic and Bronze Age in different regions.

S.S.C. Napoli

Società Sportiva Calcio Napoli, commonly referred to as Napoli (pronounced [ˈnaːpoli]), is an Italian professional football club based in Naples, Campania. Formed in 1926, the club plays in Serie A, the top flight of Italian football. The club has won Serie A two times, and been runners-up six times, the Coppa Italia five times, the Supercoppa Italiana twice, and the 1988–89 UEFA Cup.Napoli have the fourth biggest fanbase in Italy, and in 2015 were ranked as the fifth most valuable football club in Serie A, as well as being listed on the Forbes' list of the most valuable football clubs. The club is one of the associate members of the European Club Association. In the January 2016 UEFA ratings, Napoli are ranked the eighth best club in European Football and the second best club in Italy.Since 1959, the club has played their home games at Stadio San Paolo in the Fuorigrotta suburb of Naples. Their home colours are sky blue shirts and white shorts. The official anthem of the club is "'O surdato 'nnammurato". Another anthem the Partenopei have coined is "Un giorno all'improvviso".

Triangle

A triangle is a polygon with three edges and three vertices. It is one of the basic shapes in geometry. A triangle with vertices A, B, and C is denoted .

In Euclidean geometry any three points, when non-collinear, determine a unique triangle and simultaneously, a unique plane (i.e. a two-dimensional Euclidean space). In other words, there is only one plane that contains that triangle, and every triangle is contained in some plane. If the entire geometry is only the Euclidean plane, there is only one plane and all triangles are contained in it; however, in higher-dimensional Euclidean spaces, this is no longer true. This article is about triangles in Euclidean geometry, and in particular, the Euclidean plane, except where otherwise noted.

Vitamin C

Vitamin C, also known as ascorbic acid and L-ascorbic acid, is a vitamin found in various foods and sold as a dietary supplement. It is used to prevent and treat scurvy. Vitamin C is an essential nutrient involved in the repair of tissue and the enzymatic production of certain neurotransmitters. It is required for the functioning of several enzymes and is important for immune system function. It also functions as an antioxidant.Evidence does not support use in the general population for the prevention of the common cold. There is, however, some evidence that regular use may shorten the length of colds. It is unclear whether supplementation affects the risk of cancer, cardiovascular disease, or dementia. It may be taken by mouth or by injection.Vitamin C is generally well tolerated. Large doses may cause gastrointestinal discomfort, headache, trouble sleeping, and flushing of the skin. Normal doses are safe during pregnancy. The United States Institute of Medicine recommends against taking large doses.Vitamin C was discovered in 1912, isolated in 1928, and in 1933 was the first vitamin to be chemically produced. It is on the World Health Organization Model List of Essential Medicines, the most effective and safe medicines needed in a health system. Vitamin C is available as an inexpensive generic medication and over-the-counter drug. Partly for its discovery, Albert Szent-Györgyi and Walter Norman Haworth were awarded the 1937 Nobel Prizes in Physiology and Medicine and Chemistry, respectively. Foods containing vitamin C include citrus fruits, kiwifruit, broccoli, Brussels sprouts, raw bell peppers, and strawberries. Prolonged storage or cooking may reduce vitamin C content in foods.

Washington, D.C.

Washington, D.C., formally the District of Columbia and commonly referred to as Washington or D.C., is the capital of the United States. Founded after the American Revolution as the seat of government of the newly independent country, Washington was named after George Washington, first President of the United States and Founding Father. As the seat of the United States federal government and several international organizations, Washington is an important world political capital. The city is also one of the most visited cities in the world, with more than 20 million tourists annually.The signing of the Residence Act on July 16, 1790, approved the creation of a capital district located along the Potomac River on the country's East Coast. The U.S. Constitution provided for a federal district under the exclusive jurisdiction of the U.S. Congress, and the District is therefore not a part of any state. The states of Maryland and Virginia each donated land to form the federal district, which included the pre-existing settlements of Georgetown and Alexandria. The City of Washington was founded in 1791 to serve as the new national capital. In 1846, Congress returned the land originally ceded by Virginia; in 1871, it created a single municipal government for the remaining portion of the District.

Washington had an estimated population of 702,455 as of July 2018, making it the 20th most populous city in the United States. Commuters from the surrounding Maryland and Virginia suburbs raise the city's daytime population to more than one million during the workweek. Washington's metropolitan area, the country's sixth largest, had a 2017 estimated population of 6.2 million residents.All three branches of the U.S. federal government are centered in the District: Congress (legislative), president (executive), and the U.S. Supreme Court (judicial). Washington is home to many national monuments, and museums, primarily situated on or around the National Mall. The city hosts 177 foreign embassies as well as the headquarters of many international organizations, trade unions, non-profit, lobbying groups, and professional associations, including the World Bank Group, the International Monetary Fund (IMF), the Organization of American States, AARP, the National Geographic Society, the Human Rights Campaign, the International Finance Corporation, and the American Red Cross.

A locally elected mayor and a 13‑member council have governed the District since 1973. However, Congress maintains supreme authority over the city and may overturn local laws. D.C. residents elect a non-voting, at-large congressional delegate to the House of Representatives, but the District has no representation in the Senate. The District receives three electoral votes in presidential elections as permitted by the Twenty-third Amendment to the United States Constitution, ratified in 1961.

ISO standards by standard number
1–9999
10000–19999
20000+
C++
Features
Standard Library
Compilers
IDEs
Superset languages
Dialects
Relative to
other languages
IEC standards
ISO/IEC standards
Related

This page is based on a Wikipedia article written by authors (here).
Text is available under the CC BY-SA 3.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.