Skip to content Skip to sidebar Skip to footer
Home / how to tell what type an object is from its base class c#

how to tell what type an object is from its base class c#

Post a Comment

General-purpose programming language

C++
ISO C++ Logo.svg

Logo endorsed by Standard C++
Paradigms Multi-paradigm: procedural, functional, object-oriented, generic, modular
Family C
Designed by Bjarne Stroustrup
Programmer ISO/IEC JTC1 (Joint Technical Committee one) / SC22 (Subcommittee 22) / WG21 (Working Grouping 21)
Beginning appeared 1985; 37 years ago  (1985)
Stable release

C++xx (ISO/IEC 14882:2020) / 15 December 2020; fifteen months ago  (2020-12-15)

Preview release

C++23 / 17 March 2022; 20 days ago  (2022-03-17)

Typing discipline Static, nominative, partially inferred
Bone Cross-platform
Filename extensions .C, .cc, .cpp, .cxx, .c++, .h, .H, .hh, .hpp, .hxx, .h++
Website isocpp.org
Major implementations
GCC, LLVM Clang, Microsoft Visual C++, Embarcadero C++Builder, Intel C++ Compiler, IBM XL C++, EDG
Influenced by
Ada, ALGOL 68,[ane] BCPL,[2] C, CLU,[1] ML, Mesa,[1] Modula-two,[ane] Simula, Smalltalk[1]
Influenced
Ada 95, C#,[3] C99, Chapel,[4] Clojure,[v] D, Java,[6] JS++,[vii] Lua, Nim,[eight] Objective-C++, Perl, PHP, Python,[9] Rust, Seed7
  • C++ Programming at Wikibooks

C++ () is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C programming language, or "C with Classes". The linguistic communication has expanded significantly over time, and modern C++ at present has object-oriented, generic, and functional features in add-on to facilities for low-level memory manipulation. It is well-nigh always implemented as a compiled language, and many vendors provide C++ compilers, including the Costless Software Foundation, LLVM, Microsoft, Intel, Oracle, and IBM, so it is bachelor on many platforms.[10]

C++ was designed with an orientation toward systems programming and embedded, resource-constrained software and large systems, with performance, efficiency, and flexibility of use as its design highlights.[11] C++ has also been found useful in many other contexts, with key strengths being software infrastructure and resources-constrained applications,[11] including desktop applications, video games, servers (eastward.chiliad. e-commerce, web search, or databases), and performance-critical applications (e.g. phone switches or space probes).[12]

C++ is standardized by the International System for Standardization (ISO), with the latest standard version ratified and published by ISO in December 2020 as ISO/IEC 14882:2020 (informally known as C++twenty).[13] The C++ programming language was initially standardized in 1998 as ISO/IEC 14882:1998, which was then amended by the C++03, C++11, C++14, and C++17 standards. The current C++20 standard supersedes these with new features and an enlarged standard library. Before the initial standardization in 1998, C++ was developed past Danish computer scientist Bjarne Stroustrup at Bell Labs since 1979 as an extension of the C linguistic communication; he wanted an efficient and flexible language like to C that also provided high-level features for program organization.[14] Since 2012, C++ has been on a three-yr release schedule[fifteen] with C++23 as the side by side planned standard.[sixteen]

History [edit]

Bjarne Stroustrup, the creator of C++, in his AT&T New Jersey role c. 2000

In 1979, Bjarne Stroustrup, a Danish computer scientist, began piece of work on " C with Classes ", the predecessor to C++.[17] The motivation for creating a new language originated from Stroustrup's feel in programming for his PhD thesis. Stroustrup found that Simula had features that were very helpful for large software development, but the language was also slow for practical use, while BCPL was fast merely besides depression-level to be suitable for large software development. When Stroustrup started working in AT&T Bong Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing. Remembering his PhD experience, Stroustrup set out to raise the C language with Simula-like features.[18] C was chosen because it was general-purpose, fast, portable and widely used. As well equally C and Simula'south influences, other languages also influenced this new language, 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.[19]

A quiz on C++11 features beingness given in Paris in 2015

