overview of lagCppl
description::
· C++ is a-middle-level-programing-language, it is-understood by a-machine with processor, RAM, output, storage, and a specific operating-system-(Os).
· in contrast, a-high-level-programing-language, it is-understood by a-machine with processor, output, storage, and Os.
· it has general-purpose, multi-paradigm (object-oriented, procedural, functional, generic), static-type-checking attributes.
[HmnSgm.2018-03-04]
name::
* McsEngl.McsTchInf000031.last.html//dirTchInf//dirMcs!⇒lagCppl,
* McsEngl.dirMcs/dirTchInf/McsTchInf000031.last.html!⇒lagCppl,
* McsEngl.Cpp!⇒lagCppl,
* McsEngl.C++!⇒lagCppl,
* McsEngl.C++-lang!⇒lagCppl,
* McsEngl.Lcpp!⇒lagCppl,
* McsEngl.lagCpp, {2019-07-04},
* McsEngl.lagCppl, {2021-03-23},
* McsEngl.lagCppl!=McsTchInf000031,
* McsEngl.lagCppl!=C++-language,
* McsEngl.language.C++!⇒lagCppl,
* McsEngl.programing-language.C++!⇒lagCppl,
archetype (input) of lagCppl
description::
· C++-archetype is any human information processing method, we want to do with a-machine with processor, RAM, output, storage devices.
name::
* McsEngl.lagCppl'archetype,
* McsEngl.lagCppl'problem,
algorithm (output) of lagCppl
description::
· C++-algorithm is a-document describing a-C++-archetype understood by an-abstract-machine with memory-RAM, storage, input and output devices, using the-C++-sunits.
name::
* McsEngl.C++'algo!⇒lagCppl-algo,
* McsEngl.lagCppl'algorithm!⇒lagCppl-algo,
* McsEngl.lagCppl'src-doc!⇒lagCppl-algo,
* McsEngl.lagCppl-algo,
algo'machine-memory
description::
· the-computer-machine which understands a-C++-src-doc-algorithm has a sequence of locations for holding information|data|values.
· all these locations are-called memory.
· each location has an-address.
· a-32-bit-computer uses 32-bit (4 bytes) to give names|numbers to these addresses.
· the-quantity of locations|addresses in a-32-bit-machine is 2^32 = 4,294,967,296.
· also each location has 8 bits (1 byte) to store info|data|values|content.
[HmnSgm.2018-03-17]
name::
* McsEngl.lagCppl-algo'memory,
* McsEngl.C++-memory-of-computer,
algo'syntax-tree
description::
· the-structure of a-source-document is a-whole-part-tree of units, semantic-units, sentences, sections of C++.
· this structure we call syntax-tree.
[HmnSgm.2018-03-02]
name::
* McsEngl.lagCppl'syntax-tree-of-source-document,
* McsEngl.lagCppl-algo'syntax-tree,
algo'file
name::
* McsEngl.lagCppl-src-file,
specific::
* implementation-file,
* header-file,
src-file.IMPLEMENTATION (.cpp)
description::
· implementation-files are the main source-files of a-source-document.
name::
* McsEngl.lagCppl'cpp-file,
* McsEngl.lagCppl'implementation-source-file,
* McsEngl.lagCppl'main-source-file,
* McsEngl.lagCppl-src-file.implementation,
===
Some authors will refer to files with a .cpp extension as "source files" and files with the .h extension as "header files". However, both of those qualify as source code.
[https://en.wikibooks.org/wiki/C%2B%2B_Programming/Programming_Languages/C%2B%2B/Code/File_Organization#Extensions]
specification of lagCppl
name::
* McsEngl.C++-spec!⇒lagCppl-spec,
* McsEngl.C++-standard!⇒lagCppl-spec,
* McsEngl.lagCppl'specification!⇒lagCppl-spec,
* McsEngl.lagCppl'standard!⇒lagCppl-spec,
* McsEngl.lagCppl-spec,
addressWpg::
* https://isocpp.org/,
ISO-working-group of lagCppl-spec
description::
· C++ is-standardized by an-ISO-working-group known as JTC1/SC22/WG21.
[https://en.wikipedia.org/wiki/C++#Standardization]
name::
* McsEngl.lagCppl'ISO-working-group,
* McsEngl.lagCppl'standards-committee,
spec.C++20
description::
C++20 is the informal name for the revision of the ISO/IEC standard for the C++ programming language expected to follow C++17.
The C++ Standards Committee began planning C++20 in July 2017.
The current draft is N4713.
[https://en.wikipedia.org/wiki/C++20]
name::
* McsEngl.C++20,
* McsEngl.lagCppl-spec.C++20,
spec.C++17
description::
C++17 (or, informally, C++1z) is the-name for the most recent revision of the-ISO/IEC-14882-standard for the-C++-programming-language.
The-C++17-specification reached the-Draft-International-Standard-(DIS) stage in March-2017.
This DIS was unanimously approved, with only editorial comments, and the final standard was-published in December-2017.
[https://en.wikipedia.org/wiki/C++17]
name::
* McsEngl.C++17,
* McsEngl.C++1z,
* McsEngl.lagCppl-spec.C++17,
spec.C++14
description::
· C++14 is a-version of the-ISO/IEC-14882-standard for the-programming-language-C++.
· It is-intended to be a small extension over C++11, featuring mainly bug fixes and small improvements.
· Its approval was-announced on 2014-August-18.
· C++14 was-released on 2014-December-15.
[https://en.wikipedia.org/wiki/C++14]
name::
* McsEngl.C++14,
* McsEngl.lagCppl-spec.C++14,
spec.C++11
description::
· C++11 is a-version of the-standard for the-programming-language-C++.
· It was-approved by International-Organization-for-Standardization-(ISO) on 12-August-2011, replacing C++03, superseded by C++14 on 18-August-2014 and later, by C++17.
· The-name follows the-tradition of naming language versions by the publication year of the-specification, though it was formerly named C++0x because it was-expected to be-published before 2010.
· Although one of the design goals was to prefer changes to the-libraries over changes to the-core-language, C++11 does-make several additions to the-core-language.
· Areas of the-core-language that were significantly improved include multithreading support, generic-programming support, uniform initialization, and performance.
· Significant changes were also made to the-C++-Standard-Library, incorporating most of the-C++-Technical-Report-1-(TR1) libraries, except the-library of mathematical-special-functions.
· C++11 was-published as ISO/IEC-14882:2011 in September-2011 and is-available for a-fee.
· The-working-draft most similar to the published C++11-standard is N3337, dated 16-January-2012; it has only editorial corrections from the-C++11-standard.
[https://en.wikipedia.org/wiki/C++11]
name::
* McsEngl.C++11,
* McsEngl.lagCppl-spec.C++11,
attribute::
* atomics support,
* auto keyword,
* Boost-library attributes,
* for loop, similar to foeach,
* randomization library,
* regular-expression support,
* threading in standard-library,
* time library,
* variadic templates,
spec.C++03
description::
· C++03 is a-version of an-international-standard for the-programming-language-C++.
· It is-defined by two standards-organizations, the-International-Standards-Organization-(ISO) and the-International-Electrotechnical-Commission-(IEC), in standard ISO/IEC-14882:2003.
· C++03 replaced the prior revision of the-C++-standard, called C++98, and was later replaced by C++11.
· C++03 was primarily a bug fix release for the-implementers to ensure greater consistency and portability.
· This revision addressed 92 core-language defect-reports, 125 library defect-reports, and included only one new language feature: value initialization.
name::
* McsEngl.C++03,
* McsEngl.lagCppl-spec.C++03,
spec.C++98
description::
· C++ is-standardized by an-ISO-working-group known as JTC1/SC22/WG21.
· So far, it has-published five revisions of the-C++-standard and is currently working on the next revision, C++20.
· In 1998, the-ISO-working-group standardized C++ for the first time as ISO/IEC-14882:1998, which is informally known as C++98.
[https://en.wikipedia.org/wiki/C++#Standardization]
name::
* McsEngl.C++98,
* McsEngl.C++-ISO/IEC-14882:1998,
* McsEngl.lagCppl-spec.C++98,
algo'unit of lagCppl
description::
· source-unit is the indivisible entities C++ uses to construct a-source-document that DENOTE NOTHING in C++-archetype.
· these entities are human-symbols as represented in computers, special-entities to represent spaces, tabs, and new-lines (whitespace), and bits (0, 1) to represent audio and image information.
[HmnSgm.2018-03-04]
name::
* McsEngl.lagCppl-src-unit!⇒lagCppl-unit,
* McsEngl.lagCppl'src-unit!⇒lagCppl-unit,
* McsEngl.lagCppl'src-doc-unit!⇒lagCppl-unit,
* McsEngl.lagCppl'unit!⇒lagCppl-unit,
* McsEngl.lagCppl-algo'unit!⇒lagCppl-unit,
* McsEngl.lagCppl-unit,
unit.SPECIFIC
name::
* McsEngl.lagCppl-unit.specific,
specific::
* white-space,
* [] array definition,
* () {} function definition,
* " string definition,
* ; end of a-sentence,
unit.white-space
description::
White Spaces: Blank, tab and new-line are collectively called white spaces.
C++, like most of the computing languages, ignores extra white spaces.
That is, multiple contiguous white spaces are treated as a single white space.
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-2.4]
name::
* McsEngl.lagCppl'white-space,
algo'word of lagCppl
description::
· algo-word is a-structure of units the-language uses to create more compound algo-structures.
name::
* McsEngl.lagCppl-algo'word!⇒lagCppl-word,
* McsEngl.lagCppl-word,
word.name
name::
* McsEngl.lagCppl-word.name,
specific::
* custom-name,
* reserved-name,
algo'semantic-unit of lagCppl
description::
· source-semantic-unit is source-unit constructs that DENOTE CONCEPTS in C++-archetype.
[HmnSgm.2018-03-03]
===
· src-sem-units ARE-DEFINED differently on existing computer-machines (32bit, 64bit, OsWin, OsUnix-like).
[http://en.cppreference.com/w/cpp/language/types]
name::
* McsEngl.lagCppl'src-sem-unit,
* McsEngl.lagCppl-algo'semantic-unit,
* McsEngl.lagCppl-src-sem-unit,
Sunt.SPECIFIC
name::
* McsEngl.lagCppl-Sunt.specific,
specific.on-short-name::
* a-array,
* b-boolean,
* c-class,
* ch-character,
* chw-character.wide,
* e-enumeration,
* f-function,
* nd-number.double,
* nf-number.float,
* ni-number.int,
* nl-number.long,
* nld-number.long-double,
* nll-number.long-long,
* ns-number.short,
* p-pointer,
* rf-reference,
* s-string,
* sc-structure,
* t-template,
specific::
* array,
* boolean,
* character,
* class,
* constant,
* enumeration,
* function,
* literal,
* named,
* namedNo,
* number,
* pointer,
* reference,
* string,
* structure,
* template,
* type,
* variable,
* void,
=== specifics-division on name
* named,
* namedNo,
=== specifics-division on process
* process,
* processNo,
* process-and-processNo,
=== specifics-division on generic
* generic (type),
* instance (literal),
Sunt.void of lagCppl
description::
· void is the-source-semantic-unit that denotes NO information, much like the-zero number.
[HmnSgm.2018-03-05]
name::
* McsEngl.lagCppl-Sunt.void,
* McsEngl.lagCppl'void-src-sem-unit,
Sunt.character (ch) of lagCppl
description::
· source-character is a-src-sem-unit that denotes any human-symbol in C++-archetype.
[HmnSgm.2018-03-05]
name::
* McsEngl.lagCppl'character.source,
* McsEngl.lagCppl-Sunt.ch,
* McsEngl.lagCppl-Sunt.character,
Sunt.char of lagCppl
name::
* McsEngl.lagCppl'narrow-character,
* McsEngl.lagCppl'ordinary-character,
* McsEngl.lagCppl-Sunt.char,
char-literal
example::
char ch = 'a';
char ch2 = 98; // same as letter b
Sunt.wchar_t (chw) of lagCppl
description::
·
name::
* McsEngl.lagCppl'wchar_t,
* McsEngl.lagCppl'wide-character,
* McsEngl.lagCppl-Sunt.wchar_t,
Sunt.string (s) of lagCppl
description::
· source-string is a-src-sem-unit that denotes some human-text in C++-archetype.
[HmnSgm.2018-03-05]
name::
* McsEngl.lagCppl'string.source,
* McsEngl.lagCppl-s,
* McsEngl.C++-string,
* McsEngl.lagCppl-Sunt.s,
* McsEngl.lagCppl-Sunt.string,
Sunt.boolean (b) of lagCppl
name::
* McsEngl.lagCppl'boolean.source,
* McsEngl.lagCppl-b,
* McsEngl.C++-bool,
* McsEngl.lagCppl-Sunt.b,
* McsEngl.lagCppl-Sunt.boolean,
bool-literal
example::
// there-are only 2 bool
true
false
Sunt.number (n) of lagCppl
name::
* McsEngl.C++-n!⇒lagCppl-n,
* McsEngl.lagCppl-src-number!⇒lagCppl-n,
* McsEngl.lagCppl'number.source!⇒lagCppl-n,
* McsEngl.lagCppl-Sunt.n!⇒lagCppl-n,
* McsEngl.lagCppl-Sunt.number!⇒lagCppl-n,
* McsEngl.lagCppl-n,
src-number.INTEGER
name::
* McsEngl.lagCppl-Sunt.integer-number,
* McsEngl.lagCppl-n.integer,
specific::
* short,
* unsigned-short,
* int,
* unsigned-int,
* long,
* unsigned-long,
* long-long,
* unsigned-long-long,
src-number.short (ns)
description::
· short is an-integer represented with 2 bytes (16 bits).
· it is a signed number.
· this means that 1 bit represent the-sign + of - of the-number and the-rest 15 bits can represent 2^15=32768 numbers, 65536 in sum (-32768, 0, +32767).
name::
* McsEngl.lagCppl-n.short,
* McsEngl.lagCppl-n.short-int,
* McsEngl.lagCppl-n.signed-short,
* McsEngl.lagCppl-n.signed-short-int,
src-number.int (ni)
description::
· source-int-number are the-integer-numbers such as 123, -456.
name::
* McsEngl.lagCppl-ni,
* McsEngl.lagCppl-n.int,
* McsEngl.lagCppl-Sunt.int-number,
literal::
int ni = 123;
int ni2 = -123;
int ni3 = 12345678912; // warning: overflow in implicit constant conversion [-Woverflow]
int ni4 = 0123 //octal
int ni5 = 0x1ab //hexadecimal
int ni6 = 0b1010 //binary (may not work on some compilers)
src-number.long (nl)
name::
* McsEngl.lagCppl-nl,
* McsEngl.lagCppl-n.long,
* McsEngl.lagCppl-Sunt.long-number,
src-number.long-long (nll)
name::
* McsEngl.lagCppl-nll,
* McsEngl.lagCppl-n.long-long,
* McsEngl.lagCppl-Sunt.long-long-number,
src-number.REAL
description::
There are 3 floating point types: float, double and long double, for single, double and long double precision floating point numbers.
float and double are represented as specified by IEEE 754 standard.
A float can represent a number between ±1.40239846×10^-45 and ±3.40282347×10^38, approximated.
A double can represented a number between ±4.94065645841246544×10^-324 and ±1.79769313486231570×10^308, approximated.
Take note that not all real numbers can be represented by float and double, because there are infinite real numbers.
Most of the values are approximated.
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-3.7]
name::
* McsEngl.lagCppl-n.floating-point,
* McsEngl.lagCppl-n.real,
* McsEngl.lagCppl-n.real,
* McsEngl.lagCppl-Sunt.real-number,
src-number.float (nf)
name::
* McsEngl.lagCppl-nf,
* McsEngl.lagCppl-n.float,
* McsEngl.lagCppl-Sunt.float-number,
src-number.double (nd)
description::
· source-double-numbers are the-real-numbers such as 3.4, -5.4.
· also they are-called floating-point-numbers.
name::
* McsEngl.lagCppl-nd,
* McsEngl.lagCppl-n.double,
* McsEngl.lagCppl-Sunt.double-number,
src-number.long-double (nld)
name::
* McsEngl.lagCppl-nld,
* McsEngl.lagCppl-n.long-double,
* McsEngl.lagCppl-Sunt.long-double-number,
src-number.SIGNED
description::
· signed-number is a-number with plus(+) or minus(-) signs in front.
· the-plus(+)-sign could-be-ignored.
name::
* McsEngl.lagCppl-n.signed,
* McsEngl.lagCppl-Sunt.signed-number,
src-number.UNSIGNED
description::
· unsigned-number is a-number without plus(+) or minus(-) signs in front.
name::
* McsEngl.lagCppl-n.signedNo,
* McsEngl.lagCppl-n.unsigned,
* McsEngl.lagCppl-Sunt.unsigned-number,
Sunt.function (f) of lagCppl
description::
· source-function is a-src-sem-unit that PROCESS information with optional input and output information.
· we use functions in order to write once a-task and use|call it many times.
[HmnSgm.2018-03-06]
name::
* McsEngl.lagCppl'function.source!⇒lagCppl-f,
* McsEngl.lagCppl'subroutine!⇒lagCppl-f,
* McsEngl.C++-f!⇒lagCppl-f,
* McsEngl.C++-function!⇒lagCppl-f,
* McsEngl.lagCppl-src-f!⇒lagCppl-f,
* McsEngl.lagCppl-src-function!⇒lagCppl-f,
* McsEngl.lagCppl-f, {2019-07-08},
* McsEngl.lagCppl-Sunt.f!⇒lagCppl-f,
* McsEngl.lagCppl-Sunt.function!⇒lagCppl-f,
definition of lagCppl-f
description::
The syntax for function definition is as follows:
returnValueType functionName ( parameterList ) {
functionBody ;
}
* The parameterList consists of comma-separated parameter-type and parameter-name, i.e., param-1-type param-1-name, param-2-type param-2-name,..,
* The returnValueType specifies the type of the return value, such as int or double. An special return type called void can be used to denote that the function returns no value. In C++, a function is allowed to return one value or no value (void). It cannot return multiple values. [C++ does not allow you to return an array!]
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-10.2]
name::
* McsEngl.lagCppl-f'definition,
declaration of lagCppl-f
description::
· src-function-declaration is its function-definition without its body (implementation).
· example:
double fAreaGet(double radius); // parameter ignored
int fMax(int ni1, int ni2);
* C++ demands functions to be-defined or declared BEFORE they are-used,
· function-declarations are usually grouped together and placed in a-header-file.
· the-header-file can-be-included in many programs.
name::
* McsEngl.lagCppl-f'declaration,
* McsEngl.lagCppl-f'prototype,
parameter-list of lagCppl-f
description::
· parameter-list of a-src-function is a comma sepated list of variable type name used to hold the INPUT information of a-src-function.
name::
* McsEngl.lagCppl-f'parameter-list,
return-value-type of lagCppl-f
description::
· return-value-type is the-type of the OUTPUT information of a-src-function.
· if there-is-no return info the-type is void.
name::
* McsEngl.lagCppl-f'return-value-type,
body of lagCppl-f
description::
· body of a-src-function is the-source-code that describes the-task a-function performs and is-included between {...}.
name::
* McsEngl.lagCppl-f'body,
lagCppl-f.SPECIFIC
name::
* McsEngl.lagCppl-f.specific,
lagCppl-f.operator
description::
· source-operator is a-function with a Math like syntax.
[HmnSgm.2018-03-04]
name::
* McsEngl.C++-opr!⇒lagCppl-operator,
* McsEngl.lagCppl-src-operator!⇒lagCppl-operator,
* McsEngl.lagCppl'operator.src!⇒lagCppl-operator,
* McsEngl.lagCppl'src-operator!⇒lagCppl-operator,
* McsEngl.lagCppl-f.operator!⇒lagCppl-operator,
* McsEngl.lagCppl-operator, {2019-07-08},
* McsEngl.lagCppl-Sunt.operator!⇒lagCppl-operator,
operand of operator of lagCppl
description::
· operand is the INPUT information of operators.
name::
* McsEngl.lagCppl'operand-of-src-operator,
* McsEngl.lagCppl-operator'operand,
operator.unary of lagCppl
name::
* McsEngl.lagCppl-opr.unary,
* McsEngl.lagCppl-operator.unary,
operator.binary of lagCppl
name::
* McsEngl.lagCppl-opr.binary,
* McsEngl.lagCppl-operator.binary,
operator.ternary of lagCppl
name::
* McsEngl.lagCppl-opr.ternary,
* McsEngl.lagCppl-operator.ternary,
operator.arithmetic of lagCppl
name::
* McsEngl.lagCppl-opr.arithmetic,
* McsEngl.lagCppl-operator.arithmetic,
specific::
** multiplication expr1 * expr2,
/ division expr1 / expr2,
% remainder (Modulus) expr1 % expr2,
+ addition expr1 + expr2,
- subtraction expr1 - expr2,
operator.logical of lagCppl
name::
* McsEngl.lagCppl-opr.logical,
* McsEngl.lagCppl-operator.logical,
specific::
* && logical-AND expr1 && expr2
* || logical-OR expr1 || expr2
* ! logical-NOT !expr
* ^ logical-XOR expr1 ^ expr2
operator.relational of lagCppl
name::
* McsEngl.lagCppl-opr.relational,
* McsEngl.lagCppl-operator.relational,
specific::
* == equal-to expr1 == expr2,
* != not-equal-to expr1 != expr2,
* > greater-than expr1 > expr2,
* >= greater-than-or-equal-to expr1 >= expr2,
* < less-than expr1 < expr2,
* <= less-than-or-equal-to expr1 <= expr2,
operator.sizeof of lagCppl
description::
· sizeof is a-unary-operator which prints the-size of the-operand in bytes.
name::
* McsEngl.lagCppl-opr.sizeof,
* McsEngl.lagCppl-operator.sizeof,
lagCppl-f.math
description::
· <cmath> library contains many common-used Mathematical functions.
name::
* McsEngl.lagCppl-f.math,
lagCppl-f.main
description::
· the-main-function is the entry point of every C++-program.
name::
* McsEngl.lagCppl-f.main,
Sunt.array (a) of lagCppl
description::
· source-array is an ordered set of src-sem-units of the same type.
[HmnSgm.2018-03-07]
name::
* McsEngl.lagCppl'array.source,
* McsEngl.lagCppl-src-a,
* McsEngl.lagCppl-src-array,
* McsEngl.lagCppl-Sunt.array,
definition of src-array
description::
· type array-name[array-length];
Sunt.class (c) of lagCppl
description::
· source-class is a-set of process and non-process src-sem-units.
· instances of class are-called objects.
[HmnSgm.2018-03-08]
name::
* McsEngl.C++-class!⇒lagCppl-class,
* McsEngl.lagCppl'class.source!⇒lagCppl-class,
* McsEngl.lagCppl-Sunt.c!⇒lagCppl-class,
* McsEngl.lagCppl-Sunt.class!⇒lagCppl-class,
* McsEngl.lagCppl-class,
definition of src-class
description::
class cCircle {
private:
double nRadius;
string sColor;
public:
double fRadiusGet();
double fAreaGet();
};
name::
* McsEngl.lagCppl-class'definition,
member of src-class
description::
· member of a-class[a] is-called any element of the-set of src-sem-units that make it[a].
name::
* McsEngl.lagCppl-class'member,
class-member.function
name::
* McsEngl.lagCppl'method!⇒lagCppl-method,
* McsEngl.lagCppl-class'member.function!⇒lagCppl-method,
* McsEngl.lagCppl-class'method!⇒lagCppl-method,
* McsEngl.lagCppl-class'function-member!⇒lagCppl-method,
* McsEngl.lagCppl-method,
method.constructor
description::
· costructor is a special class-function that has the same name as the-classname, and which is-called implicitly when an-object is-created and initializes the-non-function-members.
name::
* McsEngl.lagCppl-method.constructor,
method.destructor
description::
· destructor is a special class-function that has the same name as the-classname, with the prefix ~, and which is-called implicitly when an-object is-destroyed.
name::
* McsEngl.lagCppl-method.destructor,
method.const
description::
· a-const-class-function, identified by a const keyword at the-end of the-function's declaration, cannot-modifies any data-member of the-class-objects.
name::
* McsEngl.lagCppl-method.const,
class-member.functionNo
name::
* McsEngl.lagCppl-class'data-member,
* McsEngl.lagCppl-class'field,
* McsEngl.lagCppl-class'functionNo-member,
* McsEngl.lagCppl-class'member.functionNo,
src-class.object
description::
· object is-called an-instance of a-class.
[HmnSgm.2018-03-08]
name::
* McsEngl.lagCppl'object,
* McsEngl.lagCppl-class.object,
Sunt.enumeration (e) of lagCppl
description::
· source-enumeration is a-set of constants.
name::
* McsEngl.lagCppl'enumeration.source,
* McsEngl.lagCppl-Sunt.e,
* McsEngl.lagCppl-Sunt.enum,
* McsEngl.lagCppl-Sunt.enumeration,
Sunt.structure (sc) of lagCppl
description::
· source-structure is a-set of non-functions src-sem-units.
· a-class contains and functions.
[HmnSgm.2018-03-07]
name::
* McsEngl.lagCppl'structure.source,
* McsEngl.lagCppl-Sunt.sc,
* McsEngl.lagCppl-Sunt.struct,
* McsEngl.lagCppl-Sunt.structure,
Sunt.template (t) of lagCppl
specific::
* source-template is a-function, class or variable with one or more types not yet specified,
name::
* McsEngl.lagCppl'template.source,
* McsEngl.lagCppl-Sunt.template,
Sunt.named of lagCppl
description::
· named-source-semantic-unit is a-src-sem-unit with a-name.
name::
* McsEngl.lagCppl'named-src-sem-unit,
* McsEngl.lagCppl-src-name-value-pair,
* McsEngl.lagCppl-Sunt.named,
identifier of named-Sunt
description::
· an-identifier is a sequence of characters (a-z, A-Z, 0-9, _), of compiler dependent length (typically 255 characters), used to name source-semantic-units.
· an-identifier must-begin with a-letter or underscore.
· an-identifier cannot-be a reserved keyword or a reserved literal (int, if, for, 35).
· an-identifier is case-sensitive.
name::
* McsEngl.lagCppl'identifier-of--src-doc,
* McsEngl.lagCppl'name-of--src-sem-unit,
value of named-Sunt
description::
· value of named-src-sem-unit[a] is-called the-src-sem-unit we associate with its[a] name.
name::
* McsEngl.lagCppl-named-Sunt'value,
* McsEngl.lagCppl'value-of-named-src-sem-unit,
* McsEngl.lagCppl-value,
scope of named-Sunt
description::
· scope of named-src-sem-unit[a] is THE-PART of the-source-document in which it[a] is-visible.
[HmnSgm.2018-03-13]
name::
* McsEngl.lagCppl'scope-of-named-src-sem-unit,
* McsEngl.lagCppl-named-Sunt'scope,
named-Sunt.SPECIFIC
name::
* McsEngl.lagCppl-named-Sunt.specific,
specific::
* array,
* class,
* constant,
* function,
* pointer,
* reference,
* variable,
=== specifics-division on value-modification
* constant,
* variable,
named-Sunt.VARIABLE
description::
· source-variable is a named src-sem-unit of the same type which can-change instances.
· it is-stored in memory, in consecutive locations depended on its type.
· the-address of the first location, is the-address of the-variable.
[HmnSgm.2018-03-06]
name::
* McsEngl.lagCppl'variable-of--src-doc,
* McsEngl.lagCppl-src-variable,
* McsEngl.lagCppl-Sunt.variable,
name of src-variable
description::
· name of a-src-variable is its identifier.
· I suggest the-names to begin with one or more letters that denote its type.
name::
* McsEngl.lagCppl-src-variable'name,
value of src-variable
description::
· value of a-src-variable is its specific src-sem-unit which is-associated with the-name of this variable.
name::
* McsEngl.lagCppl'value-of-src-variable,
* McsEngl.lagCppl-src-variable'value,
type of src-variable
description::
· type of a-src-variable is type of the-values of the-variable.
name::
* McsEngl.lagCppl'type-of-src-variable,
* McsEngl.lagCppl-src-variable'type,
address of src-variable
description::
· address of a-src-variable is the-address of the first memory location that stores the-value of the-variable.
name::
* McsEngl.lagCppl-src-variable'address,
named-Sunt.CONSTANT
description::
Constants are non-modifiable variables, declared with keyword const. Their values cannot be changed during program execution. Also, const must be initialized during declaration. For examples:
const double PI = 3.1415926; // Need to initialize
Constant Naming Convention: Use uppercase words, joined with underscore. For example, MIN_VALUE, MAX_SIZE.
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-3.4]
name::
* McsEngl.lagCppl'constant-of--src-doc,
* McsEngl.lagCppl-src-constant,
* McsEngl.lagCppl-Sunt.constant,
named-Sunt.POINTER (p)
description::
· pointer is a-named-src-sem-unit that stores a-memory-address.
[HmnSgm.2018-03-08]
name::
* McsEngl.lagCppl-p,
* McsEngl.C++-pointer-of--src-doc,
* McsEngl.lagCppl-src-pointer,
* McsEngl.lagCppl-Sunt.pointer,
definition of src-pointer
description::
type *pointer;
type* pointer;
type * pointer;
string * psColor = &sColor;
where type is the-type of information contained in pointer's memory-address.
named-Sunt.REFERENCE (rf)
description::
· a-source-reference is an alternate name of an existing src-named-sem-unit.
name::
* McsEngl.lagCppl'alias-src-named-sem-unit,
* McsEngl.lagCppl'reference-src-named-sem-unit,
* McsEngl.lagCppl-src-reference,
definition of src-reference
description::
type &newname = existingname;
type& newname = existingname;
type & newname = existingname;
Sunt.namedNo of lagCppl
name::
* McsEngl.lagCppl'anonymous-src-sem-unit,
* McsEngl.lagCppl'namedNo-src-sem-unit,
* McsEngl.lagCppl-Sunt.namedNo,
specific::
* anonymous-class,
* anonymous-function,
Sunt.instance (literal) of lagCppl
description::
· literal is an INSTANCE src-sem-unit.
name::
* McsEngl.lagCppl'literal-src-sem-unit,
* McsEngl.lagCppl-Sunt.instance,
* McsEngl.lagCppl-Sunt.literal,
Sunt.instanceNo (type) of lagCppl
description::
· type is a generic src-sem-unit.
name::
* McsEngl.lagCppl'type-src-sem-unit,
* McsEngl.lagCppl-Sunt.instanceNo,
* McsEngl.lagCppl-Sunt.type,
Sunt.process of lagCppl
description::
· source-process-sem-unit is a-src-sem-unit that describes a-process of information management.
name::
* McsEngl.lagCppl-Sunt.process,
specific::
* function,
Sunt.process-and-processNo of lagCppl
name::
* McsEngl.lagCppl-Sunt.process-and-processNo,
specific::
* class,
algo'sentence of lagCppl
description::
· C++-sentence is a language construct that DENOTES a-process or relation.
[HmnSgm.2018-03-02]
name::
* McsEngl.lagCppl'src-sentence!⇒lagCppl-sentence,
* McsEngl.lagCppl'src-statement!⇒lagCppl-sentence,
* McsEngl.lagCppl-algo'sentence!⇒lagCppl-sentence,
* McsEngl.lagCppl-sentence,
termination of src-sentence
description::
A programming statement must be terminated by a semi-colon (;), just like an English sentence ends with a period. (Why not ends with a period like an english sentence? This is because period crashes with decimal point - it is hard for the dumb computer to differentiate between period and decimal point!)
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-2.3]
sentence.SPECIFIC
name::
* McsEngl.lagCppl-sentence.specific,
specific::
* assignment-sentence,
* condition-sentence,
* declaration-sentence,
* definition-sentence,
* if-sentence,
* input-sentence,
* loop-sentence,
* output-sentence,
* preprocessor-directive--sentence,
sentence.DEFINITION
description::
· src-definition is the-sentence that CREATES new semantic-units in a-src-document.
· it is the MOST IMPORTANT type of employed sentences because all programing-languages work on ONE-DEFINITION-RULE which means that the-compiler refuses to continue when it finds an un-defined semantic-unit or a-semantic-unit defined more than once.
· this rule is what makes source-documents MONOsemantic in contrast to POLYsemantic human-documents.
[HmnSgm.2018-03-04]
name::
* McsEngl.lagCppl'definition-sentence,
* McsEngl.lagCppl-sentence.definition,
sentence.DECLARATION
description::
· src-declaration is a-src-definition without implementation details.
[HmnSgm.2018-03-04]
name::
* McsEngl.lagCppl'declaration,
* McsEngl.lagCppl-sentence.declaration,
sentence.ASSIGNMENT
description::
· src-assignment-sentence is a-sentence with which the-programer associates information to a-named-src-sem-unit.
· example: n = 5;
name::
* McsEngl.lagCppl'assignment-sentence,
* McsEngl.lagCppl-sentence.assignment,
operator of src-assignment
description::
· the-symbol "=" is-known as the-assignment-operator.
· the-meaning of "=" in programming is different from Mathematics.
· it denotes assignment instead of equality.
name::
* McsEngl.lagCppl'assignment-src-operator,
* McsEngl.lagCppl-opr.assignment,
* McsEngl.lagCppl-operator.assignment,
sentence.conditional
name::
* McsEngl.lagCppl'conditional-sentence,
* McsEngl.lagCppl-sentence.conditional,
* McsEngl.lagCppl-sentence.decision,
specific::
* if,
* switch,
sentence.loop
name::
* McsEngl.lagCppl'loop-sentence,
* McsEngl.lagCppl-sentence.iteration,
* McsEngl.lagCppl-sentence.loop,
specific::
* for,
* do,
* while,
sentence.PREPROCESSOR-DIRECTIVE
description::
A preprocessor directive, which begins with a # sign (such as #include, #define), tells the preprocessor to perform a certain action (such as including a header file, or performing text replacement), before compiling the source code into object code.
Preprocessor directives are not programming statements, and therefore should NOT be terminated with a semi-colon.
For example,
#include <iostream> // To include the IO library header
#include <cmath> // To include the Math library header
#define PI 3.14159265 // To substitute the term PI with 3.14159265 in this file
// DO NOT terminate preprocessor directive with a semi-colon
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-2.5]
name::
* McsEngl.lagCppl'preprocessor-directive,
sentence.typedef
description::
· typedef sentence defines a new type.
· syntax: typedef type newtype
· example: typedef unsigned int intu
name::
* McsEngl.lagCppl'typedef-sentence,
* McsEngl.lagCppl-sentence.typedef,
algo'section of lagCppl
name::
* McsEngl.lagCppl'src-section!⇒lagCppl-section,
* McsEngl.lagCppl-algo'section!⇒lagCppl-section,
* McsEngl.lagCppl-section,
specific::
* comment,
* block,
* namespace,
section.COMMENT
description::
· comments are parts of a-source-document that ignored by the-compiler.
· they provide useful explanation and documentation.
· there-are two types of comments:
* multi-line-omment: begins with /* and ends with */. It may span more than one lines,
* end-of-line-comment: begins with // and lasts until the end of the-line,
name::
* McsEngl.lagCppl'comment,
* McsEngl.lagCppl'src-comment,
* McsEngl.lagCppl-section.comment,
section.BLOCK
description::
· source-section is an order set of src-sentences enclosed by braces { }.
name::
* McsEngl.lagCppl'src-block,
* McsEngl.lagCppl-section.block,
section.NAMESPACE (ns)
description::
· namespace is a-section of a-source-document which groups named-src-sem-units to avoid name collision.
[HmnSgm.2018-03-14]
name::
* McsEngl.lagCppl'namespace,
* McsEngl.lagCppl-src-namespace,
definition::
namespace nsName {
int ni; //named-src-sem-units
}
· we refer to an-entity of this namespace as: nsName::ni
specific::
* std-namespace,
algo'DOING of lagCppl
name::
* McsEngl.lagCppl-algo'doing,
specific::
* writing,
* building,
algo'writing
name::
* McsEngl.lagCppl-algo'writing,
algo'building
description::
· C++-building is the-process with input a-source-doc and output its binary-doc.
[HmnSgm.2018-03-03]
name::
* McsEngl.lagCppl'building-bin-doc,
part::
* preprocessing,
* compiling,
* liking,
algo'compiling
name::
* McsEngl.lagCppl'compilation,
* McsEngl.lagCppl'compiling,
* McsEngl.lagCppl-algo'compiling,
whole-chain::
* building-bin-doc,
algo'linking
name::
* McsEngl.lagCppl'linking,
whole-chain::
* building-bin-doc,
algo.SPECIFIC
name::
* McsEngl.lagCppl-algo.specific,
algo.LIBRARY
name::
* McsEngl.C++-library.source!⇒lagCppl-library,
* McsEngl.lagCppl-src-library!⇒lagCppl-library,
* McsEngl.lagCppl'src-library!⇒lagCppl-library,
* McsEngl.lagCppl-library,
relation-to-header-files of src-library
description::
In simple terms, library contains function body whereas header file contains function prototype.Example:
math.h is a header file which includes function prototype for function calls like sqrt(),pow() etc.{ libm.so is the library file used for these type of functions.}
libc.so is a library file which includes function body for function calls like printf(),scanf() etc. {stdio.h is the header file for these functions.}
Note : linux uses .so extension whereas windows uses .dll extension
[https://www.quora.com/What-is-the-difference-between-a-header-file-and-a-library-in-c-programming-language, Mithilesh-Kumar]
name::
* McsEngl.lagCppl-library'relation-to-header-files,
library.STANDARD-STD
description::
· C++-standard-library is a-collection of functions and classes written in the-core-language and part of the-ISO-standard.
· the-standard-ANSI-C-library is-ported over C++ with a-prefix "c" and without the ".h", e.g., <cmath> for C's <math.h>.
· the-C++-standard-library and the-STL share many features, but neither is a strict superset of the other.
name::
* McsEngl.lagCppl'standard-library,
* McsEngl.C++-library.standard,
* McsEngl.lagCppl-library.standard,
addressWpg::
* C++ Standard Library Header Files: https://msdn.microsoft.com/en-us/,
* https://en.wikipedia.org/wiki/C++_Standard_Library,
header-file of standard-library
name::
* McsEngl.C++-header-file.standard-library,
specific::
· the-src-sem-units of standard-library are-distributed among some 51 header-files.
[http://www.cs.sjsu.edu/~pearce/modules/lectures/cpp/advanced/libcp.htm]
===
* Algorithms
<algorithm>
* C Library Wrappers
<cassert>, <cctype>, <cerrno>, <cfenv>, <cfloat>, <cinttypes>, <ciso646>, <climits>, <clocale>, <cmath>, <csetjmp>, <csignal>, <cstdarg>, <cstdbool>, <cstddef>, <cstdint>, <cstdio>, <cstdlib>, <cstring>, <ctgmath>, <ctime>, <cwchar>, <cwctype>
* Containers
* Sequence
<array>, <deque>, <forward_list>, <list>, <vector>
* Ordered Associative
<map>, <set>
* Unordered Associative
<unordered_map>, <unordered_set>
* Adaptor
<queue>, <stack>
* Error Handling
<exception>, <stdexcept>, <system_error>
* Input/Output
<filesystem>, <fstream>, <iomanip>, <ios>, <iosfwd>, <iostream>, <istream>, <ostream>, <sstream>, <streambuf>, <strstream>
* Iterators Library
<iterator>
* Localization
<codecvt>, <cvt/wbuffer>, <cvt/wstring>, <locale>
* Math and Numerics
<complex>, <limits>, <numeric>, <random>, <ratio>, <valarray>
* Memory Management [more information]
<allocators>, <memory>, <new>, <scoped_allocator>
* Multithreading
<atomic>, <condition_variable>, <future>, <mutex>, <shared_mutex>, <thread>
* Other Utilities
<bitset>, <chrono>, <functional>, <initializer_list>, <tuple>, <type_traits>, <typeinfo>, <typeindex>, <utility>
* Strings and Character Data
<regex>, <string>
[https://msdn.microsoft.com/en-us/library/a7tkse1h.aspx]
library.STANDARD-TEMPLATE-LIBRARY-STL
description::
STL was developed by Alexander Stepanov and Meng Lee at Hewlett-Packard Lab as proof-of-concept for so-called generic programming. It was released in 1994 and subsequently adopted into the C++98.
STL provides a collection of templates representing containers, iterators, algorithms and function objects.
- A container (templatized data structure) can be used to hold fundamental-type values or almost any type of objects, e.g., vector, list, deque.
- An iterator (a generalization of pointer) is an object that lets you transverse through elements of a container, e.g., vector::iterator, list::iterator.
- Algorithms are used for tasks such as searching, sorting and comparison, e.g., for_each, find, sort.
- Function objects are objects that act like functions.
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp9_STL.html#zz-1.3]
name::
* McsEngl.lagCppl'STL,
* McsEngl.lagCppl-library.standard-template-library,
* McsEngl.lagCppl-library.STL,
header-file of STL
name::
* McsEngl.C++-STL'header-file,
specific::
STL is provided in the following headers:
* <vector>, <list>, <deque>, <queue>, <stack>, <map>, <set>, <bitset>, <forward_list> (C++11), <unordered_map> (C++11), <unordered_set> (C++11), <array> (C++11): Containers data structures template classes,
* <iterator>: Iterator for transversing the elements in a container,
* <algorithm>, <numeric>, <functional>, <utility>: Algorithm and function objects,
* <initializer_list> (C++11), <memory> (C++11),
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp9_STL.html#zz-1.3]
library.BOOST
description::
Boost provides free peer-reviewed portable C++ source libraries.
We emphasize libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.
[http://www.boost.org/]
name::
* McsEngl.lagCppl-library.Boost,
algo.PROGRAM
name::
* McsEngl.lagCppl'program,
* McsEngl.lagCppl-algo.program,
* McsEngl.lagCppl-program,
binary-algo of lagCppl
description::
· lagCppl[a] is a-compiled-language.
· its[a] algo is-translated to a-binary-algo to be-understood by a-real-machine.
name::
* McsEngl.lagCppl'bin-doc!⇒LagCpp-bin-algo,
* McsEngl.lagCppl'binary-document!⇒LagCpp-bin-algo,
* McsEngl.lagCppl'bnr-doc!⇒LagCpp-bin-algo,
* McsEngl.lagCppl'machine-doc!⇒LagCpp-bin-algo,
* McsEngl.lagCppl'object-code!⇒LagCpp-bin-algo,
* McsEngl.lagCppl'object-doc!⇒LagCpp-bin-algo,
* McsEngl.lagCppl-bin-algo,
DOING of bin-algo
name::
* McsEngl.lagCppl-bin-algo'doing,
specific::
* building--bin-doc,
* running--bin-program,
bin-algo.PROGRAM
name::
* McsEngl.lagCppl'bin-program,
* McsEngl.lagCppl'program.binary,
* McsEngl.lagCppl-bin-doc.program,
* McsEngl.lagCppl-bin-program,
evaluation of lagCppl
name::
* McsEngl.lagCppl'evaluation,
evaluation::
C++ Strength and Pitfall
C++ is a powerful language for high-performance applications, including writing operating systems and their subsystems, games and animation.
C++ is also a complex and difficult programming language, which is really not meant for dummies.
For example, to effectively use the C++ Standard Template Library (STL), you need to understand these difficult concepts: pointers, references, operator overloading and template, on top of the object-oriented programming concepts such as classes and objects, inheritance and polymorphism; and the traditional constructs such as decision and loop.
C++ is performance centric.
The C++ compiler does not issue warning/error message for many obvious programming mistakes, undefined and unspecified behaviors, such as array index out of range, using an uninitialized variable, etc, due to the focus on performance and efficiency rather than the ease of use - it assumes that those who choose to program in C++ are not dummies.
[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-1.]
EVOLUTING of lagCppl
name::
* McsEngl.lagCppl'evoluting,
{2014}::
=== C++14:
On August 18, 2014, the ISO (International Organization for Standardization) approved a new version of C++, called C++14. Unlike C++11, which added a huge amount of new functionality, C++14 is a comparatively minor update, mainly featuring bug fixes and small improvements.
[http://www.learncpp.com/cpp-tutorial/b-2-introduction-to-c14/]
{2011}::
=== C++11:
In mid-2011, the new C++ standard (dubbed C++11) was finished. The Boost library project made a considerable impact on the new standard, and some of the new modules were derived directly from the corresponding Boost libraries. Some of the new features included regular expression support, a comprehensive randomization library, a new C++ time library, atomics support, a standard threading library (which up until 2011 both C and C++ were lacking), a new for loop syntax providing functionality similar to foreach loops in certain other languages, the auto keyword, new container classes, better support for unions and array-initialization lists, and variadic templates.
[http://www.cplusplus.com/info/history/]
{2005}::
=== TR1:
In 2005, the C++ standards committee released a technical report (dubbed TR1) detailing various features they were planning to add to the latest C++ standard.
The new standard was informally dubbed C++0x as it was expected to be released sometime before the end of the first decade.
Ironically, however, the new standard would not be released until mid-2011.
Several technical reports were released up until then, and some compilers began adding experimental support for the new features.
[http://www.cplusplus.com/info/history/]
{2003}::
=== C++03:
In 2003, the committee responded to multiple problems that were reported with their 1998 standard, and revised it accordingly. The changed language was dubbed C++03.
[http://www.cplusplus.com/info/history/]
{1998}::
=== C++98:
In 1998, the C++ standards committee published the first international standard for C++ ISO/IEC 14882:1998, which would be informally known as C++98.
The Annotated C++ Reference Manual was said to be a large influence in the development of the standard.
The Standard Template Library, which began its conceptual development in 1979, was also included.
[http://www.cplusplus.com/info/history/]
{1990}::
=== Turbo C++:
In 1990, The Annotated C++ Reference Manual was released.
The same year, Borland's Turbo C++ compiler would be released as a commercial product.
Turbo C++ added a plethora of additional libraries which would have a considerable impact on C++'s development.
Although Turbo C++'s last stable release was in 2006, the compiler is still widely used.
[http://www.cplusplus.com/info/history/]
{1989}::
=== inheritance:
The language was updated again in 1989 to include protected and static members, as well as inheritance from several classes.
[http://www.cplusplus.com/info/history/]
{1985}::
=== book: The C++ Programming Language:
In 1985, Stroustrup's reference to the language entitled The C++ Programming Language was published.
That same year, C++ was implemented as a commercial product.
The language was not officially standardized yet, making the book a very important reference.
[http://www.cplusplus.com/info/history/]
{1983}::
=== C++:
In 1983, the name of the language was changed from C with Classes to C++. The ++ operator in the C language is an operator for incrementing a variable, which gives some insight into how Stroustrup regarded the language. Many new features were added around this time, the most notable of which are virtual functions, function overloading, references with the & symbol, the const keyword, and single-line comments using two forward slashes (which is a feature taken from the language BCPL).
[http://www.cplusplus.com/info/history/]
{1979}::
=== C with classes:
The C++ programming language has a history going back to 1979, when Bjarne Stroustrup was doing work for his Ph.D. thesis. One of the languages Stroustrup had the opportunity to work with was a language called Simula, which as the name implies is a language primarily designed for simulations. The Simula 67 language - which was the variant that Stroustrup worked with - is regarded as the first language to support the object-oriented programming paradigm. Stroustrup found that this paradigm was very useful for software development, however the Simula language was far too slow for practical use.
Shortly thereafter, he began work on "C with Classes", which as the name implies was meant to be a superset of the C language. His goal was to add object-oriented programming into the C language, which was and still is a language well-respected for its portability without sacrificing speed or low-level functionality. His language included classes, basic inheritance, inlining, default function arguments, and strong type checking in addition to all the features of the C language.
The first C with Classes compiler was called Cfront, which was derived from a C compiler called CPre. It was a program designed to translate C with Classes code to ordinary C. A rather interesting point worth noting is that Cfront was written mostly in C with Classes, making it a self-hosting compiler (a compiler that can compile itself). Cfront would later be abandoned in 1993 after it became difficult to integrate new features into it, namely C++ exceptions. Nonetheless, Cfront made a huge impact on the implementations of future compilers and on the Unix operating system.
[http://www.cplusplus.com/info/history/]
GENERIC of lagCppl
Generic-chain::
* middle-level--programing-language,
* general-purpose--programing-language,
* object-oriented--programing-language,
* compiled--programing-language,
* procedural--programing-language,
* generic-programing--programing-language,
* programing-language,
* computer-language,
* language,
* mapping-method,
* method,
* ModelConceptStructured,
* info,
* model,
* entity,
lagCppl.SPECIFIC
name::
* McsEngl.lagCppl.specific,
* McsEngl.C++AsSpecific,
specific::
lagCppl.EMBEDDED
description::
Embedded C++ (EC++) is a dialect of the C++ programming language for embedded systems.
It was defined by an industry group led by major Japanese central processing unit (CPU) manufacturers, including NEC, Hitachi, Fujitsu, and Toshiba, to address the shortcomings of C++ for embedded applications.
The goal of the effort[1] is to preserve the most useful object-oriented features of the C++ language yet minimize code size while maximizing execution efficiency and making compiler construction simpler.
The official website states the goal as "to provide embedded systems programmers with a subset of C++ that is easy for the average C programmer to understand and use".
[https://en.wikipedia.org/wiki/Embedded_C++]
name::
* McsEngl.lagCppl.embedded,
* McsEngl.EC++,
