structured-concept: C++--programing-language

concept-created: {2018-03-01}

description of C++

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::
* cpt.filMcsLcpp.last.html,
* cpt.dirTchInf/filMcsLcpp.last.html,
* cpt.Cpp,
* cpt.C++,
* cpt.C++-lang,
* cpt.language.C++,
* cpt.programing-language.C++,

archetype of C++

description::
· C++-archetype is any human information processing method, we want to do with a-machine with processor, RAM, output, storage devices.

name::
* cpt.C++'archetype,
* cpt.C++'problem,

algorithm of C++

description::
· C++-algorithm is a-document describing a-C++-archetype done with a-computer-machine, using the-C++-src-sem-units.

name::
* cpt.C++'algorithm,
* cpt.C++-algo,

specific::
* source-document,
* binary-document,

source-document of C++ (src-doc)

description::
· source-document is a-C++-algorithm written in C++, understood by an-abstract-machine with memory-RAM, storage, input and output devices.

name::
* cpt.C++'src-code,
* cpt.C++'src-document,
* cpt.C++'src-doc,

src-doc'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::
* cpt.C++-algo'memory,
* cpt.C++-memory-of-computer,

src-doc'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::
* cpt.C++'syntax-tree-of-source-document,

src-doc'unit

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::
* cpt.C++'src-unit,
* cpt.C++'src-doc-unit,
* cpt.C++-src-doc'unit,
* cpt.C++-src-unit,

src-unit.SPECIFIC

name::
* cpt.C++-src-unit.specific,

specific::
* identifier-(name),
* keyword,
* white-space,
* operator,
* [] array definition,
* () {} function definition,
* " string definition,
* ; end of a-sentence,

src-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::
* cpt.C++'white-space,

src-unit.keyword

description::
· keywords are reserved identifiers used in source-document creation.
[HmnSgm.2018-03-12]

name::
* cpt.C++'keyword,

addressWpg::
* http://en.cppreference.com/w/cpp/keyword,

src-doc'semantic-unit

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::
* cpt.C++'src-sem-unit,
* cpt.C++-src-doc'semantic-unit,
* cpt.C++-src-sem-unit,

src-sem-unit.SPECIFIC

name::
* cpt.C++-src-sem-unit.specific,

specific::
* array,
* boolean,
* character,
* class,
* constant,
* enumeration,
* function,
* literal,
* named,
* namedNo,
* number,
* pointer,
* reference,
* string,
* structure,
* template,
* type,
* variable,
* void,

=== specific-division on name
* named,
* namedNo,

=== specific-division on process
* process,
* processNo,
* process-and-processNo,

=== specific-division on generic
* generic (type),
* instance (literal),

src-sem-unit.VOID

description::
· void is the-source-semantic-unit that denotes NO information, much like the-zero number.
[HmnSgm.2018-03-05]

name::
* cpt.C++-src-sem-unit.void,
* cpt.C++'void-src-sem-unit,

src-sem-unit.CHARACTER (ch)

description::
· source-character is a-src-sem-unit that denotes any human-symbol in C++-archetype.
[HmnSgm.2018-03-05]

name::
* cpt.C++'character.source,
* cpt.C++-src-sem-unit.ch,
* cpt.C++-src-sem-unit.character,

src-sem-unit.char

name::
* cpt.C++'narrow-character,
* cpt.C++'ordinary-character,
* cpt.C++-src-sem-unit.char,

char-literal

example::
char ch = 'a';
char ch2 = 98; // same as letter b

src-sem-unit.wchar_t (chw)

description::
·

name::
* cpt.C++'wchar_t,
* cpt.C++'wide-character,
* cpt.C++-src-sem-unit.wchar_t,

src-sem-unit.BOOLEAN (b)

name::
* cpt.C++'boolean.source,
* cpt.C++-b,
* cpt.C++-bool,
* cpt.C++-src-sem-unit.b,
* cpt.C++-src-sem-unit.boolean,

bool-literal