In 1982, Stroustrup started to develop a successor to C with Classes, which he named "C++" ( ++ being the increment operator in C) afterward going through several other names. New features were added, including virtual functions, office name and operator overloading, references, constants, blazon-condom free-store memory allocation (new/delete), improved blazon checking, and BCPL style single-line comments with ii forwards slashes ( // ). Furthermore, Stroustrup developed a new, standalone compiler for C++, Cfront.

In 1984, Stroustrup implemented the first stream input/output library. The idea of providing an output operator rather than a named output function was suggested by Doug McIlroy[1] (who had previously suggested Unix pipes).

In 1985, the start edition of The C++ Programming Language was released, which became the definitive reference for the linguistic communication, as in that location was not yet an official standard.[20] The first commercial implementation of C++ was released in October of the aforementioned year.[17]

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

In 1998, C++98 was released, standardizing the language, and a minor update (C++03) was released in 2003.

After C++98, 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 modest C++14 update released in December 2014, various new additions were introduced in C++17.[22] After becoming finalized in February 2020,[23] a draft of the C++20 standard was approved on 4 September 2020 and officially published on 15 Dec 2020.[24] [25]

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

As of 2022[update] C++ ranked quaternary on the TIOBE index, a measure out of the popularity of programming languages, after Python, C and Coffee.[27]

Etymology [edit]

According to Stroustrup, "the name signifies the evolutionary nature of the changes from C".[28] This proper name is credited to Rick Mascitti (mid-1983)[19] and was first used in Dec 1983. When Mascitti was questioned informally in 1992 nearly 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 signal an enhanced calculator plan.

During C++'s development menses, the language had been referred to as "new C" and "C with Classes"[19] [29] before acquiring its final proper noun.

Philosophy [edit]

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

  • It must be driven by bodily issues and its features should be immediately useful in real world programs.
  • Every characteristic should be implementable (with a reasonably obvious way to do so).
  • Programmers should exist complimentary to pick their ain programming style, and that manner should exist fully supported by C++.
  • Assuasive a useful feature is more important than preventing every possible misuse of C++.
  • It should provide facilities for organising programs into divide, well-defined parts, and provide facilities for combining separately adult parts.
  • No implicit violations of the type system (just allow explicit violations; that is, those explicitly requested by the programmer).
  • User-created types need to accept the same support and performance as built-in types.
  • Unused features should not negatively touch created executables (e.g. in lower operation).
  • There should be no linguistic communication beneath C++ (except assembly language).
  • C++ should piece of work alongside other existing programming languages, rather than fostering its own separate and incompatible programming surroundings.
  • If the developer's intent is unknown, allow the programmer to specify it past providing transmission control.

Standardization [edit]

Scene during the C++ Standards Commission meeting in Stockholm in 1996

C++ standards
Year C++ Standard[30] Informal proper noun
1998 ISO/IEC 14882:1998[31] C++98
2003 ISO/IEC 14882:2003[32] C++03
2011 ISO/IEC 14882:2011[33] C++11, C++0x
2014 ISO/IEC 14882:2014[34] C++fourteen, C++1y
2017 ISO/IEC 14882:2017[35] C++17, C++1z
2020 ISO/IEC 14882:2020[13] C++xx, C++2a

C++ is standardized by an ISO working group known every bit JTC1/SC22/WG21. And so far, it has published six revisions of the C++ standard and is currently working on the next revision, C++23.

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 bug identified in C++98.

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

In 2014, C++xiv (as well known as C++1y) was released every bit a minor extension to C++11, featuring mainly bug fixes and small improvements.[37] The Draft International Standard ballot procedures completed in mid-August 2014.[38]

Afterwards 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 canonical and published in December 2017.[39]

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

  • ISO/IEC TR 18015:2006[40] on the use of C++ in embedded systems and on operation implications of C++ language and library features,
  • ISO/IEC TR 19768:2007[41] (also known every bit the C++ Technical Study ane) on library extensions mostly integrated into C++eleven,
  • ISO/IEC TR 29124:2010[42] on special mathematical functions, integrated into C++17
  • ISO/IEC TR 24733:2011[43] on decimal floating-point arithmetic,
  • ISO/IEC TS 18822:2015[44] on the standard filesystem library, integrated into C++17
  • ISO/IEC TS 19570:2015[45] on parallel versions of the standard library algorithms, integrated into C++17
  • ISO/IEC TS 19841:2015[46] on software transactional retention,
  • ISO/IEC TS 19568:2015[47] on a new fix of library extensions, some of which are already integrated into C++17,
  • ISO/IEC TS 19217:2015[48] on the C++ concepts, integrated into C++xx
  • ISO/IEC TS 19571:2016[49] on the library extensions for concurrency, some of which are already integrated into C++xx
  • ISO/IEC TS 19568:2017[fifty] on a new set up of general-purpose library extensions
  • ISO/IEC TS 21425:2017[51] on the library extensions for ranges, integrated into C++xx
  • ISO/IEC TS 22277:2017[52] on coroutines, integrated into C++twenty
  • ISO/IEC TS 19216:2018[53] on the networking library
  • ISO/IEC TS 21544:2018[54] on modules, integrated into C++20
  • ISO/IEC TS 19570:2018[55] on a new set up of library extensions for parallelism
  • ISO/IEC TS 23619:2021[56] on a new extensions for reflection

More technical specifications are in development and pending approving, including new set of concurrency extensions.[57]

Linguistic communication [edit]

The C++ language has ii master components: a direct mapping of hardware features provided primarily by the C subset, and zip-overhead abstractions based on those mappings. Stroustrup describes C++ as "a light-weight abstraction programming linguistic communication [designed] for building and using efficient and elegant abstractions";[11] and "offering both hardware access and brainchild is the basis of C++. Doing it efficiently is what distinguishes information technology from other languages."[58]

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

                                    #include                                    <iostream>                                                int                                    main            ()                                    {                                                            std            ::            cout                                    <<                                    "How-do-you-do, world!            \n            "            ;                                    }

Object storage [edit]

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

Static storage duration objects [edit]

Static storage duration objects are created before primary() is entered (come across 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 permit implementations some liberty in how to organize their implementation. More than formally, objects of this type have a lifespan that "shall last for the duration of the program".[62]

Static storage duration objects are initialized in two phases. Outset, "static initialization" is performed, and simply after all static initialization is performed, "dynamic initialization" is performed. In static initialization, all objects are first initialized with zeros; subsequently that, all objects that have a constant initialization phase are initialized with the constant expression (i.east. variables initialized with a literal or constexpr). Though information technology is not specified in the standard, the static initialization stage can be completed at compile fourth dimension and saved in the data partition of the executable. Dynamic initialization involves all object initialization done via a constructor or function phone call (unless the function is marked with constexpr, in C++eleven). The dynamic initialization order is divers as the order of declaration within the compilation unit (i.eastward. the aforementioned file). No guarantees are provided about the order of initialization between compilation units.

Thread storage elapsing objects [edit]

Variables of this blazon are very similar to static storage duration objects. The main divergence is the creation time is merely prior to thread creation and destruction is washed subsequently the thread has been joined.[63]

Automated storage elapsing objects [edit]

The near common variable types in C++ are local variables inside a office or block, and temporary variables.[64] 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 proclamation (see below for details) and destroyed in the reverse order of creation when the scope is left. This is implemented past allotment on the stack.

Local variables are created as the point of execution passes the declaration betoken. If the variable has a constructor or initializer this is used to define the initial country 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 terminate of the object lifetime, assuasive a discipline for automated resource management termed RAII, which is widely used in C++.

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

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

Dynamic storage elapsing objects [edit]

These objects have a dynamic lifespan and can be created directly with a telephone call to new and destroyed explicitly with a call to delete .[65] C++ likewise supports malloc and costless, from C, only these are non compatible with new and delete . Use of new returns an accost to the allocated retentiveness. The C++ Cadre Guidelines advise confronting using new directly for creating dynamic objects in favor of smart pointers through make_unique < T > for single ownership and make_shared < T > for reference-counted multiple ownership,[66] which were introduced in C++11.

Templates [edit]

C++ templates enable generic programming. C++ supports function, class, allonym, and variable templates. Templates may exist parameterized by types, compile-fourth dimension constants, and other templates. Templates are implemented by instantiation at compile-time. To instantiate a template, compilers substitute specific arguments for a template'due south parameters to generate a concrete role 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 lawmaking optimization, only this power implies a price. Template use may increase code size, considering each template instantiation produces a copy of the template lawmaking: ane for each gear up of template arguments, yet, this is the same or smaller amount of code that would be generated if the lawmaking was written by hand.[67] This is in contrast to run-time generics seen in other languages (e.grand., Java) where at compile-time the type is erased and a single template trunk is preserved.

Templates are dissimilar 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 blazon system of their companion linguistic communication, as well as all compile-time type definitions, and tin can perform loftier-level operations including programmatic period command based on evaluation of strictly type-checked parameters. Macros are capable of provisional control over compilation based on predetermined criteria, only 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 menses 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 add-on, templates are a compile-fourth dimension mechanism in C++ that is Turing-complete, meaning that any ciphering expressible by a computer plan can be computed, in some form, past a template metaprogram prior to runtime.

In summary, a template is a compile-fourth dimension parameterized office or class written without knowledge of the specific arguments used to instantiate it. Afterward instantiation, the resulting code is equivalent to code written specifically for the passed arguments. In this manner, templates provide a manner 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 [edit]

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

Encapsulation [edit]

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

The object-oriented principle ensures the encapsulation of all and only the functions that admission the internal representation of a type. C++ supports this principle via member functions and friend functions, but information technology does not enforce information technology. 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 by and large considered good practise to make all data individual or protected, and to make public but those functions that are part of a minimal interface for users of the grade. This can hide the details of data implementation, allowing the designer to afterward fundamentally change the implementation without changing the interface in any way.[68] [69]

Inheritance [edit]

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

Multiple inheritance is a C++ feature assuasive a class to be derived from more than than one base form; this allows for more elaborate inheritance relationships. For case, a "Flying Cat" grade tin can inherit from both "True cat" and "Flying Mammal". Some other languages, such as C# or Coffee, accomplish something similar (although more limited) by assuasive inheritance of multiple interfaces while restricting the number of base classes to one (interfaces, unlike classes, provide simply declarations of fellow member functions, no implementation or member data). An interface every bit in C# and Coffee can be defined in C++ as a class containing only pure virtual functions, often known as an abstruse base class or "ABC". The member functions of such an abstract base class are commonly explicitly divers in the derived class, not inherited implicitly. C++ virtual inheritance exhibits an ambiguity resolution feature called say-so.

Operators and operator overloading [edit]

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

Overloadable operators are besides an essential office of many advanced C++ programming techniques, such equally smart pointers. Overloading an operator does not modify the precedence of calculations involving the operator, nor does it change the number of operands that the operator uses (any operand may even so be ignored by the operator, though information technology volition be evaluated prior to execution). Overloaded "&&" and "||" operators lose their brusk-circuit evaluation property.

Polymorphism [edit]

Polymorphism enables 1 mutual interface for many implementations, and for objects to human activity differently under unlike circumstances.

C++ supports several kinds of static (resolved at compile-time) and dynamic (resolved at run-time) polymorphisms, supported by the linguistic communication features described above. Compile-fourth dimension polymorphism does not let for sure run-time decisions, while runtime polymorphism typically incurs a functioning penalty.

Static polymorphism [edit]

Function overloading allows programs to declare multiple functions having the aforementioned name but with unlike arguments (i.east. ad hoc polymorphism). The functions are distinguished by the number or types of their formal parameters. Thus, the same function name tin 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 differing return types would result in a compile-time error message.

When declaring a function, a programmer can specify for 1 or more parameters a default value. Doing then allows the parameters with defaults to optionally be omitted when the role 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 lodge, with whatever unmatched parameters at the end of the parameter list being assigned their default arguments. In many cases, specifying default arguments in a single function announcement is preferable to providing overloaded part definitions with different numbers of parameters.

Templates in C++ provide a sophisticated mechanism for writing generic, polymorphic lawmaking (i.e. parametric polymorphism). In particular, through the curiously recurring template design, it'due south possible to implement a form of static polymorphism that closely mimics the syntax for overriding virtual functions. Because C++ templates are type-enlightened and Turing-consummate, they can also exist used to permit the compiler resolve recursive conditionals and generate substantial programs through template metaprogramming. Reverse to some opinion, template lawmaking will non generate a majority code after compilation with the proper compiler settings.[67]

Dynamic polymorphism [edit]

Inheritance [edit]

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

C++ also provides the dynamic_cast operator, which allows code to safely attempt conversion of an object, via a base of operations reference/pointer, to a more derived type: downcasting. The attempt is necessary equally 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 blazon information (RTTI), metadata in the program that enables differentiating types and their relationships. If a dynamic_cast to a arrow fails, the consequence is the nullptr constant, whereas if the destination is a reference (which cannot exist nada), the cast throws an exception. Objects known to exist of a certain derived type tin 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 developer is very confident the cast is, and will ever be, valid.

Virtual member functions [edit]

Ordinarily, when a role in a derived class overrides a function in a base class, the part to phone call is determined by the blazon 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, information technology may not be possible to decide the type of the object and therefore the correct part to call, given simply a base grade pointer; the conclusion is therefore put off until runtime. This is chosen dynamic dispatch. Virtual member functions or methods [70] allow the most specific implementation of the part to exist called, according to the actual run-fourth dimension blazon of the object. In C++ implementations, this is ordinarily done using virtual part tables. If the object type is known, this may be bypassed by prepending a fully qualified grade name before the office telephone call, but in general calls to virtual functions are resolved at run time.

In add-on to standard fellow member functions, operator overloads and destructors can exist virtual. An inexact rule based on applied feel states that if whatsoever function in the course 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. Yet a state of affairs may ascend where a copy of an object needs to exist created when a pointer to a derived object is passed as a pointer to a base object. In such a example, a common solution is to create a clone () (or similar) virtual office that creates and returns a re-create of the derived grade when chosen.

A member function can too exist made "pure virtual" by appending it with = 0 after the endmost parenthesis and before the semicolon. A class containing a pure virtual role is called an abstruse class. Objects cannot be created from an abstract class; they can merely exist derived from. Any derived class inherits the virtual function every bit pure and must provide a non-pure definition of information technology (and all other pure virtual functions) before objects of the derived grade tin can be created. A plan that attempts to create an object of a class with a pure virtual fellow member function or inherited pure virtual member role is ill-formed.

Lambda expressions [edit]

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

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

Since C++20, you can write template parameters on a lambda without the keyword template : 

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

If the lambda takes no parameters, and no return type or other specifiers are used, the () can exist omitted, that is, 

                        [            capture            ]                                    {                                    function_body                                    }

The return blazon of a lambda expression can be automatically inferred, if possible, east.thou.: 

                        [](            int                                    10            ,                                    int                                    y            )                                    {                                    return                                    x                                    +                                    y            ;                                    }                                    // inferred            [](            int                                    x            ,                                    int                                    y            )                                    ->                                    int                                    {                                    render                                    x                                    +                                    y            ;                                    }                                    // explicit

The [ capture ] listing supports the definition of closures. Such lambda expressions are defined in the standard as syntactic saccharide for an unnamed office object.

Exception handling [edit]

Exception handling is used to communicate the being of a runtime problem or error from where it was detected to where the result can be handled.[71] Information technology permits this to be done in a compatible style and separately from the chief code, while detecting all errors.[72] Should an mistake occur, an exception is thrown (raised), which is and so caught past the nearest suitable exception handler. The exception causes the current scope to be exited, and also each outer telescopic (propagation) until a suitable handler is establish, calling in turn the destructors of whatever objects in these exited scopes.[73] At the same time, an exception is presented as an object carrying the data about the detected problem.[74]

Some C++ style guides, such as Google's,[75] LLVM's,[76] and Qt'due south[77] forbid the usage of exceptions.

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 case below.[78] 

                                    #include                                    <iostream>                                    #include                                    <vector>                                    #include                                    <stdexcept>                                                int                                    chief            ()                                    {                                                            try                                    {                                                            std            ::            vector            <            int            >                                    vec            {            3            ,                                    four            ,                                    iii            ,                                    1            };                                                            int                                    i            {            vec            .            at            (            4            )};                                    // Throws an exception, std::out_of_range (indexing for vec is from 0-3 not one-4)                                                }                                                            // An exception handler, catches std::out_of_range, which is thrown past vec.at(iv)                                                catch                                    (            std            ::            out_of_range                                    &            e            )                                    {                                                            std            ::            cerr                                    <<                                    "Accessing a non-existent chemical element: "                                    <<                                    eastward            .            what            ()                                    <<                                    '\n'            ;                                                            }                                                            // To grab whatsoever other standard library exceptions (they derive from std::exception)                                                catch                                    (            std            ::            exception                                    &            east            )                                    {                                                            std            ::            cerr                                    <<                                    "Exception thrown: "                                    <<                                    eastward            .            what            ()                                    <<                                    '\n'            ;                                                            }                                                            // Catch whatever unrecognised exceptions (i.e. those which don't derive from std::exception)                                                take hold of                                    (...)                                    {                                                            std            ::            cerr                                    <<                                    "Some fatal mistake            \due north            "            ;                                                            }                                    }

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

Unlike signal treatment, in which the handling function is called from the point of failure, exception handling exits the current scope earlier the catch block is entered, which may exist located in the electric current part or whatsoever of the previous part calls currently on the stack.

Enumerated types [edit]

C++ has enumeration types that are directly inherited from C's and work mostly like these, except that an enumeration is a real blazon in C++, giving added compile-fourth dimension checking. Too (as with structs), the C++ enum keyword is automatically combined with a typedef, and so that instead of naming the blazon enum name, but name it name. This can be fake in C using a typedef: typedef enum { Value1 , Value2 } name ;

C++eleven also provides a second kind of enumeration, called a scoped enumeration. These are type-safe: the enumerators are not implicitly converted to an integer type. Amid other things, this allows I/O streaming to be divers for the enumeration type. Some other feature of scoped enumerations is that the enumerators practice non leak, so usage requires prefixing with the proper noun of the enumeration (east.k., Color::Red for the beginning enumerator in the instance below), unless a using enum declaration (introduced in C++20) has been used to bring the enumerators into the current scope. A scoped enumeration is specified past the phrase enum form (or enum struct). For case: 

                            enum              form                                          Color                                          {              Red              ,                                          Green              ,                                          Blue              };

The underlying type of an enumeration is an implementation-defined integral type that is large enough to concur all enumerated values; it does not take to be the smallest possible type. The underlying type can be specified directly, which allows "forrad declarations" of enumerations: 

                            enum              form                                          Color                                          :                                          long                                          {              Red              ,                                          Green              ,                                          Blue              };                                          // must fit in size and memory layout the type 'long'              enum              class                                          Shapes                                          :                                          char              ;                                          // forward declaration. If later in that location are values defined that don't fit in 'char' it is an error.

Standard library [edit]

The draft "Working Paper" standard that became approved as C++98; half of its size was devoted to the C++ Standard Library.

The C++ standard consists of two parts: the core linguistic communication and the standard library. C++ programmers look the latter on every major implementation of C++; it includes aggregate types (vectors, lists, maps, sets, queues, stacks, arrays, tuples), algorithms (notice, 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 retention management, regular expression support, multi-threading library, atomics back up (assuasive a variable to be read or written to by at nigh one thread at a fourth dimension without any external synchronisation), time utilities (measurement, getting electric 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 information technology comply with the C++ type system).

A big role 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-similar 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 (due east.m., STL sort) that perform even better than, for example, the C standard library qsort, thank you to C++ features like using inlining and compile-time bounden instead of function pointers. The standard does not refer to it as "STL", every bit it is just a part of the standard library, but the term is nonetheless widely used to distinguish it from the rest of the standard library (input/output streams, internationalization, diagnostics, the C library subset, etc.).[80]

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

C++ Core Guidelines [edit]

The C++ Cadre Guidelines[81] are an initiative led past Bjarne Stroustrup, the inventor of C++, and Herb Sutter, the convener and chair of the C++ ISO Working Grouping, to assistance programmers write 'Modern C++' by using best practices for the language standards C++11 and newer, and to help developers of compilers and static checking tools to create rules for catching bad programming practices.

The chief aim is to efficiently and consistently write type and resource safe C++.

The Cadre Guidelines were appear[82] in the opening keynote at CPPCon 2015.

The Guidelines are accompanied by the Guideline Back up Library (GSL),[83] a header only library of types and functions to implement the Cadre Guidelines and static checker tools for enforcing Guideline rules.[84]

Compatibility [edit]

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 lawmaking produced by dissimilar compilers is expected to be incompatible. In that location were, all the same, attempts to standardize compilers for particular machines or operating systems (for case C++ ABI),[85] though they seem to be largely abandoned now.

With C [edit]

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

Some incompatibilities accept been removed by the 1999 revision of the C standard (C99), which at present supports C++ features such every bit line comments ( // ) and declarations mixed with lawmaking. 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.[87] 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).[88] [89] [90] Nonetheless, 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 office may not rely on features depending on name mangling (i.e., function overloading).

Criticism [edit]

Despite its widespread adoption, some notable programmers have criticized the C++ language, including Linus Torvalds,[91] Richard Stallman,[92] Joshua Bloch, Ken Thompson[93] [94] [95] and Donald Knuth.[96] [97]

Ane 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 practise necessitates restricting lawmaking to a subset of C++, thus eschewing the readability benefits of common fashion and idioms. Every bit expressed by Joshua Bloch:

I call up C++ was pushed well across its complication threshold, and yet in that location are a lot of people programming information technology. But what you do is you forcefulness people to subset it. Then 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 non using operator overloading." At that place are just a bunch of features that you're not going to utilise because the complexity of the resulting code is too high. And I don't call up it'southward good when you have to first doing that. You lose this programmer portability where everyone can read everyone else's lawmaking, which I think is such a skillful thing.

Donald Knuth (1993, commenting on pre-standardized C++), who said of Edsger Dijkstra that "to call back of programming in C++" "would brand him physically sick":[96] [97]

The trouble that I have with them today is that... C++ is too complicated. At the moment, it'southward 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 ii competing ideas as to how they should solve some trouble, they said "OK, we'll practise them both". So the language is too bizarre for my gustatory modality.

Ken Thompson, who was a colleague of Stroustrup at Bong Labs, gives his assessment:[94] [95]

It certainly has its good points. But more often than not I call back it's a bad language. It does a lot of things half well and it'southward only a garbage heap of ideas that are mutually sectional. Everybody I know, whether it'southward personal or corporate, selects a subset and these subsets are unlike. And then it's non a good language to transport an algorithm—to say, "I wrote it; hither, accept it." It's mode as well big, mode too complex. And it's obviously built by a committee. Stroustrup campaigned for years and years and years, fashion 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 characteristic in that linguistic communication 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.

Yet Brian Kernighan, likewise a colleague at Bong Labs, disputes this assessment:[98]

C++ has been enormously influential. ... Lots of people say C++ is as well big and likewise complicated etc. etc. but in fact it is a very powerful language and pretty much everything that is in at that place is there for a really audio reason: it is not somebody doing random invention, it is actually people trying to solve real world problems. At present a lot of the programs that we take for granted today, that nosotros only use, are C++ programs.

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

Other complaints may include a lack of reflection or garbage collection, long compilation times, perceived feature creep,[100] and verbose mistake letters, particularly from template metaprogramming.[101]

Come across also [edit]

  • Comparison of programming languages
  • List of C++ compilers
  • Outline of C++
  • Category:C++ libraries

References [edit]

  1. ^ a b c d eastward f Stroustrup, Bjarne (1996). "A history of C++: 1979-1991". History of programming languages---II. ACM. pp. 699–769. doi:ten.1145/234286.1057836.
  2. ^ Stroustrup, Bjarne (16 December 2021). "C++20: Reaching for the Aims of C++ - Bjarne Stroustrup - CppCon 2021". CppCon.
  3. ^ Naugler, David (May 2007). "C# two.0 for C++ and Coffee developer: 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.
  4. ^ "Chapel spec (Acknowledgements)" (PDF). Cray Inc. 1 October 2015. Archived (PDF) from the original on 24 June 2018. Retrieved xiv January 2016.
  5. ^ "Rich Hickey Q&A past Michael Fogus". Archived from the original on eleven Jan 2017. Retrieved 11 Jan 2017.
  6. ^ Harry. H. Chaudhary (28 July 2014). "Great The Java Programming Interview :: 2000+ Java Interview Que/Ans". Archived from the original on 27 May 2021. Retrieved 29 May 2016.
  7. ^ Roger Poon (1 May 2017). "Scaling JS++: Abstraction, Performance, and Readability". Archived from the original on xi May 2020. Retrieved 21 April 2020.
  8. ^ "FAQ Nim Programming Linguistic communication". Archived from the original on eleven July 2017. Retrieved 21 Apr 2020.
  9. ^ "9. Classes — Python iii.6.four documentation". docs.python.org. Archived from the original on 23 Oct 2012. Retrieved 9 January 2018.
  10. ^ Stroustrup, Bjarne (1997). "1". The C++ Programming Language (Third ed.). ISBN0-201-88954-4. OCLC 59193992.
  11. ^ a b c Stroustrup, B. (6 May 2014). "Lecture:The essence of C++. University of Edinburgh". YouTube. Archived from the original on 28 April 2015. Retrieved 12 June 2015.
  12. ^ Stroustrup, Bjarne (17 February 2014). "C++ Applications". stroustrup.com. Archived from the original on 4 April 2021. Retrieved 5 May 2014.
  13. ^ a b "ISO/IEC 14882:2020". International Organization for Standardization. Archived from the original on 16 Dec 2020. Retrieved 16 December 2020.
  14. ^ "Bjarne Stroustrup's Homepage". www.stroustrup.com. Archived from the original on 14 May 2019. Retrieved 15 May 2013.
  15. ^ "C++ IS schedule" (PDF). Archived (PDF) from the original on 10 Baronial 2020. Retrieved 9 Baronial 2020.
  16. ^ "C++; Where it'southward heading". Archived from the original on three December 2018. Retrieved 3 December 2018.
  17. ^ a b Stroustrup, Bjarne (seven March 2010). "Bjarne Stroustrup'due south FAQ: When was C++ invented?". stroustrup.com. Archived from the original on 6 Feb 2016. Retrieved 16 September 2010.
  18. ^ a b Stroustrup, Bjarne. "Evolving a language in and for the real world: C++ 1991-2006" (PDF). Archived (PDF) from the original on 20 November 2007. Retrieved 14 August 2013.
  19. ^ a b c Stroustrup, Bjarne. "A History of C ++ : 1979− 1991" (PDF). Archived (PDF) from the original on 2 February 2019. Retrieved 18 July 2013.
  20. ^ Stroustrup, Bjarne. "The C++ Programming Language" (First ed.). Archived from the original on 9 August 2012. Retrieved xvi September 2010.
  21. ^ Stroustrup, Bjarne. "The C++ Programming Language" (Second ed.). Archived from the original on 9 August 2012. Retrieved xvi September 2010.
  22. ^ Sutter, Herb (30 June 2016). "Trip report: Summer ISO C++ standards meeting (Oulu)". herbsutter.com. Archived from the original on viii October 2016. the next standard later on C++17 volition be C++20
  23. ^ Dusíková, Hana (six Nov 2019). "N4817: 2020 Prague Meeting Invitation and Information" (PDF). Archived (PDF) from the original on 29 December 2019. Retrieved thirteen February 2020.
  24. ^ "Current Status". isocpp.org. Archived from the original on viii September 2020. Retrieved 7 September 2020.
  25. ^ "C++20 Canonical -- Herb Sutter". isocpp.org. Archived from the original on xi September 2020. Retrieved viii September 2020.
  26. ^ "Informatics Pioneer Bjarne Stroustrup to Receive the 2018 Charles Stark Draper Prize for Engineering science" (Printing release). National Academy of Engineering. 3 January 2018. Archived from the original on 3 January 2018. Retrieved 14 December 2021.
  27. ^ TIOBE (Jan 2022). "TIOBE Index for January 2021". TIOBE.com. TIOBE Company. Archived from the original on 25 February 2018. Retrieved 2 February 2022.
  28. ^ "Bjarne Stroustrup's FAQ – Where did the name "C++" come from?". Archived from the original on 6 Feb 2016. Retrieved 16 Jan 2008.
  29. ^ "C For C++ Programmers". Northeastern University. Archived from the original on 17 November 2010. Retrieved 7 September 2015.
  30. ^ "History of C++". en.cppreference.com. Archived from the original on two February 2022. Retrieved sixteen March 2022.
  31. ^ "ISO/IEC 14882:1998". International Organization for Standardization. Archived from the original on 15 Jan 2017. Retrieved 23 November 2018.
  32. ^ "ISO/IEC 14882:2003". International Organization for Standardization. Archived from the original on 13 August 2021. Retrieved 23 November 2018.
  33. ^ a b "ISO/IEC 14882:2011". International Organization for Standardization. Archived from the original on 27 May 2016. Retrieved 23 November 2018.
  34. ^ "ISO/IEC 14882:2014". International System for Standardization. Archived from the original on 29 April 2016. Retrieved 23 November 2018.
  35. ^ "ISO/IEC 14882:2017". International Organization for Standardization. Archived from the original on 17 May 2013. Retrieved 2 December 2017.
  36. ^ "Nosotros have an international standard: C++0x is unanimously approved". Sutter's Manufacturing plant. 12 August 2011. Archived from the original on 28 June 2018. Retrieved 23 Nov 2018.
  37. ^ "The Future of C++". Archived from the original on 23 October 2018. Retrieved 23 Nov 2018 – via channel9.msdn.com.
  38. ^ "We have C++14! : Standard C++". isocpp.org. Archived from the original on 19 August 2014. Retrieved 19 August 2014.
  39. ^ Sutter, Herb (15 July 2017). "Trip report: Summer ISO C++ standards meeting (Toronto)". Archived from the original on six August 2017. Retrieved 4 Baronial 2017.
  40. ^ "ISO/IEC TR 18015:2006". International System for Standardization. Archived from the original on xv January 2019. Retrieved fifteen February 2019.
  41. ^ "ISO/IEC TR 19768:2007". International Organization for Standardization. Archived from the original on four March 2016. Retrieved 15 February 2019.
  42. ^ "ISO/IEC TR 29124:2010". International System for Standardization. Archived from the original on 12 Jan 2019. Retrieved 15 February 2019.
  43. ^ "ISO/IEC TR 24733:2011". International Organization for Standardization. Archived from the original on xv January 2019. Retrieved 15 Feb 2019.
  44. ^ "ISO/IEC TS 18822:2015". International Arrangement for Standardization. Archived from the original on fifteen January 2019. Retrieved 15 February 2019.
  45. ^ "ISO/IEC TS 19570:2015". International Organisation for Standardization. Archived from the original on fifteen January 2019. Retrieved 15 February 2019.
  46. ^ "ISO/IEC TS 19841:2015". International Organisation for Standardization. Archived from the original on 15 Jan 2019. Retrieved fifteen February 2019.
  47. ^ "ISO/IEC TS 19568:2015". International Organization for Standardization. Archived from the original on xv January 2019. Retrieved xv February 2019.
  48. ^ "ISO/IEC TS 19217:2015". International Organization for Standardization. Archived from the original on 15 January 2019. Retrieved 15 February 2019.
  49. ^ "ISO/IEC TS 19571:2016". International Arrangement for Standardization. Archived from the original on fifteen Jan 2019. Retrieved 15 Feb 2019.
  50. ^ "ISO/IEC TS 19568:2017". International Organization for Standardization. Archived from the original on 15 January 2019. Retrieved xv February 2019.
  51. ^ "ISO/IEC TS 21425:2017". International Arrangement for Standardization. Archived from the original on 15 Jan 2019. Retrieved 15 February 2019.
  52. ^ "ISO/IEC TS 22277:2017". International Organization for Standardization. Archived from the original on 15 Jan 2019. Retrieved 15 Feb 2019.
  53. ^ "ISO/IEC TS 19216:2018". International Arrangement for Standardization. Archived from the original on xv Jan 2019. Retrieved fifteen Feb 2019.
  54. ^ "ISO/IEC TS 21544:2018". International Organisation for Standardization. Archived from the original on 15 January 2019. Retrieved 15 February 2019.
  55. ^ "ISO/IEC TS 19570:2018". International Organisation for Standardization. Archived from the original on 15 January 2019. Retrieved xv Feb 2019.
  56. ^ "ISO/IEC TS 23619:2021". International System for Standardization. Archived from the original on 15 December 2018. Retrieved 11 October 2021.
  57. ^ Come across a list at "Experimental C++ Features". cppreference.com. Archived from the original on 23 Nov 2018. Retrieved 15 February 2019.
  58. ^ B. Stroustrup (interviewed by Sergio De Simone) (30 April 2015). "Stroustrup: Thoughts on C++17 - An Interview". Archived from the original on eight July 2015. Retrieved 8 July 2015.
  59. ^ Stroustrup, Bjarne (2000). The C++ Programming Language (Special ed.). Addison-Wesley. p. 46. ISBN0-201-70073-5.
  60. ^ Stroustrup, Bjarne. "Open problems for The C++ Programming Language (tertiary Edition)". Archived from the original on five May 2014. Retrieved 5 May 2014. This code is copied directly from Bjarne Stroustrup'southward errata page (p. 633). He addresses the use of '\due north' rather than std::endl. Too see Can I write "void main()"? for an caption of the implicit return 0; in the main function. This implicit render is not available in other functions. CS1 maint: postscript (link)
  61. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) Archived ii Oct 2018 at the Wayback Auto §3.7 Storage elapsing [basic.stc]
  62. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) Archived ii October 2018 at the Wayback Car §3.7.one Static Storage elapsing [basic.stc.static]
  63. ^ ISO/IEC. Programming Languages – C++11 Draft (n3797) Archived 2 October 2018 at the Wayback Machine §3.7.two Thread Storage elapsing [bones.stc.thread]
  64. ^ ISO/IEC. Programming Languages – C++eleven Typhoon (n3797) Archived 2 October 2018 at the Wayback Automobile §3.7.three Automatic Storage duration [basic.stc.auto]
  65. ^ ISO/IEC. Programming Languages – C++eleven Typhoon (n3797) Archived 2 Oct 2018 at the Wayback Machine §3.7.four Dynamic Storage duration [basic.stc.dynamic]
  66. ^ "C++ Cadre Guidelines". isocpp.github.io. Archived from the original on viii February 2020. Retrieved 9 February 2020.
  67. ^ a b "Nobody Understands C++: Part 5: Template Lawmaking Bloat". articles.emptycrate.com/: EmptyCrate Software. Travel. Stuff. 6 May 2008. Archived from the original on 25 April 2016. Retrieved 8 March 2010. On occasion you will read or hear someone talking about C++ templates causing lawmaking bloat. I was thinking about it the other twenty-four hour period and thought to myself, "self, if the lawmaking does exactly the aforementioned thing then the compiled code cannot really be any bigger, can it?" [...] And what about compiled code size? Each were compiled with the control grand++ <filename>.cpp -O3. Non-template version: 8140 bytes, template version: 8028 bytes!
  68. ^ Sutter, Herb; Alexandrescu, Andrei (2004). C++ Coding Standards: 101 Rules, Guidelines, and Best Practices. Addison-Wesley.
  69. ^ Henricson, Mats; Nyquist, Erik (1997). Industrial Forcefulness C++. Prentice Hall. ISBN0-13-120965-five.
  70. ^ Stroustrup, Bjarne (2000). The C++ Programming Language (Special ed.). Addison-Wesley. p. 310. ISBN0-201-70073-5. A virtual member function is sometimes called a method.
  71. ^ Mycroft, Alan (2013). "C and C++ Exceptions | Templates" (PDF). Cambridge Reckoner Laboratory - Course Materials 2013-fourteen. Archived (PDF) from the original on 13 May 2016. Retrieved xxx Baronial 2016.
  72. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. p. 345. ISBN9780321563842.
  73. ^ Stroustrup, Bjarne (2013). The C++ Programming Linguistic communication. Addison Wesley. pp. 363–365. ISBN9780321563842.
  74. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. pp. 345, 363. ISBN9780321563842.
  75. ^ "Google C++ Style Guide". Archived from the original on 16 March 2019. Retrieved 25 June 2019.
  76. ^ "LLVM Coding Standards". LLVM ix documentation. Archived from the original on 27 June 2019. Retrieved 25 June 2019.
  77. ^ "Coding Conventions". Qt Wiki. Archived from the original on 26 June 2019. Retrieved 26 June 2019.
  78. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. pp. 344, 370. ISBN9780321563842.
  79. ^ Stroustrup, Bjarne (2013). The C++ Programming Language. Addison Wesley. p. 349. ISBN9780321563842.
  80. ^ Graziano Lo Russo (2008). "An Interview with A. Stepanov". stlport.org. Archived from the original on four March 2009. Retrieved 8 October 2015.
  81. ^ "C++ Cadre Guidelines". isocpp.github.io. Archived from the original on 16 February 2020. Retrieved 9 February 2020.
  82. ^ "Bjarne Stroustrup announces C++ Core Guidelines : Standard C++". isocpp.org. Archived from the original on 11 May 2020. Retrieved 31 March 2020.
  83. ^ "microsoft/GSL". 18 July 2021. Archived from the original on 18 July 2021. Retrieved xviii July 2021 – via GitHub.
  84. ^ "Using the C++ Core Guidelines checkers". docs.microsoft.com. Archived from the original on thirteen August 2021. Retrieved 31 March 2020.
  85. ^ "C++ ABI Summary". 20 March 2001. Archived from the original on x July 2018. Retrieved thirty May 2006.
  86. ^ "Bjarne Stroustrup's FAQ – Is C a subset of C++?". Archived from the original on 6 February 2016. Retrieved 5 May 2014.
  87. ^ "C9X – The New C Standard". Archived from the original on 21 June 2018. Retrieved 27 Dec 2008.
  88. ^ "C++0x Back up in GCC". Archived from the original on 21 July 2010. Retrieved 12 October 2010.
  89. ^ "C++0x Core Linguistic communication Features In VC10: The Table". Archived from the original on 21 August 2010. Retrieved 12 Oct 2010.
  90. ^ "Clang - C++98, C++xi, and C++fourteen Status". Clang.llvm.org. 12 May 2013. Archived from the original on four July 2013. Retrieved 10 June 2013.
  91. ^ "Re: [RFC] Catechumen builin-mailinfo.c to utilise The Improve String Library" (Mailing list). 6 September 2007. Archived from the original on eight March 2021. Retrieved 31 March 2015.
  92. ^ "Re: Efforts to attract more users?" (Mailing listing). 12 July 2010. Archived from the original on 21 March 2015. Retrieved 31 March 2015.
  93. ^ Andrew Binstock (18 May 2011). "Dr. Dobb'due south: Interview with Ken Thompson". Archived from the original on thirteen March 2014. Retrieved 7 February 2014.
  94. ^ a b Peter Seibel (16 September 2009). Coders at Work: Reflections on the Craft of Programming. Apress. pp. 475–476. ISBN978-i-4302-1948-4. Archived from the original on ane December 2019. Retrieved 9 November 2017.
  95. ^ a b "C++ in Coders at Work". 16 Oct 2009. Archived from the original on x November 2017. Retrieved ix Nov 2017.
  96. ^ a b "An Interview with Donald Knuth". Dr. Dobb's. Archived from the original on 8 March 2021. Retrieved 18 July 2021.
  97. ^ a b "Archived copy". Archived from the original on xx November 2017. Retrieved 10 November 2017. {{cite web}}: CS1 maint: archived re-create every bit title (link)
  98. ^ Brian Kernighan (18 July 2018). Brian Kernighan Q&A - Computerphile. Archived from the original on 25 September 2021.
  99. ^ "Stroustrup: FAQ". www.stroustrup.com. Archived from the original on half-dozen February 2016. Retrieved 7 June 2013.
  100. ^ Pike, Rob (2012). "Less is exponentially more". Archived from the original on vii July 2017. Retrieved 23 Nov 2018.
  101. ^ Kreinin, Yossi (xiii Oct 2009). "Defective C++". Archived from the original on v Feb 2016. Retrieved 3 February 2016.

Further reading [edit]

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

External links [edit]

  • 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 organisation.

tardyainght91.blogspot.com

Source: https://en.wikipedia.org/wiki/C%2B%2B

You may like these posts

Post a Comment for "how to tell what type an object is from its base class c#"