Character and string literals

There also exist non-numerical constants, like: 

The first two expressions represent single character constants, and the following two represent string literals
composed of several characters. Notice that to represent a single character we enclose it between single quotes (')
and to express a string (which generally consists of more than one character) we enclose it between double quotes
(").

When writing both single character and string literals, it is necessary to put the quotation marks surrounding them
to distinguish them from possible variable identifiers or reserved keywords. Notice the difference between these
two expressions: 

x alone would refer to a variable whose identifier is x, whereas 'x'(enclosed within single quotation marks) would
refer to the character constant 'x'.
Character and string literals have certain peculiarities, like the escape codes. These are special characters that are
difficult or impossible to express otherwise in the source code of a program, like newline (\n) or tab (\t). All of
them are preceded by a backslash (\). Here you have a list of some of such escape codes:



For example: 



Additionally, you can express any character by its numerical ASCII code by writing a backslash character (\)
followed by the ASCII code expressed as an octal (base-8) or hexadecimal (base-16) number. In the first case
(octal) the digits must immediately follow the backslash (for example \23or \40), in the second case
(hexadecimal), an x character must be written before the digits themselves (for example \x20or \x4A).
String literals can extend to more than a single line of code by putting a backslash sign (\) at the end of each
unfinished line. 



You can also concatenate several string constants separating them by one or several blank spaces, tabulators, newline or any other valid blank character:



Finally, if we want the string literal to be explicitly made of wide characters (w char_t), instead of narrow characters
(char), we can precede the constant with the L prefix: 

 

Wide characters are used mainly to represent non-English or exotic character sets.


Boolean literals

There are only two valid Boolean values: true and false. These can be expressed in C++ as values of type bool by  
using the Boolean literals true and false.

Floating Point Numbers

They express numbers with decimals and/or exponents. They can include either a decimal point, an e character
(that expresses "by ten at the Xth height", where Xis an integer value that follows the e character), or both a decimal point and an e character:

These are four valid numbers with decimals expressed in C++. The first number is PI, the second one is the
number of Avogadro, the third is the electric charge of an electron (an extremely small number) -all of them
approximated- and the last one is the number three expressed as a floating-point numeric literal.

The default type for floating point literals is double. If you explicitly want to express a float or long double
numerical literal, you can use the for l suffixes respectively:

Any of the letters that can be part of a floating-point numerical constant (e, f, l) can be written using either lower
or uppercase letters without any difference in their meanings.

Integer Numerals

                                                                              Integer Numerals

They are numerical constants that identify integer decimal values. Notice that to express a numerical constant we
do not have to write quotes (") nor any special character. There is no doubt thatit is a constant: whenever we
write 1776in a program, we will be referring to the value 1776.
In addition to decimal numbers (those that all of us are used to use every day) C++ allows the use as literal
constants of octal numbers (base 8) and hexadecimalnumbers (base 16). If we want to express an octal number
we have to precede it with a 0(zero character). And in order to express a hexadecimal number we have to precede
it with the characters 0x(zero, x). For example, the following literal constants are all equivalent to each other:



All of these represent the same number: 75 (seventy-five) expressed as a base-10 numeral, octal numeral and
hexadecimal numeral, respectively.
Literal constants, like variables, are considered to have a specific data type. By default, integer literals are of type
int. However, we can force them to either be unsigned by appending the ucharacter to it, or long by appending l: 



In both cases, the suffix can be specified using either upper or lowercase letters.

Literals

Literals are used to express particular values within the source code of a program. We have already used these
previously to give concrete values to variables or to express messages we wanted our programs to printout, for
example, when we wrote:



the 5in this piece of code was a literal constant.
Literal constants can be divided in Integer Numerals, Floating-Point Numerals, Characters, Strings and Boolean Values.

Constants
Constants are expressions with a fixed value.

Introduction to strings

Variables that can store non-numerical values that are longer than one single character are known as strings.
The C++ language library provides support for strings through the standard string class. This is not a fundamental type, but it behaves in a similar way as fundamental types do in its most basic usage.
A first difference with fundamental data types is that in order to declare and use objects (variables)of this type we need to include an additional header file in our source code: <string>and have access to the std name space
(which we already had in all our previous programs thanks to the using name space statement). 



As you may see in the previous example, strings can be initialized with any valid string literal just like numerical
type variables can be initialized to any valid numerical literal. Both initialization formats are valid with strings:



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

Initialization of variables

When declaring a regular local variable, its value is by default undetermined. But you may want a variable to store
a concrete value at the same moment that it is declared. In order to do that, you can initialize the variable. There are two ways to do this in C++:
The first one, known as c-like, is done by appending an equal sign followed by the value to which the variable will
be initialized:
type identifier = initial_value ;
For example, if we want to declare an int variable called a initialized with a value of 0 at the moment in which it is
declared, we could write:

The other way to initialize variables, known as constructor initialization, is done by enclosing the initial value
between parentheses (()):
type identifier (initial_value) ;
For example: 



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

Scope of variables

All the variables that we intend to use in a program must have been declared with its type specifier in an earlier
point in the code, like we did in the previous code at the beginning of the body of the function main when we
declared that a, b, and result were of type int.
A variable can be either of global or local scope. A global variable is a variable declared in the main body of the
source code, outside all functions, while a local variable is one declared within the body of a function or a block. 

Global variables can be referred from anywhere in the code, even inside functions, whenever it is after its
declaration. The scope of local variables is limited to the block enclosed in braces ({}) where they are declared. For example,

if they are declared at the beginning of the body of a function (like in function main) their scope is between its
declaration point and the end of that function. In the example above, this means that if another function existed in
addition to main, the local variables declared in main could not be accessed from the other function and vice versa.

Declaration of variables

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



These are two valid declarations of variables. The first one declares a variable of type int with the identifier a. The
second one declares a variable of type float with the identifier my number. Once declared, the variables a and
my number can be used within the rest of their scope in the program.
If you are going to declare more than one variable of the same type, you can declare all of them in a single
statement by separating their identifiers with commas. For example:



This declares three variables (a, band c), all of them of type int, and has exactly the same meaning as:
inta;



The integer data types char, short, long and int can be either signed or unsigned depending on the range of
numbers needed to be represented. Signed types can represent both positive and negative values, whereas
unsigned types can only represent positive values (and zero). This can be specified by using either the specifier
signed or the specifier unsigned before the type name. For example:

By default, if we do not specify either signed or unsigned most compiler settings will assume the type to be
signed, therefore instead of the second declaration above we could have written:



with exactly the same meaning (with or without the keyword signed)
An exception to this general rule is the char type, which exists by itself and is considered a different fundamental
data type from signed char and unsigned char, thought to store characters. You should use either signed or unsigned if you intend to store numerical values in a char-sized variable.
short and long can be used alone as type specifiers. In this case, they refer to their respective integer
fundamental types: short is equivalent to short int and long is equivalent to long int. The following two
variable declarations are equivalent:



Finally, signed and unsigned may also be used as standalone type specifiers, meaning the same as signed int and unsigned int respectively. The following two declarations are equivalent:



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

 

Do not worry if something else than the variable declarations themselves looks a bit strange to you. You will see
the rest in detail in coming sections.

Fundamental data types

When programming, we store the variables in our computer's memory, but the computer has to know what kind of
data we want to store in them, since it is not going to occupy the same amount of memory to store a simple
number than to store a single letter or a large number, and they are not going to be interpreted the same way.
The memory in our computers is organized in bytes. A byte is the minimum amount of memory that we can
manage in C++. A byte can store a relatively small amount of data: one single character or a small integer
(generally an integer between 0 and 255). In addition, the computer can manipulate more complex data types that
come from grouping several bytes, such as long numbers or non-integer numbers.
Next you have a summary of the basic fundamental data types in C++, as well as the range of values that can be
represented with each one:

* The values of the columns Size and Range depend on the system the program is compiled for. The values
shown above are those found on most 32-bit systems.But for other systems, the general specification is that int
has the natural size suggested by the system architecture (one "word") and the four integer types char, short,
int and long must each one be at least as large as the one preceding it, with char being always 1 byte in size.
The same applies to the floating point types float, double and long double, where each one must provide at
least as much precision as the preceding one.

Identifiers

A valid identifier is a sequence of one or more letters, digits or underscore characters (_). Neither spaces nor
punctuation marks or symbols can be part of an identifier. Only letters, digits and single underscore characters are
valid. In addition, variable identifiers always have to begin with a letter. They can also begin with an underline
character (_), but in some cases these may be reserved for compiler specific keywords or external identifiers, as
well as identifiers containing two successive underscore characters anywhere. In no case they can begin with a
digit.
Another rule that you have to consider when inventing your own identifiers is that they cannot match any keyword
of the C++ language nor your compiler's specific ones, which are reserved keywords. The standard reserved
keywords are:
asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete,
do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto,
if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register,
reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template,
this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void,
volatile, wchar_t, while
Additionally, alternative representations for some operators cannot be used as identifiers since they are reserved
words under some circumstances:
and, and_eq, bitand, bitor, compl, not, not_eq, or,or_eq, xor, xor_eq

Your compiler may also include some additional specific reserved keywords.
Very important:The C++ language is a "case sensitive" language. That means that an identifier written in capital
letters is not equivalent to another one with the same name but written in small letters. Thus, for example, the
RESULTvariable is not the same as the resultvariable or the Resultvariable. These are three different variable
identifiers.

Variables. Data Types.

The usefulness of the "Hello World" programs shown in the previous section is quite questionable. We had to write
several lines of code, compile them, and then execute the resulting program just to obtain a simple sentence
written on the screen as result. It certainly would have been much faster to type the output sentence by ourselves.
However, programming is not limited only to printing simple texts on the screen. In order to go a little further on
and to become able to write programs that perform useful tasks that really save us work we need to introduce the
concept of variable.
Let us think that I ask you to retain the number 5 in your mental memory, and then I ask you to memorize also
the number 2 at the same time. You have just stored two different values in your memory. Now, if I ask you to add
1 to the first number I said, you should be retaining the numbers 6 (that is 5+1) and 2 in your memory. Values
that we could now for example subtract and obtain 4as result.
The whole process that you have just done with your mental memory is a simile of what a computer can do with
two variables. The same process can be expressed in C++ with the following instruction set:

Obviously, this is a very simple example since we have only used two small integer values, but consider that your
computer can store millions of numbers like these at the same time and conduct sophisticated mathematical
operations with them.
Therefore, we can define a variable as a portion ofmemory to store a determined value.
Each variable needs an identifier that distinguishes it from the others, for example, in the previous code the
variable identifiers were a, band result, but we could have called the variables any names we wanted to invent,
as long as they were valid identifiers.

Comments

Comments are parts of the source code disregarded by the compiler. They simply do nothing. Their purpose is only
to allow the programmer to insert notes or descriptions embedded within the source code.
C++ supports two ways to insert comments:

The first of them, known as line comment, discards everything from where the pair of slash signs (//) is found up
to the end of that same line. The second one, knownas block comment, discards everything between the /*
characters and the first appearance of the */characters, with the possibility of including morethan one line.
We are going to add comments to our second program:



If you include comments within the source code of your programs without using the comment characters
combinations //, /*or */, the compiler will take them as if they were C++ expressions, most likely causing one or
several error messages when you compile it.

Let us add an additional instruction to our first program:

In this case, we performed two insertions into coutin two different statements. Once again, the separation in
different lines of code has been done just to give greater readability to the program, since maincould have been
perfectly valid defined this way:

We were also free to divide the code into more lines if we considered it more convenient:

And the result would again have been exactly the same as in the previous examples.
Preprocessor directives (those that begin by #) are out of this general rule since they are not statements. They are
lines read and processed by the preprocessor and do not produce any code by themselves. Preprocessor directives
must be specified in their own line and do not have to end with a semicolon (;).

Structure of a program

Probably the best way to start learning a programming language is by writing a program. Therefore, here is our first program:The first panel shows the source code for our first program:

 The second one shows the result of the program once
compiled and executed. The way to edit and compile a program depends on the compiler you are using. Depending
on whether it has a Development Interface or not and on its version. Consult the compilers section and the manual
or help included with your compiler if you have doubts on how to compile a C++ console program.
The previous program is the typical program that programmer apprentices write for the first time, and its result is
the printing on screen of the "Hello World!" sentence. It is one of the simplest programs that can be written in
C++, but it already contains the fundamental components that every C++ program has. We are going to look line
by line at the code we have just written:
// my first program in C++
This is a comment line. All lines beginning with two slash signs (//) are considered comments and do not
have any effect on the behavior of the program. The programmer can use them to include short
explanations or observations within the source code itself. In this case, the line is a brief description of
what our program is.
#include <iostream>
Lines beginning with a hash sign (#) are directives for the preprocessor. They are not regular code lines
with expressions but indications for the compiler's preprocessor. In this case the directive #include
<iostream>tells the preprocessor to include the iostream standard file. This specific file (iostream)
includes the declarations of the basic standard input-output library in C++, and it is included because its
functionality is going to be used later in the program.
using namespace std;
All the elements of the standard C++ library are declared within what is called a namespace, the
namespace with the name std. So in order to access its functionality we declare with this expression that
we will be using these entities. This line is very frequent in C++ programs that use the standard library,
and in fact it will be included in most of the source codes included in these tutorials.
int main ()
This line corresponds to the beginning of the definition of the main function. The main function is the point
by where all C++ programs start their execution, independently of its location within the source code.It
does not matter whether there are other functions with other names defined before or after it - the
instructions contained within this function's definition will always be the first ones to be executed in any
C++ program. For that same reason, it is essential that all C++ programs have a main function.
The word main followed in the code by a pair of parentheses (()). That is because it is a function
declaration: In C++, what differentiates a function declaration from other types of expressions are these
parentheses that follow its name. Optionally, these parentheses may enclose a list of parameters within
them.
Right after these parentheses we can find the body of the main function enclosed in braces ({}). What is
contained within these braces is what the function does when it is executed.

History

Bjarne Stroustrup began his work on "C with Classes" in 1979. The idea of creating a new language originated from Stroustrup's experience in programming for his Ph.D. thesis. Stroustrup found that Simula had features that were very helpful for large software development, but the language was too slow for practical use, while BCPL was fast but too low-level to be suitable for large software development. When Stroustrup started working in AT&T Bell Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing. Remembering his Ph.D. experience, Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it was general-purpose, fast, portable and widely used. Besides C and Simula, some other languages that inspired him were ALGOL 68, Ada, CLU and ML. At first, the class, derived class, strong type checking, inlining, and default argument features were added to C via Stroustrup's C++ to C compiler, Cfront. The first commercial implementation of C++ was released on 14 October 1985.

In 1983, the name of the language was changed from C with Classes to C++ (++ being the increment operator in C). New features were added including virtual functions, function name and operator overloading, references, constants, user-controlled free-store memory control, improved type checking, and BCPL style single-line comments with two forward slashes (//). In 1985, the first edition of The C++ Programming Language was released, providing an important reference to the language, as there was not yet an official standard. Release 2.0 of C++ came in 1989 and the updated second edition of The C++ Programming Language was released in 1991. New features included multiple inheritance, abstract classes, static member functions, const member functions, and protected members. In 1990, The Annotated C++ Reference Manual was published. This work became the basis for the future standard. Late feature additions included templates, exceptions, namespaces, new casts, and a Boolean type.

As the C++ language evolved, the standard library evolved with it. The first addition to the C++ standard library was the stream I/O library which provided facilities to replace the traditional C functions such as printf and scanf. Later, among the most significant additions to the standard library, was a large amount of the Standard Template Library.

C++ is sometimes called a hybrid language.

It is possible to write object oriented or procedural code in the same program in C++. This has caused some concern that some C++ programmers are still writing procedural code, but are under the impression that it is object oriented, simply because they are using C++. Often it is an amalgamation of the two. This usually causes most problems when the code is revisited or the task is taken over by another coder.

C++ continues to be used and is one of the preferred programming languages to develop professional applications.

Introduction

C++ (pronounced "see plus plus") is a statically typed, free-form, multi-paradigm, compiled, general-purpose programming language. It is regarded as an intermediate-level language, as it comprises a combination of both high-level and low-level language features. Developed by Bjarne Stroustrup starting in 1979 at Bell Labs, it adds object oriented features, such as classes, and other enhancements to the C programming language. Originally named C with Classes, the language was renamed C++ in 1983, as a pun involving the increment operator.

C++ is one of the most popular programming languages and is implemented on a wide variety of hardware and operating system platforms. As an efficient compiler to native code, its application domains include systems software, application software, device drivers, embedded software, high-performance server and client applications, and entertainment software such as video games. Several groups provide both free and proprietary C++ compiler software, including the GNU Project, Microsoft, Intel and Embarc adero Technologies. C++ has greatly influenced many other popular programming languages, most notably C# and Java. Other successful languages such as Objective-C use a very different syntax and approach to adding classes to C.

C++ is also used for hardware design, where the design is initially described in C++, then analyzed, architecturally constrained, and scheduled to create a register-transfer level hardware description language via high-level synthesis.

The language began as enhancements to C, first adding classes, then virtual functions, operator overloading, multiple inheritance, templates and exception handling among other features. After years of development, the C++ programming language standard was ratified in 1998 as ISO/IEC 14882:1998. The standard was amended by the 2003 technical corrigendum, ISO/IEC 14882:2003. The current standard extending C++ with new features was ratified and published by ISO in September 2011 as ISO/IEC 14882:2011 (informally known as C++11).