example::
// there-are only 2 bool
true
false

src-sem-unit.NUMBER (n)

name::
* cpt.C++'number.source,
* cpt.C++-n,
* cpt.C++-src-number,
* cpt.C++-src-sem-unit.n,
* cpt.C++-src-sem-unit.number,

src-number.INTEGER

name::
* cpt.C++-src-sem-unit.integer-number,
* cpt.C++-src-sem-unit.number.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::
* cpt.C++-src-number.short,
* cpt.C++-src-number.short-int,
* cpt.C++-src-number.signed-short,
* cpt.C++-src-number.signed-short-int,

src-number.int (ni)

description::
· source-int-number are the-integer-numbers such as 123, -456.

name::
* cpt.C++-ni,
* cpt.C++-src-number.int,
* cpt.C++-src-sem-unit.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::
* cpt.C++-nl,
* cpt.C++-src-number.long,
* cpt.C++-src-sem-unit.long-number,

src-number.long-long (nll)

name::
* cpt.C++-nll,
* cpt.C++-src-number.long-long,
* cpt.C++-src-sem-unit.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::
* cpt.C++-src-number.floating-point,
* cpt.C++-src-number.real,
* cpt.C++-src-sem-unit.number.real,
* cpt.C++-src-sem-unit.real-number,

src-number.float (nf)

name::
* cpt.C++-nf,
* cpt.C++-src-number.float,
* cpt.C++-src-sem-unit.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::
* cpt.C++-nd,
* cpt.C++-src-number.double,
* cpt.C++-src-sem-unit.double-number,

src-number.long-double (nld)

name::
* cpt.C++-nld,
* cpt.C++-src-number.long-double,
* cpt.C++-src-sem-unit.long-double-number,

src-number.SIGNED

description::
· unsigned-number is a-number with plus(+) or minus(-) signs in front.
· the-plus(+)-sign could-be-ignored.

name::
* cpt.C++-src-sem-unit.number.signed,
* cpt.C++-src-sem-unit.signed-number,

src-number.UNSIGNED

description::
· unsigned-number is a-number without plus(+) or minus(-) signs in front.

name::
* cpt.C++-src-sem-unit.number.signedNo,
* cpt.C++-src-sem-unit.number.unsigned,
* cpt.C++-src-sem-unit.unsigned-number,

src-sem-unit.STRING (s)

description::
· source-string is a-src-sem-unit that denotes some human-text in C++-archetype.
[HmnSgm.2018-03-05]

name::
* cpt.C++'string.source,
* cpt.C++-s,
* cpt.C++-string,
* cpt.C++-src-sem-unit.s,
* cpt.C++-src-sem-unit.string,

src-sem-unit.FUNCTION (f)

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::
* cpt.C++'function.source,
* cpt.C++'subroutine,
* cpt.C++-f,
* cpt.C++-function,
* cpt.C++-src-f,
* cpt.C++-src-function,
* cpt.C++-src-sem-unit.f,
* cpt.C++-src-sem-unit.function,

definition src-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::
* cpt.C++-src-f'definition,

declaration src-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::
* cpt.C++-src-f'declaration,
* cpt.C++-src-f'prototype,

name src-f

parameter-list of src-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::
* cpt.C++-src-f'parameter-list,

argument of src-f

description::
· argument of a-src-function is the-value we give in a-parameter of it.
[HmnSgm.2018-03-07]

name::
* cpt.C++-src-f'argument,

return-value-type src-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::
* cpt.C++-src-f'return-value-type,

body src-f

description::
· body of a-src-function is the-source-code that describes the-task a-function performs and is-included between {...}.

name::
* cpt.C++-src-f'body,

src-f.SPECIFIC

name::
* cpt.C++-src-f.specific,

src-f.OPERATOR (C++-opr)

description::
· source-operator is a-function with a Math like syntax.
[HmnSgm.2018-03-04]

