C++ is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C programming language, or "C with Classes". The language has expanded significantly over time, and modern C++ now has object-oriented, generic, and functional features in addition to facilities for low-level memory manipulation. It is almost always implemented as a compiled language, and many vendors provide C++ compilers, including the Free Software Foundation, LLVM, Microsoft, Intel, Oracle, and IBM, so it is available on many platforms.
C++ was designed with an orientation toward system programming and embedded, resource-constrained software and large systems, with performance, efficiency, and flexibility of use as its design highlights.[10] C++ has also been found useful in many other contexts, with key strengths being software infrastructure and resource-constrained applications,[10] including desktop applications, video games, servers (e.g. e-commerce, web search, or databases), and performance-critical applications (e.g. telephone switches or space probes).
What you should already know
This guide assumes you have the following basic background:
-
A general understanding of the Internet and the World Wide Web (WWW).
- Good working knowledge of HyperText Markup Language (HTML).
-
Some programming experience. If you are new to programming, try one of
the tutorials linked on the main page about C++.
As in C, C++ supports four types of memory management: static storage duration objects, thread storage duration objects, automatic storage duration objects, and dynamic storage duration objects.
Static storage duration objects are created before main() is entered (see exceptions below) and destroyed in reverse order of creation after main() exits. The exact order of creation is not specified by the standard (though there are some rules defined below) to allow implementations some freedom in how to organize their implementation. More formally, objects of this type have a lifespan that "shall last for the duration of the program".
The most common variable types in C++ are local variables inside a function or block, and temporary variables.[61] The common feature about automatic variables is that they have a lifetime that is limited to the scope of the variable. They are created and potentially initialized at the point of declaration (see below for details) and destroyed in the reverse order of creation when the scope is left. This is implemented by allocation on the stack.
You use variables as symbolic names for values in your application. The
names of variables, called identifiers, conform to certain rules.
A variable name can consist of alphabets (both upper and lower case), numbers and the underscore ‘_’ character. However, the name must not start with a number.
The scope of a variable describes where in a program's text the variable may be used, while the extent (also called lifetime) of a variable describes when in a program's execution the variable has a (meaningful) value. The scope of a variable affects its extent. The scope of a variable is actually a property of the name of the variable, and the extent is a property of the storage location of the variable. These should not be confused with context (also called environment), which is a property of the program, and varies by point in the program's text or execution—see scope: an overview. Further, object lifetime may coincide with variable lifetime, but in many cases is not tied to it.
Global variables are in fact properties of the global object. In web
pages the global object is window, so you can set and access global
variables using the window.variable syntax.
Consequently, you can access global variables declared in one window or
frame from another window or frame by specifying the window or frame
name. For example, if a variable called phoneNumber is declared in a
document, you can refer to this variable from an iframe as
parent.phoneNumber.
In computer programming, a constant is a value that should not be altered by the program during normal execution, i.e., the value is constant.[a] When associated with an identifier, a constant is said to be "named," although the terms "constant" and "named constant" are often used interchangeably. This is contrasted with a variable, which is an identifier with a value that can be changed during normal execution, i.e., the value is variable. Constants are useful for both programmers and compilers: For programmers they are a form of self-documenting code and allow reasoning about correctness, while for compilers they allow compile-time and run-time checks that verify that constancy assumptions are not violated, and allow or simplify some compiler optimizations.
There are various specific realizations of the general notion of a constant, with subtle distinctions that are often overlooked. The most significant are: compile-time (statically-valued) constants, run-time (dynamically-valued) constants, immutable objects, and constant types (const).
Typical examples of compile-time constants include mathematical constants, values from standards (here maximum transmission unit), or internal configuration values (here characters per line), such as these C examples
const PI = 3.14;
A constant cannot change value through assignment or be re-declared
while the script is running. It has to be initialized to a value.
The scope rules for constants are the same as those for let block scope
variables. If the const keyword is omitted, the identifier is assumed to
represent a variable.
However, object attributes are not protected, so the following statement
is executed without problems.
Use the if statement to execute a statement if a logical condition is
true. Use the optional else clause to execute a statement if the condition
is false. An if statement looks as follows:
if (condition) { statement_1; } else { statement_2; }
condition can be any expression that evaluates to true or false. See
Boolean for an explanation of what evaluates to true and false. If
condition evaluates to true, statement_1 is executed; otherwise,
statement_2 is executed. statement_1 and statement_2 can be any statement,
including further nested if statements.
You may also compound the statements using else if to have multiple
conditions tested in sequence, as follows:
if (condition_1) { statement_1; } else if (condition_2) { statement_2;
} else if (condition_n) { statement_n; } else { statement_last; }
In the case of multiple conditions only the first logical condition which
evaluates to true will be executed. To execute multiple statements, group
them within a block statement ({ ... }) . In general, it's good practice
to always use block statements, especially when nesting if statements:
if (condition) { statement_1_runs_if_condition_is_true;
statement_2_runs_if_condition_is_true; } else {
statement_3_runs_if_condition_is_false;
statement_4_runs_if_condition_is_false; }
It is advisable to not use simple assignments in a conditional expression,
because the assignment can be confused with equality when glancing over
the code. For example, do not use the following code:
if (x = y) { /* statements here */ } If you need to use an
assignment in a conditional expression, a common practice is to put
additional parentheses around the assignment. For example:
if ((x = y)) { /* statements here */ }
A while statement executes its statements as long as a specified condition
evaluates to true. A while statement looks as follows:
while (condition)
{
statement;
} If the condition becomes false,
statement within the loop stops executing and control passes to the
statement following the loop.
The condition test occurs before statement in the loop is executed. If
the condition returns true, statement is executed and the condition is
tested again. If the condition returns false, execution stops and
control is passed to the statement following while.
To execute multiple statements, use a block statement ({ ... }) to group
those statements.
With each iteration, the loop increments n and adds that value to x.
Therefore, x and n take on the following values:
- After the first pass: n = 1 and x = 1
- After the second pass: n = 2 and x = 3
- After the third pass: n = 3 and x = 6
After completing the third pass, the condition n < 3 is no longer
true, so the loop terminates.