history of c language

7/30/2019 History of C Language

1/16

History of C Language

The C programming language was designed by Dennies Ritchie in the early 1970s at

Bell Laboratories. It was first used system implementation language for the nascent

Unix operating system. The main reason to devised C was to overcome the limitationsof B. It was Derived from the type-less language BCPL ((Basic Combined

Programming Language). C was was the evolution of B and BCPL by incorporating

type checking. It was originally intended for use in writing compilers for other

languages.

History of C++

C++ was devised by Bjarne Stroustrup in 1983 at Bell Laboratories. It is an extension

of C by adding some enhancements to C language. Bjarne combined the simula's(a

language designed for making simulations, created by Ole-Johan Dahl and KristenNygaard) features of object oriented and the efficiency of C. The new features added

to language are templates, namespaces, exception handling and use of standary

library.

Difference between c and c++

C++ is an extension of C language. This means that you can not only use the new

features introduced with C++ but can also use the power and efficiency of C language.C and C++ are no more language for writing compilers and other languages, these

general purpose languages are used worldwide in every field.

Here is a list of differences between c and c++.

The main difference between C and C++ is that C++ is object oriented while C is

function or procedure oriented. Object oriented programming paradigm is focused on

writing programs that are more readable and maintainable. It also helps the reuse of

code by packaging a group of similar objects or using the concept of component

programming model. It helps thinking in a logical way by using the concept of real

world concepts of objects, inheritance and polymorphism. It should be noted that thereare also some drawbacks of such features. For example using polymorphism in a

program can slow down the performance of that program.

On the other hand, functional and procedural programming focus primarily on the

actions and events, and the programming model focuses on the logical assertions that

trigger execution of program code.


2/16

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 than35 operators, covering basic arithmetic, bit manipulation, indirection,

comparisons, logical operations and others. Almost all operators can beoverloadedfor 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 using C++ as adomain-specific language.

The overloadable operators are also an essential part of many advanced C++ programming techniques,

such assmart 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 theirshort-circuit evaluationproperty.

[edit]Templates

See also:Template metaprogrammingandGeneric programming

C++ templates enablegeneric programming. C++ supports both function and class templates. Templates

may be parameterized by types, compile-time constants, and other templates. C++ templates are

implemented by instantiationat 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
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2Bhttp://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2Bhttp://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2Bhttp://en.wikipedia.org/wiki/Operator_overloadinghttp://en.wikipedia.org/wiki/Operator_overloadinghttp://en.wikipedia.org/wiki/Operator_overloadinghttp://en.wikipedia.org/wiki/Domain-specific_languagehttp://en.wikipedia.org/wiki/Domain-specific_languagehttp://en.wikipedia.org/wiki/Domain-specific_languagehttp://en.wikipedia.org/wiki/Smart_pointerhttp://en.wikipedia.org/wiki/Smart_pointerhttp://en.wikipedia.org/wiki/Smart_pointerhttp://en.wikipedia.org/wiki/Short-circuit_evaluationhttp://en.wikipedia.org/wiki/Short-circuit_evaluationhttp://en.wikipedia.org/wiki/Short-circuit_evaluationhttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=8http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=8http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=8http://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=8http://en.wikipedia.org/wiki/Short-circuit_evaluationhttp://en.wikipedia.org/wiki/Smart_pointerhttp://en.wikipedia.org/wiki/Domain-specific_languagehttp://en.wikipedia.org/wiki/Operator_overloadinghttp://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B


3/16

phrase "Substitution failure is not an error" (SFINAE). Templates are a powerful tool that can be used

forgeneric programming,template metaprogramming, and code optimization, but this power implies a

cost. Template use may increase code size, since each template instantiation produces a copy of the

template code: one for each set of template arguments. 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 staticpolymorphism(see below) andgeneric programming.

In addition, templates are a compile time mechanism in C++ that isTuring-complete, meaning that anycomputation expressible by a computer program can be computed, in some form, by atemplate

metaprogramprior 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.

[edit]Objects

Main article:C++ classes

C++ introducesobject-oriented programming(OOP) features to C. It offersclasses, which provide the

four features commonly present in OOP (and some non-OOP)

languages:abstraction,encapsulation,inheritance, andpolymorphism. One distinguishing feature of C++

classes compared to classes in other programming languages is support for deterministicdestructors,

which in turn provide support for theResource Acquisition is Initializationconcept.

[edit]Encapsulation

Encapsulationis the hiding of information in order 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 in order to explicitly enforce encapsulation. A publicmember 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 OO principle is that all of the functions (and only the functions) that access the internal representation