name::
* cpt.C++'operator.src,
* cpt.C++'src-operator,
* cpt.C++-opr,
* cpt.C++-src-f.operator,
* cpt.C++-src-operator,
* cpt.C++-src-sem-unit.operator,

operand of src-operator

description::
· operand is the INPUT information of operators.

name::
* cpt.C++'operand-of-src-operator,
* cpt.C++-src-operator'operand,

src-operator.UNARY

name::
* cpt.C++-opr.unary,
* cpt.C++-src-operator.unary,

src-operator.BINARY

name::
* cpt.C++-opr.binary,
* cpt.C++-src-operator.binary,

src-operator.TERNARY

name::
* cpt.C++-opr.ternary,
* cpt.C++-src-operator.ternary,

src-operator.ARITHMETIC

name::
* cpt.C++-opr.arithmetic,
* cpt.C++-src-operator.arithmetic,

specific::
** multiplication expr1 * expr2,
/ division expr1 / expr2,
% remainder (Modulus) expr1 % expr2,
+ addition expr1 + expr2,
- subtraction expr1 - expr2,

src-operator.LOGICAL

name::
* cpt.C++-opr.logical,
* cpt.C++-src-operator.logical,

specific::
* && logical-AND expr1 && expr2
* || logical-OR expr1 || expr2
* ! logical-NOT !expr
* ^ logical-XOR expr1 ^ expr2

src-operator.RELATIONAL

name::
* cpt.C++-opr.relational,
* cpt.C++-src-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,

src-operator.sizeof

description::
· sizeof is a-unary-operator which prints the-size of the-operand in bytes.

name::
* cpt.C++-opr.sizeof,
* cpt.C++-src-operator.sizeof,

src-f.MATH

description::
· <cmath> library contains many common-used Mathematical functions.

name::
* cpt.C++-src-f.math,

src-f.main

description::
· the-main-function is the entry point of every C++-program.

name::
* cpt.C++-src-f.main,

src-sem-unit.ARRAY (a)

description::
· source-array is an ordered set of src-sem-units of the same type.
[HmnSgm.2018-03-07]

name::
* cpt.C++'array.source,
* cpt.C++-src-a,
* cpt.C++-src-array,
* cpt.C++-src-sem-unit.array,

definition of src-array

description::
· type array-name[array-length];

src-sem-unit.CLASS (c)

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::
* cpt.C++'class.source,
* cpt.C++-class,
* cpt.C++-src-class,
* cpt.C++-src-sem-unit.c,
* cpt.C++-src-sem-unit.class,

definition of src-class

description::
class cCircle {
 private:
   double nRadius;
   string sColor;
 public:
   double fRadiusGet();
   double fAreaGet();
};

name::
* cpt.C++-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::
* cpt.C++-class'member,

class-member.FUNCTION

name::
* cpt.C++-class'member.function,
* cpt.C++-class'method,
* cpt.C++-class'function-member,

class-function.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::
* cpt.C++-class-function.constructor,

class-function.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::
* cpt.C++-class-function.constructor,

class-function.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::
* cpt.C++-class-function.const,

class-member.FUNCTION.NO

name::
* cpt.C++-class'data-member,
* cpt.C++-class'field,
* cpt.C++-class'functionNo-member,
* cpt.C++-class'member.functionNo,

src-class.OBJECT

description::
· object is-called an-instance of a-class.
[HmnSgm.2018-03-08]

name::
* cpt.C++'object,
* cpt.C++-class.object,

src-sem-unit.ENUMERATION (e)

description::
· source-enumeration is a-set of constants.

name::
* cpt.C++'enumeration.source,
* cpt.C++-src-sem-unit.e,
* cpt.C++-src-sem-unit.enum,
* cpt.C++-src-sem-unit.enumeration,

src-sem-unit.STRUCTURE (sc)

description::
· source-structure is a-set of non-functions src-sem-units.
· a-class contains and functions.
[HmnSgm.2018-03-07]

name::
* cpt.C++'structure.source,
* cpt.C++-src-sem-unit.sc,
* cpt.C++-src-sem-unit.struct,
* cpt.C++-src-sem-unit.structure,

