Fontem paginae C++ inspicere

{{Latinitas|-2}}
{{Videhom|C}}
'''C++''' est altioris gradus [[lingua programmationis]] quam annis [[1980]]s [[Bjarne Stroustrup]] e [[C (lingua programmandi)|lingua C]] creavit. Hac cum [[programmatura ad res directa|lingua obiecta spectante]] programmata contortuliora modo generaliori faciliorique scribi et compilari possunt, et, ob originem in C, omnia programmata C paene sine mutatione in C++ compilari etiam possunt.

== Salve, munde! ==
Hic textus monstrat programma minimum, quod "Salve, munde!" in [[monitorium]] mittit.
<syntaxhighlight lang="cpp">
// quod iussum obiectum std::cout praebet
#include <iostream>
 
int main()
{
   std::cout << "Salve, munde!" << std::endl;
}
</syntaxhighlight>

== Historia ==
Stroustrup, cum apud Societatis AT&T Bell Laboratoria laborare coeperet, problema datur ut [[nucleus (informatica)|nucleus]] [[Unix|UNIX]] respectu{{dubsig}} computationis distributatae aestimet. Experientia eius studiorum PhD [[memoria]] tenente, Stroustrup linguam C adiunctis [[Simula (lingua programmandi)|linguae Simulae]] meliorare proficiscitur. C selegit propterea quod ad omnia adhiberi potest, celeris portabilisque est, et in usu commni erat. Etiam eo tempore animatus erat ab linguis ALGOL 68, Ada, CLU et ML. 

Annos postquam linguam primum elaborare incepit, anno 1998 norma linguae C++ sancta est designatione [[ISO]]/IEC 14882:1998. Illa norma usque hodie vim habet, sed enmendata est anno 2003 ab Corrigendo Technico [[ISO]]/IEC 14882:2003 designatio. Proxima versio normalis affabiliter C++0x nuncupata usque hodie elaboratur. 
<!--
When Stroustrup started working in AT&T Bell Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing. Remembering his Ph.D. experience, Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it was general-purpose, fast, portable and widely used. Besides C and Simula, some other languages that inspired him were ALGOL 68, Ada, CLU and ML.