of a type should be encapsulated within the type definition. C++ supports this (via member functions and
http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_errorhttp://en.wikipedia.org/wiki/Substitution_failure_is_not_an_errorhttp://en.wikipedia.org/wiki/Substitution_failure_is_not_an_errorhttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Generics_in_Javahttp://en.wikipedia.org/wiki/Generics_in_Javahttp://en.wikipedia.org/wiki/Generics_in_Javahttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=9http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=9http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=9http://en.wikipedia.org/wiki/C%2B%2B_classeshttp://en.wikipedia.org/wiki/C%2B%2B_classeshttp://en.wikipedia.org/wiki/C%2B%2B_classeshttp://en.wikipedia.org/wiki/Object-oriented_programminghttp://en.wikipedia.org/wiki/Object-oriented_programminghttp://en.wikipedia.org/wiki/Object-oriented_programminghttp://en.wikipedia.org/wiki/Class_(computer_science)http://en.wikipedia.org/wiki/Class_(computer_science)http://en.wikipedia.org/wiki/Class_(computer_science)http://en.wikipedia.org/wiki/Abstraction_(computer_science)http://en.wikipedia.org/wiki/Abstraction_(computer_science)http://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Destructor_(computer_science)http://en.wikipedia.org/wiki/Destructor_(computer_science)http://en.wikipedia.org/wiki/Destructor_(computer_science)http://en.wikipedia.org/wiki/Resource_Acquisition_is_Initializationhttp://en.wikipedia.org/wiki/Resource_Acquisition_is_Initializationhttp://en.wikipedia.org/wiki/Resource_Acquisition_is_Initializationhttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=10http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=10http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=10http://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=10http://en.wikipedia.org/wiki/Resource_Acquisition_is_Initializationhttp://en.wikipedia.org/wiki/Destructor_(computer_science)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)http://en.wikipedia.org/wiki/Information_hidinghttp://en.wikipedia.org/wiki/Abstraction_(computer_science)http://en.wikipedia.org/wiki/Class_(computer_science)http://en.wikipedia.org/wiki/Object-oriented_programminghttp://en.wikipedia.org/wiki/C%2B%2B_classeshttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=9http://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Generics_in_Javahttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Generic_programminghttp://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error


4/16

friend functions), but does not enforce it: the programmer can declare parts or all of the representation of

a type to be public, and is allowed to make public entities that are not part of the representation of the

type. Therefore, C++ supports not just OO programming, but other weaker decomposition paradigms,

likemodular programming.

It is generally considered good practice to make all dataprivate 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.[27][28]

[edit]Inheritance

Inheritanceallows one data type to acquire properties of other data types. Inheritance from abase

classmay 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 inheritanceis a C++ feature not found in most other languages, allowing a class to be derived

from more than one base classes; 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

asC#orJava, accomplish something similar (although more limited) by allowing inheritance of

multipleinterfaceswhile 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 classor "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 resolutionfeature calleddominance.

[edit]Polymorphism

See also:Polymorphism in object-oriented programming

Polymorphismenables one common interface for many implementations, and for objects to act differently

under different circumstances.

C++ supports several kinds ofstatic(compile-time) and dynamic(run-time)polymorphisms. Compile-time

polymorphism does not allow for certain run-time decisions, while run-time polymorphism typically incurs

a performance penalty.

[edit]Static polymorphism