src-sem-unit.TEMPLATE (t)

specific::
* source-template is a-function, class or variable with one or more types not yet specified.

name::
* cpt.C++'template.source,
* cpt.C++-src-sem-unit.template

src-sem-unit.NAMED

description::
· named-source-semantic-unit is a-src-sem-unit with a-name.

name::
* cpt.C++'named-src-sem-unit,
* cpt.C++-src-name-value-pair,
* cpt.C++-src-sem-unit.named,

identifier of named-src-sem-unit

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::
* cpt.C++'identifier-of--src-doc,
* cpt.C++'name-of--src-sem-unit,

value of named-src-sem-unit

description::
· value of named-src-sem-unit[a] is-called the-src-sem-unit we associate with its[a] name.

name::
* cpt.C++'value-of-named-src-sem-unit,
* cpt.C++-named-src-sem-unit'value,

scope of named-src-sem-unit

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::
* cpt.C++'scope-of-named-src-sem-unit,
* cpt.C++-named-src-sem-unit'scope,

named-src-sem-unit.SPECIFIC

name::
* cpt.C++-named-src-sem-unit.specific,

specific::
* array,
* class,
* constant,
* function,
* pointer,
* reference,
* variable,
=== specific-division on value-modification
* constant,
* variable,

named-src-sem-unit.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::
* cpt.C++'variable-of--src-doc,
* cpt.C++-src-variable,
* cpt.C++-src-sem-unit.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::
* cpt.C++-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::
* cpt.C++'value-of-src-variable,
* cpt.C++-src-variable'value,

type of src-variable

description::
· type of a-src-variable is type of the-values of the-variable.

name::
* cpt.C++'type-of-src-variable,
* cpt.C++-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::
* cpt.C++-src-variable'address,

named-src-sem-unit.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::
* cpt.C++'constant-of--src-doc,
* cpt.C++-src-constant,
* cpt.C++-src-sem-unit.constant,

named-src-sem-unit.POINTER (p)

description::
· pointer is a-named-src-sem-unit that stores a-memory-address.
[HmnSgm.2018-03-08]

name::
* cpt.C++-p,
* cpt.C++-pointer-of--src-doc,
* cpt.C++-src-pointer,
* cpt.C++-src-sem-unit.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-src-sem-unit.REFERENCE (rf)

description::
· a-source-reference is an alternate name of an existing src-named-sem-unit.

name::
* cpt.C++'alias-src-named-sem-unit,
* cpt.C++'reference-src-named-sem-unit,
* cpt.C++-src-reference,

definition of src-reference

description::
type &newname = existingname;
type& newname = existingname;
type & newname = existingname;

src-sem-unit.NAMED.NO

name::
* cpt.C++'anonymous-src-sem-unit,
* cpt.C++'namedNo-src-sem-unit,
* cpt.C++-src-sem-unit.namedNo,

specific::
* anonymous-class,
* anonymous-function,

src-sem-unit.INSTANCE (literal)

description::
· literal is an INSTANCE src-sem-unit.

name::
* cpt.C++'literal-src-sem-unit,
* cpt.C++-src-sem-unit.instance,
* cpt.C++-src-sem-unit.literal,

src-sem-unit.INSTANCE.NO (type)

description::
· type is a generic src-sem-unit.

name::
* cpt.C++'type-src-sem-unit,
* cpt.C++-src-sem-unit.instanceNo,
* cpt.C++-src-sem-unit.type,

src-sem-unit.PROCESS

description::
· source-process-sem-unit is a-src-sem-unit that describes a-process of information management.

name::
* cpt.C++-src-sem-unit.process,

specific::
* function,

src-sem-unit.PROCESS.NO

name::
* cpt.C++-src-sem-unit.processNo,

specific::
* array,
* boolean,
* character,
* enumeration,
* number,
* string,
* structure,
* void,