The language began as enhancements to C, first adding classes, then virtual functions, function name and operator overloading, multiple inheritance, references, constants, user-controlled free-store memmory control, improved type checking, and BCPL style single-line comments with two forward slashes (//).L ate addition of features included templates, exceptions, namespaces, new casts, and a Boolean type. 

After years of development, the C++ programming language standard was ratified in 1998 as ISO/IEC 14882:1998. That standard is still current, but is amended by the 2003 technical corrigendum, ISO/IEC 14882:2003. The next standard version (known informally as C++0x) is in development.

== Etymologia ==
According to Stroustrup: "the name signifies the evolutionary nature of the changes from C".[5] During C++'s development period, the language had been referred to as "new C", then "C with Classes". The final name is credited to Rick Mascitti (mid-1983) and was first used in December 1983. When Mascitti was questioned informally in 1992 about the naming, he indicated that it was given in a tongue-in-cheek spirit. It stems from C's "++" operator (which increments the value of a variable) and a common naming convention of using "+" to indicate an enhanced computer program.-->

== Natura ==
C++ plurimam linguae C [[syntaxis|syntaxim]] et [[praeprocessorium]] accepit. Lingua autem undecim res additionales praebet quae laborem programmatorum meliorant:
* Dictum <syntaxhighlight lang="cpp" inline>//</syntaxhighlight>, quo post  in singula linea possumus reddere commentationes
* Dictum <syntaxhighlight lang="cpp" inline>const</syntaxhighlight>, quo constantes alphanumerici definiri possunt
* Dictum <syntaxhighlight lang="cpp" inline>inline</syntaxhighlight>, quo functiones singulae lineae definiri possunt
* Declarationes quae ubique possunt poni
* [[Referentia]]s et operatorem referentialem <syntaxhighlight lang="cpp" inline>&</syntaxhighlight>
* <syntaxhighlight lang="cpp" inline>new</syntaxhighlight> et <syntaxhighlight lang="cpp" inline>delete</syntaxhighlight>, quae facile sinunt variabilium memoriam allocare et deallocare  
* [[Lingua obiecta spectans|Obiectorum usum]] lingua re vera sustinet, classes veras praebens, quibus programmatores possunt definire nova genera variabilium programmatis aptorum, et functiones eorum (quae ''methodi'' appellantur).
** Constructores, destructores, operatores, methodosque a programmatoribus definitas
** [[Incapsulatio]]nem, ubi dictis <syntaxhighlight lang="cpp" inline>private</syntaxhighlight>, <syntaxhighlight lang="cpp" inline>public</syntaxhighlight>, <syntaxhighlight lang="cpp" inline>protected</syntaxhighlight> programmatores possunt decernere  variabiles secretos et methodos  quibus hi variabiles  legi,  adhiberi vel commutari possint, 
** [[Hereditas|Hereditatem]], ubi novae classes possunt heriditare variabiles et functiones ex classe antea definita
* [[Superpositio (informatica)|Superpositiones]] ([[Anglice]] ''Overloading'') operatorum mathematicorum et aliorum functionum, ubi programma continue decernit methodum applicabilem iuxta datum variabilium genus
<!--C++ inherits most of C's syntax and the C preprocessor.
C++ is often considered to be a superset of C, but this is not strictly true.[16] Most C code can easily be made to compile correctly in C++, but there are a few differences that cause some valid C code to be invalid in C++, or to behave differently in C++.

One commonly encountered difference is that C allows implicit conversion from void* to other pointer types, but C++ does not. Another common portability issue is that C++ defines many new keywords, such as new and class, that may be used as identifiers (e.g. variable names) in a C program.

Some incompatibilities have been removed by the latest (C99) C standard, which now supports C++ features such as // comments and mixed declarations and code. On the other hand, C99 introduced a number of new features that C++ does not support, such as variable-length arrays, native complex-number types, designated initializers and compound literals[17]. However, at least some of the new C99 features will likely be included in the next version of the C++ standard, C++0x.
-->

=== Classes et obiecta ===
C++ ad C syntaxim [[lingua obiecta spectans|linguarum obiecta spectantium]] introduxit. Classibus cum definiuntur praebentur : abstractio, incapsulatio, hereditas, polymorphismus, et superpositio. Classis ita cogitari potest ut forma ex qua obiecta individua cudantur cum programma operatur. Classis definita idem ac int aut float in programmate fungit, et obiecta declarata idem ac variabiles huius classis. Classes igitur sinunt programmatores omnino nova genera variabilium definire et adhibere quae similia sunt int, float, etc.

Exemplum programmatis infra datum monstrat syntaxim qua classes declaruntur, et quo modo obiecta adhibentur in parte principali programmatis <syntaxhighlight lang="cpp" inline>main()</syntaxhighlight>.

<syntaxhighlight lang="cpp">
#include <iostream>
#include <cstring>
using namespace std;

class persona
{
public: //haec data et functiones publice commutari et haberi possunt
 string nomen;
 int aetasData();

 persona();
private: //haec data et functiones sola per methodos huius classis commutari et haveri possunt
 int annusPraesens = 2013;
 int annusNatalis;
 int aetas;
 void aetatemPonere();
};

void persona::aetatemPonere() //Sola hac methodo aetas personae poni potest
{
cout<<"Quo anno natus est?";
cin>>annusNatalis;
aetas= 2013-annusNatalis;
}

int persona::aetasData() //Sola hac methodo aetas personae dari potest
{
return aetas;
}

persona::persona() //Hic est classis constructor
{
cout<<"Nomen?";
cin>>nomen;
aetatemPonere();
}

int main()
{
persona Maria;
persona *Caesar = new persona;

cout<<Maria.nomen<<" "<<Maria.aetasData()<<endl;
cout<<Caesar->nomen<<" "<<Caesar->aetasData()<<endl;
}
</syntaxhighlight>
<!--
Encapsulation

Encapsuation is 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 public member of the class is accessible to any function. A private member is accessible only to functions that are members of that class and to functions and classes explicitly granted access permission by the class ("friends"). A protected member is accessible to members of classes that inherit from the class in addition to the class itself and any friends.

The 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 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. Because of this, C++ supports not just OO programming, but other weaker decomposition paradigms, like modular programming.

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

Inheritance

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

Multiple inheritance is a C++ feature sometimes considered controversial. Multiple inheritance allows a class to be derived from more than one base class; this can result in a complicated graph of inheritance relationships. For example, a "Flying Cat" class can inherit from both "Cat" and "Flying Mammal". Some other languages, such as Java or C#, accomplish something similar (although more limited) by allowing inheritance of multiple interfaces while restricting the number of base classes to one (interfaces, unlike classes, provide only declarations of member functions, no implementation or member data). Interfaces and abstract classes in Java and C# can be expressed in C++ as a class containing only function declarations, often known as an abstract base class or "ABC." Programmers preferring the Java/C# model of inheritance can choose to inherit only one non-abstract class, and can otherwise limit themselves to only abstract classes.

Polymorphism
See also: Polymorphism in object-oriented programming

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

C++ supports several kinds of static (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.

=== Operatores et eorum superpositio ===
C++ provides more than 30 operators, covering basic arithmetic, bit manipulation, indirection, comparisons, logical operations and more. Almost all operators can be overloaded for user-defined types, with a few notable exceptions such as member access (. and .*). The rich set of overloadable operators is central to using C++ as a domain specific language. The overloadable operators are also an essential part of many advanced C++ programming techniques, such as smart pointers. Overloading an operator does not change the precedence of calculations involving the operator, nor does it change the number of operands that the operator uses (any operand may however be ignored).

=== Formulae ===

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

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

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

{{NexInt}}
* [[C (lingua programmationis)|C]]
* [[D (lingua programmationis)|D]]
* [[GCC]]
* [[Perl]]

== Bibliographia ==
*[https://www.britannica.com/technology/C-computer-language Commentarius ex Encyclopaedia Britannica]
{{DEFAULTSORT:C}}
[[Categoria:Linguae programmationis]]

{{Myrias|Technologia}}