Function overloadingallows programs to declare multiple functions having the same name (but with

different arguments). The functions are distinguished by the number or types of theirformal 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.
http://en.wikipedia.org/wiki/Modularity_(programming)http://en.wikipedia.org/wiki/Modularity_(programming)http://en.wikipedia.org/wiki/Modularity_(programming)http://en.wikipedia.org/wiki/Datahttp://en.wikipedia.org/wiki/Datahttp://en.wikipedia.org/wiki/Datahttp://en.wikipedia.org/wiki/C%2B%2B#cite_note-cppcs-26http://en.wikipedia.org/wiki/C%2B%2B#cite_note-cppcs-26http://en.wikipedia.org/wiki/C%2B%2B#cite_note-cppcs-26http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=11http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=11http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=11http://en.wikipedia.org/wiki/Inheritance_(computer_science)http://en.wikipedia.org/wiki/Inheritance_(computer_science)http://en.wikipedia.org/wiki/Base_classhttp://en.wikipedia.org/wiki/Base_classhttp://en.wikipedia.org/wiki/Base_classhttp://en.wikipedia.org/wiki/Base_classhttp://en.wikipedia.org/wiki/Virtual_inheritancehttp://en.wikipedia.org/wiki/Virtual_inheritancehttp://en.wikipedia.org/wiki/Multiple_inheritancehttp://en.wikipedia.org/wiki/Multiple_inheritancehttp://en.wikipedia.org/wiki/C_Sharp_(programming_language)http://en.wikipedia.org/wiki/C_Sharp_(programming_language)http://en.wikipedia.org/wiki/C_Sharp_(programming_language)http://en.wikipedia.org/wiki/Java_(programming_language)http://en.wikipedia.org/wiki/Java_(programming_language)http://en.wikipedia.org/wiki/Java_(programming_language)http://en.wikipedia.org/wiki/Interface_(computer_science)http://en.wikipedia.org/wiki/Interface_(computer_science)http://en.wikipedia.org/wiki/Interface_(computer_science)http://en.wikipedia.org/wiki/Abstract_base_classhttp://en.wikipedia.org/wiki/Abstract_base_classhttp://en.wikipedia.org/wiki/Abstract_base_classhttp://en.wikipedia.org/wiki/Abstract_base_classhttp://en.wikipedia.org/wiki/Dominance_(C%2B%2B)http://en.wikipedia.org/wiki/Dominance_(C%2B%2B)http://en.wikipedia.org/wiki/Dominance_(C%2B%2B)http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=12http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=12http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=12http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/wiki/Type_polymorphismhttp://en.wikipedia.org/wiki/Type_polymorphismhttp://en.wikipedia.org/wiki/Compile-timehttp://en.wikipedia.org/wiki/Compile-timehttp://en.wikipedia.org/wiki/Compile-timehttp://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=13http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=13http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=13http://en.wikipedia.org/wiki/Function_overloadinghttp://en.wikipedia.org/wiki/Function_overloadinghttp://en.wikipedia.org/wiki/Parameter_(computer_science)http://en.wikipedia.org/wiki/Parameter_(computer_science)http://en.wikipedia.org/wiki/Parameter_(computer_science)http://en.wikipedia.org/wiki/Parameter_(computer_science)http://en.wikipedia.org/wiki/Function_overloadinghttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=13http://en.wikipedia.org/wiki/Polymorphism_(computer_science)http://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)http://en.wikipedia.org/wiki/Compile-timehttp://en.wikipedia.org/wiki/Type_polymorphismhttp://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programminghttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=12http://en.wikipedia.org/wiki/Dominance_(C%2B%2B)http://en.wikipedia.org/wiki/Abstract_base_classhttp://en.wikipedia.org/wiki/Abstract_base_classhttp://en.wikipedia.org/wiki/Interface_(computer_science)http://en.wikipedia.org/wiki/Java_(programming_language)http://en.wikipedia.org/wiki/C_Sharp_(programming_language)http://en.wikipedia.org/wiki/Multiple_inheritancehttp://en.wikipedia.org/wiki/Virtual_inheritancehttp://en.wikipedia.org/wiki/Base_classhttp://en.wikipedia.org/wiki/Base_classhttp://en.wikipedia.org/wiki/Inheritance_(computer_science)http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=11http://en.wikipedia.org/wiki/C%2B%2B#cite_note-cppcs-26http://en.wikipedia.org/wiki/C%2B%2B#cite_note-cppcs-26http://en.wikipedia.org/wiki/Datahttp://en.wikipedia.org/wiki/Modularity_(programming)


5/16

When declaring a function, a programmer can specify for one or more parameters adefault 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 overloadedfunction definitions with different numbers of parameters.

Templatesin C++ provide a sophisticated mechanism for writing generic, polymorphic code. In particular,

through theCuriously Recurring Template Pattern, it's possible to implement a form of static

polymorphism that closely mimics the syntax for overriding virtual functions. Since C++ templates are

type-aware andTuring-complete, they can also be used to let the compiler resolve recursive conditionals

and generate substantial programs throughtemplate metaprogramming. Contrary to some opinion,

template code will not generate a bulk code after compilation with the proper compiler settings.[29]

[edit]Dynamic polymorphism

[edit]Inheritance

Variable pointers (and references) to a base class type in C++ can refer to objects of any derived classes

of that type in addition to objects exactly matching the variable type. This allows arrays and other kinds of

containers to hold pointers to objects of differing types. Because assignment of values to variables

usually occurs at run-time, this is necessarily a run-time phenomenon.

C++ also provides a dynamic_cast operator, which allows the program to safely attempt conversion of