src-sem-unit.PROCESS-AND-PROCESS.NO

name::
* cpt.C++-src-sem-unit.process-and-processNo,

specific::
* class,

src-doc'sentence

description::
· C++-sentence is a language construct that DENOTES a-process or relation.
[HmnSgm.2018-03-02]

name::
* cpt.C++'src-sentence,
* cpt.C++'src-statement,
* cpt.C++-src-doc'sentence,
* cpt.C++-src-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]

src-sentence.SPECIFIC

name::
* cpt.C++-src-sentence.specific,

specific::
* assignment-sentence,
* condition-sentence,
* declaration-sentence,
* definition-sentence,
* if-sentence,
* input-sentence,
* loop-sentence,
* output-sentence,
* preprocessor-directive--sentence,

src-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::
* cpt.C++-definition.source,
* cpt.C++-src-definition,
* cpt.C++-src-sentence.definition,

src-sentence.DECLARATION

description::
· src-declaration is a-src-definition without implementation details.
[HmnSgm.2018-03-04]

name::
* cpt.C++-declaration.source,
* cpt.C++-src-declaration,
* cpt.C++-src-sentence.declaration,

src-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::
* cpt.C++'assignment-src-sentence,
* cpt.C++-src-assignment,
* cpt.C++-src-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::
* cpt.C++'assignment-src-operator,
* cpt.C++-opr.assignment,
* cpt.C++-src-operator.assignment,

src-sentence.CONDITIONAL

name::
* cpt.C++-src-sentence.conditional,
* cpt.C++-src-sentence.decision,

specific::
* if,
* switch,

src-sentence.LOOP

name::
* cpt.C++-src-sentence.iteration,
* cpt.C++-src-sentence.loop,

specific::
* for,
* do,
* while,

src-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::
* cpt.C++'preprocessor-directive,

src-sentence.typedef

description::
· typedef sentence defines a new type.
· syntax: typedef type newtype
· example: typedef unsigned int intu

name::
* cpt.C++'typedef-sentence,
* cpt.C++-src-sentence.typedef,

src-doc'section

name::
* cpt.C++'src-section,
* cpt.C++-src-doc'section,
* cpt.C++-src-section,

specific::
* comment,
* block,

src-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::
* cpt.C++'comment,
* cpt.C++'src-comment,
* cpt.C++-src-section.comment,

src-section.BLOCK

description::
· source-section is an order set of src-sentences enclosed by braces { }.

name::
* cpt.C++'src-block,
* cpt.C++-src-section.block,

src-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::
* cpt.C++'namespace,
* cpt.C++-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,

src-doc'file

name::
* cpt.C++-src-file,

specific::
* implementation-file,
* header-file,

src-file.IMPLEMENTATION (.cpp)

description::
· implementation-files are the main source-files of a-source-document.

name::
* cpt.C++'cpp-file,
* cpt.C++'implementation-source-file,
* cpt.C++'main-source-file,
* cpt.C++-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]

src-file.HEADER (.h)

description::
· a-header-file is a special kind of source-file that is-included by the-preprocessor with the-#include-directive, traditionally used at the-beginning of a-cpp-file.
[https://en.wikibooks.org/wiki/C%2B%2B_Programming/Programming_Languages/C%2B%2B/Code/File_Organization#Extensions]

name::
* cpt.C++'header-file,
* cpt.C++-src-file.header,

src-doc'DOING

name::
* cpt.C++-src-doc'doing,

specific::
* writing,
* building,

src-doc'writing

name::
* cpt.C++-src-doc'writing,

src-doc'building

description::
· C++-building is the-process with input a-source-doc and output its binary-doc.
[HmnSgm.2018-03-03]

name::
* cpt.C++'building-bin-doc,

part::
* preprocessing,
* compiling,
* liking,

src-doc'pre-processing

description::
· C++-source-document is-preprocessed before it is-compiled:

[https://www.ntu.edu.sg/home/ehchua/programming/cpp/cp1_Basics.html#zz-2.5]

name::
* cpt.C++'preprocessing,
* cpt.C++-src-doc'preprocessing,

whole-chain::
* building-bin-doc,

src-doc'compiling

name::
* cpt.C++'compilation,
* cpt.C++'compiling,
* cpt.C++-src-doc'compiling,

whole-chain::
* building-bin-doc,

src-doc'linking

name::
* cpt.C++'linking,

whole-chain::
* building-bin-doc,

src-doc.SPECIFIC

name::
* cpt.C++-src-doc.specific,

src-doc.LIBRARY

name::
* cpt.C++'src-library,
* cpt.C++-library.source,
* cpt.C++-src-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::
* cpt.C++-src-library'relation-to-header-files,

src-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::
* cpt.C++'standard-library,
* cpt.C++-library.standard,

addressWpg::
* C++ Standard Library Header Files: https://msdn.microsoft.com/en-us/,
* https://en.wikipedia.org/wiki/C++_Standard_Library,

namespace of standard-library

description::
· the entire standard-C++-library exists in a-namespace called std.
[http://www.cs.sjsu.edu/~pearce/modules/lectures/cpp/advanced/libcp.htm]

name::
* cpt.C++'namespace.std,
* cpt.C++'std-namespace,

header-file of standard-library

name::
* cpt.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]

src-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::
* cpt.C++'STL,
* cpt.C++-src-library.standard-template-library,
* cpt.C++-src-library.STL,

header-file of STL

name::
* cpt.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]

src-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::
* cpt.C++-src-library.Boost,

src-doc.PROGRAM

name::
* cpt.C++'src-program,

binary-document of C++ (bin-doc)

name::
* cpt.C++'bin-doc,
* cpt.C++'binary-document,
* cpt.C++'bnr-doc,
* cpt.C++'machine-doc,
* cpt.C++'object-code,
* cpt.C++'object-doc,

bin-doc'DOING

name::
* cpt.C++-bin-doc'doing,

specific::
* building--bin-doc,
* running--bin-program,

bin-doc.PROGRAM

name::
* cpt.C++'bin-doc.program,
* cpt.C++'bin-program,
* cpt.C++'program.binary,

evaluation of C++

name::
* cpt.C++'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.]

tool of C++

name::
* cpt.C++'tool,
* cpt.C++-tool,

tool.PREPROCESSOR

description::
· preprocessor is either a separate program invoked by the-compiler or part of the-compiler itself.
· it performs intermediate operations that modify the original source-code and internal compiler options before the-compiler tries to compile the resulting source-code.
[https://en.wikibooks.org/wiki/C%2B%2B_Programming/Programming_Languages/C%2B%2B/Code/Compiler/Preprocessor]

name::
* cpt.C++'preprocessor,
* cpt.C++-tool.preprocessor,

tool.COMPILER

name::
* cpt.C++'compiler,
* cpt.C++-tool.compiler,

attribute::
* Os-support,
* standard-conformance,
* author,
* license,
* Ide,

specific::
* C++Builder,
* Clang,
* GCC,
* Intel-C++-Compiler,
* Oracle-Solaris-Studio,
* Micorosoft-Visual-C++,
* Open-Watcom-C/C++,
===
Popular C++ compilers are MinGW for Windows, XCode for macOS, and GCC on Linux.
* cpp.sh-online-compiler,

compiler.GCC

name::
* cpt.C++-compiler.GCC,
* cpt.GNU-Compiler-Collection,

addressWpg::
* https://gcc.gnu.org/,
* book: An Introduction to GCC: http://www.network-theory.co.uk/,
* https://www.ntu.edu.sg/home/ehchua/programming/cpp/gcc_make.html,

tool.LINKER

description::
The linker is a program that makes executable files. The linker resolves linkage issues, such as the use of symbols or identifiers which are defined in one translation unit and are needed from other translation units. Symbols or identifiers which are needed outside a single translation unit have external linkage. In short, the linker's job is to resolve references to undefined symbols by finding out which other object defines a symbol in question, and replacing placeholders with the symbol's address. Of course, the process is more complicated than this; but the basic ideas apply.
Linkers can take objects from a collection called a library. Depending on the library (system or language or external libraries) and options passed, they may only include its symbols that are referenced from other object files or libraries. Libraries for diverse purposes exist, and one or more system libraries are usually linked in by default.
[https://en.wikibooks.org/wiki/C%2B%2B_Programming/Programming_Languages/C%2B%2B/Code/Compiler/Linker]

name::
* cpt.C++'linker,
* cpt.C++-tool.linker,

tool.EDITOR

name::
* cpt.C++'editor,
* cpt.C++-tool.editor,

tool.IDE

name::
* cpt.C++'Ide,
* cpt.C++-tool.Ide,

specific::
* CodeBlocks,
* Eclipse,
* NetBeans,
* Visual-Studio,

specification of C++

name::
* cpt.C++'specification,
* cpt.C++'standard,
* cpt.C++-spec,
* cpt.C++-standard,

addressWpg::
* https://isocpp.org/,

ISO-working-group of C++-spec

description::
· C++ is-standardized by an-ISO-working-group known as JTC1/SC22/WG21.
[https://en.wikipedia.org/wiki/C++#Standardization]

name::
* cpt.C++'ISO-working-group,
* cpt.C++'standards-committee,

C++-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::
* cpt.C++20,
* cpt.C++-spec.C++20,

C++-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::
* cpt.C++17,
* cpt.C++1z,
* cpt.C++-spec.C++17,

C++-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::
* cpt.C++14,
* cpt.C++-spec.C++14,

C++-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::
* cpt.C++11,
* cpt.C++-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,

C++-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::
* cpt.C++03,
* cpt.C++-spec.C++03,

C++-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::
* cpt.C++98,
* cpt.C++-ISO/IEC-14882:1998,
* cpt.C++-spec.C++98,

resource of C++

Name::
* cpt.C++'resource,
* cpt.C++AeResource,

addressWpg::
* Standard C++ Foundation: https://isocpp.org/,
* cppreference.com,
* Everipedia,

tutorial of C++

name::
* cpt.C++'tutorial,

addressWpg::
* cplusplus.com,
* Chua-Hock-Chuan programing notes: https://www.ntu.edu.sg/,
* wikibooks.org: https://en.wikibooks.org/wiki/C++_Programming,
* C++ Language Reference: https://msdn.microsoft.com/,
* tutorialspoint.com,
* geeksforgeeks.org,

GENERIC of C++

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,
* mapping-method,
* method,
* ModelConceptStructured,
* info,
* model,
* entity,

C++.SPECIFIC

name::
* cpt.C++.specific,
* cpt.C++AsSpecific,

specific::

C++.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::
* cpt.C++.embedded,
* cpt.EC++,

C++.EVOLUTING

name::
* cpt.C++.evoluting,

{time.}::
=== :

{time.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/]

{time.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/]

{time.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/]

{time.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/]

{time.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/]

{time.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/]

{time.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/]

{time.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/]

{time.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/]

{time.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/]

meta-info

this page was-visited times since {2018-03-01}

page-path: synagonism.net / Mcs-worldview / dirTchInf / C++-language

SEARCH::
· this page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
LOCAL-SEARCH:
· TYPE CTRL+F "cpt.words-of-concept's-name", to go to the-LOCATION of the-concept.
GLOBAL-SEARCH:
· clicking on the-green-TITLE of a-page you have access to the-global--locator-names of my-site.
· a-preview of the-description of a-global-name makes reading fast.

footer::
• author: Kaseluris.Nikos.1959
• email:
 imgMail
• twitter: @synagonism
• steemit: https://steemit.com/@synagonism

webpage-versions::
• version.last.dynamic: filMcsLcpp.last.html,
• version.1-0-0.2018-03-17.published: filMcsLcpp.1-0-0.2018-03-17.html,

support (link)