an object into an object of a more specific object type (as opposed to conversion to a more general type,

which is always allowed). This feature relies onrun-time type information(RTTI). Objects known to be of

a certain specific type can also be cast to that type withstatic_cast, a purely compile-time construct

that is faster and does not require RTTI.

[edit]Virtual member functionsOrdinarily, when a function in a derived classoverridesa 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 calleddynamic

dispatch.Virtual member functionsormethods[30]

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 usingvirtual function tables. If the object type is known, this may be bypassed by prepending a fully

qualified class namebefore 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. A general

rule of thumb is that if any functions in the class are 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.
http://en.wikipedia.org/wiki/Default_argumentshttp://en.wikipedia.org/wiki/Default_argumentshttp://en.wikipedia.org/wiki/Default_argumentshttp://en.wikipedia.org/wiki/Generic_programming#Templateshttp://en.wikipedia.org/wiki/Generic_programming#Templateshttp://en.wikipedia.org/wiki/Curiously_Recurring_Template_Patternhttp://en.wikipedia.org/wiki/Curiously_Recurring_Template_Patternhttp://en.wikipedia.org/wiki/Curiously_Recurring_Template_Patternhttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/C%2B%2B#cite_note-28http://en.wikipedia.org/wiki/C%2B%2B#cite_note-28http://en.wikipedia.org/wiki/C%2B%2B#cite_note-28http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=14http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=14http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=14http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=15http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=15http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=15http://en.wikipedia.org/wiki/Run-time_type_informationhttp://en.wikipedia.org/wiki/Run-time_type_informationhttp://en.wikipedia.org/wiki/Run-time_type_informationhttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=16http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=16http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=16http://en.wikipedia.org/wiki/Method_overriding_(programming)http://en.wikipedia.org/wiki/Method_overriding_(programming)http://en.wikipedia.org/wiki/Method_overriding_(programming)http://en.wikipedia.org/wiki/Dynamic_dispatchhttp://en.wikipedia.org/wiki/Dynamic_dispatchhttp://en.wikipedia.org/wiki/Dynamic_dispatchhttp://en.wikipedia.org/wiki/Dynamic_dispatchhttp://en.wikipedia.org/wiki/Virtual_functionshttp://en.wikipedia.org/wiki/Virtual_functionshttp://en.wikipedia.org/wiki/Virtual_functionshttp://en.wikipedia.org/wiki/C%2B%2B#cite_note-29http://en.wikipedia.org/wiki/C%2B%2B#cite_note-29http://en.wikipedia.org/wiki/C%2B%2B#cite_note-29http://en.wikipedia.org/wiki/Virtual_function_tablehttp://en.wikipedia.org/wiki/Virtual_function_tablehttp://en.wikipedia.org/wiki/Virtual_function_tablehttp://en.wikipedia.org/wiki/Fully_qualified_namehttp://en.wikipedia.org/wiki/Fully_qualified_namehttp://en.wikipedia.org/wiki/Fully_qualified_namehttp://en.wikipedia.org/wiki/Fully_qualified_namehttp://en.wikipedia.org/wiki/Fully_qualified_namehttp://en.wikipedia.org/wiki/Fully_qualified_namehttp://en.wikipedia.org/wiki/Virtual_function_tablehttp://en.wikipedia.org/wiki/C%2B%2B#cite_note-29http://en.wikipedia.org/wiki/Virtual_functionshttp://en.wikipedia.org/wiki/Dynamic_dispatchhttp://en.wikipedia.org/wiki/Dynamic_dispatchhttp://en.wikipedia.org/wiki/Method_overriding_(programming)http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=16http://en.wikipedia.org/wiki/Run-time_type_informationhttp://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=15http://en.wikipedia.org/w/index.php?title=C%2B%2B&action=edit&section=14http://en.wikipedia.org/wiki/C%2B%2B#cite_note-28http://en.wikipedia.org/wiki/Template_metaprogramminghttp://en.wikipedia.org/wiki/Turing-completehttp://en.wikipedia.org/wiki/Curiously_Recurring_Template_Patternhttp://en.wikipedia.org/wiki/Generic_programming#Templateshttp://en.wikipedia.org/wiki/Default_arguments


6/16

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 data type.

Objects cannot be created from abstract data types; 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.

Structure of a programProbably the best way to start learning a programming language is by writing a program. Therefore,here is our first program:

1234567

8910

// my first program in C++

#include usingnamespace std;

int main (){

cout


7/16

use the standard library, and in fact it will be included in most of the source codes included inthese tutorials.

int main ()

This line corresponds to the beginning of the definition of the main function. The main functionis the point by where all C++ programs start their execution, independently of its locationwithin the source code. It does not matter whether there are other functions with other namesdefined before or after it - the instructions contained within this function's definition will

always be the first ones to be executed in any C++ program. For that same reason, it isessential that all C++ programs have a main function.

The word main is followed in the code by a pair of parentheses (()). That is because it is afunction declaration: In C++, what differentiates a function declaration from other types ofexpressions are these parentheses that follow its name. Optionally, these parentheses mayenclose a list of parameters within them.

Right after these parentheses we can find the body of the main function enclosed in braces

({}). What is contained within these braces is what the function does when it is executed.cout


8/16

We could have written:

int main () { cout


9/16

semicolon (;).

Comments

Comments are parts of the source code disregarded by the compiler. They simply do nothing. Theirpurpose is only to allow the programmer to insert notes or descriptions embedded within the sourcecode.

C++ supports two ways to insert comments:

12// line comment/* block comment */

The first of them, known as line comment, discards everything from where the pair of slash signs (//)

is found up to the end of that same line. The second one, known as block comment, discards

everything between the /*characters and the first appearance of the */ characters, with the possibilityof including more than one line.We are going to add comments to our second program:

123456789

101112

/* my second program in C++with more comments */


int main (){

cout


10/16

The whole process that you have just done with your mental memory is a simile of what a computercan do with two variables. The same process can be expressed in C++ with the following instructionset:

1

234

a = 5;

b = 2;a = a + 1;result = a - b;

Obviously, this is a very simple example since we have only used two small integer values, butconsider that your computer can store millions of numbers like these at the same time and conductsophisticated mathematical operations with them.

Therefore, we can define a variable as a portion of memory to store a determined value.

Each variable needs an identifier that distinguishes it from the others. For example, in the previouscode thevariable identifiers were a, b and result, but we could have called the variables any names

we wanted to invent, as long as they were valid identifiers.

IdentifiersA valid identifieris a sequence of one or more letters, digits or underscore characters (_). Neither

spaces nor punctuation marks or symbols can be part of an identifier. Only letters, digits and singleunderscore characters are valid. In addition, variable identifiers always have to begin with a letter.They can also begin with an underline character (_ ), but in some cases these may be reserved for

compiler specific keywords or external identifiers, as well as identifiers containing two successiveunderscore characters anywhere. In no case can they begin with a digit.

Another rule that you have to consider when inventing your own identifiers is that they cannot match

any keyword of the C++ language nor your compiler's specific ones, which are reserved keywords.The standard reserved keywords are:

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue,default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern,false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new,operator, private, protected, public, register, reinterpret_cast, return, short,signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try,typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t,while

Additionally, alternative representations for some operators cannot be used as identifiers since theyare reserved words under some circumstances:

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

Your compiler may also include some additional specific reserved keywords.

Very important: The C++ language is a "case sensitive"language. That means that an identifierwritten in capital letters is not equivalent to another one with the same name but written in smallletters. Thus, for example, theRESULT variable is not the same as the result variable or

the Result variable. These are three different variable identifiers.


11/16

Fundamental data typesWhen programming, we store the variables in our computer's memory, but the computer has to knowwhat kind of data we want to store in them, since it is not going to occupy the same amount ofmemory to store a simple number than to store a single letter or a large number, and they are notgoing to be interpreted the same way.

The memory in our computers is organized in bytes. A byte is the minimum amount of memory thatwe can manage in C++. A byte can store a relatively small amount of data: one single character or asmall integer (generally an integer between 0 and 255). In addition, the computer can manipulatemore complex data types that come from grouping several bytes, such as long numbers or non-

integer numbers.

Next you have a summary of the basic fundamental data types in C++, as well as the range of valuesthat can be represented with each one:

Name Description Size* Range*

char Character or small integer. 1bytesigned: -128 to 127unsigned: 0 to 255

short

int(short)Short Integer. 2bytes

signed: -32768 to 32767

unsigned: 0 to 65535

int Integer. 4bytessigned: -2147483648 to2147483647unsigned: 0 to 4294967295

long

int (long)Long integer. 4bytes

signed: -2147483648 to2147483647unsigned: 0 to 4294967295

bool Boolean value. It can take one of twovalues: true or false.

1byte true or false

float Floating point number. 4bytes +/- 3.4e +/- 38 (~7 digits)

double Double precision floating point number. 8bytes +/- 1.7e +/- 308 (~15 digits)

long doubleLong double precision floating pointnumber.

8bytes +/- 1.7e +/- 308 (~15 digits)

wchar_t Wide character.2 or4bytes

1 wide character

* The values of the columns Size and Range depend on the system the program is compiled for. Thevalues shown above are those found on most 32-bit systems. But for other systems, the generalspecification is that int has the natural size suggested by the system architecture (one "word") and

the four integer types char, short, int andlong must each one be at least as large as the one

preceding it, with char being always one byte in size. The same applies to the floating point

types float, double and long double, where each one must provide at least as much precision as

the preceding one.

Declaration of variablesIn order to use a variable in C++, we must first declare it specifying which data type we want it to be.The syntax to declare a new variable is to write the specifier of the desired data type (like int, bool,float...) followed by a valid variable identifier. For example:

12int a;float mynumber;


12/16

These are two valid declarations of variables. The first one declares a variable of type intwith theidentifier a. The second one declares a variable of type floatwith the identifier mynumber. Once

declared, the variables a andmynumbercan be used within the rest of their scope in the program.

If you are going to declare more than one variable of the same type, you can declare all of them in a

single statement by separating their identifiers with commas. For example:

int a, b, c;

This declares three variables (a, b and c), all of them of type int, and has exactly the same meaningas:

123

int a;int b;int c;

The integer data types char, short, long and intcan be either signed or unsigned depending on therange of numbers needed to be represented. Signed types can represent both positive and negativevalues, whereas unsigned types can only represent positive values (and zero). This can be specified byusing either the specifiersignedor the specifier unsignedbefore the type name. For example:

12unsignedshortint NumberOfSisters;signedint MyAccountBalance;

By default, if we do not specify either signedor unsignedmost compiler settings will assume the type

to be signed, therefore instead of the second declaration above we could have written:

int MyAccountBalance;

with exactly the same meaning (with or without the keyword signed)

An exception to this general rule is the chartype, which exists by itself and is considered a different

fundamental data type from signed charand unsigned char, thought to store characters. You shoulduse either signed orunsigned if you intend to store numerical values in a char-sized variable.

short and long can be used alone as type specifiers. In this case, they refer to their respective

integer fundamental types: short is equivalent to short int and long is equivalent to long int. The

following two variable declarations are equivalent:

12short Year;shortint Year;

Finally, signed and unsigned may also be used as standalone type specifiers, meaning the same

as signed int andunsigned int respectively. The following two declarations are equivalent:

1 unsigned NextYear;


13/16

2 unsignedint NextYear;

To see what variable declarations look like in action within a program, we are going to see the C++code of the example about your mental memory proposed at the beginning of this section:

12345678910111213

14151617181920212223

// operating with variables


int main (){

// declaring variables:int a, b;int result;

// process:a = 5;

b = 2;a = a + 1;result = a - b;

// print out the result:cout


14/16

Global variables can be referred from anywhere in the code, even inside functions, whenever it is afterits declaration.

The scope of local variables is limited to the block enclosed in braces ({}) where they are declared.

For example, if they are declared at the beginning of the body of a function (like in function main)their scope is between its declaration point and the end of that function. In the example above, thismeans that if another function existed in addition to main, the local variables declared in main could

not be accessed from the other function and vice versa.

Initialization of variablesWhen declaring a regular local variable, its value is by default undetermined. But you may want avariable to store a concrete value at the same moment that it is declared. In order to do that, you caninitialize the variable. There are two ways to do this in C++:

The first one, known as c-like initialization, is done by appending an equal sign followed by the valueto which the variable will be initialized:

type identifier = initial_value ;

For example, if we want to declare an intvariable called a initialized with a value of 0 at the momentin which it is declared, we could write:

int a = 0;

The other way to initialize variables, known as constructor initialization, is done by enclosing the initialvalue between parentheses (()):

type identifier (initial_value) ;

For example:

int a (0);


15/16

Both ways of initializing variables are valid and equivalent in C++.

1234

567891011121314151617

// initialization of variables


int main (){

int a=5; // initial value = 5int b(2); // initial value = 2int result; // initial value

undetermined

a = a + 3;result = a - b;cout


16/16

12string mystring = "This is a string";string mystring ("This is a string");

Strings can also perform all the other basic operations that fundamental data types can, like beingdeclared without an initial value and being assigned values during execution:

123456789101112

131415

// my first string#include #include usingnamespace std;

int main (){

string mystring;mystring = "This is the initial string

content";cout

history of c language

Documents