Standard Output (cout)

By default, the standard output of a program is the screen, and the C++ stream object defined to access it is cout.
cout is used in conjunction with the insertion operator, which is written as <<(two "less than" signs).



The <<operator inserts the data that follows it into the stream preceding it. In the examples above it inserted the
constant string Output sentence, the numerical constant 120and variable x into the standard output stream cout.
Notice that the sentence in the first instruction is enclosed between double quotes (") because it is a constant
string of characters. Whenever we want to use constant strings of characters we must enclose them between
double quotes (") so that they can be clearly distinguished from variable names. For example, these two sentences
have very different results:



The insertion operator (<<) may be used more than once in a single statement:



This last statement would print the message Hello, I am a C++ statement on the screen. The utility of repeating
the insertion operator (<<) is demonstrated when we want to print out a combination of variables and constants or
more than one variable:



If we assume the age variable to contain the value 24and the zip code variable to contain 90064the output of the
previous statement would be:



It is important to notice that cout does not add a line break after its output unless we explicitly indicate it,
therefore, the following statements:



will be shown on the screen one following the other without any line break between them:

This is a sentence.This is another sentence.

even though we had written them in two different insertions into cout. In order to perform a line break on the
output we must explicitly insert a new-line character into cout. In C++ a new-line character can be specified as \n
(backslash, n):



This produces the following output:
First sentence.
Second sentence.
Third sentence.
Additionally, to add a new-line, you may also use the endl manipulator. For example:



would print out:
First sentence.
Second sentence.
The end l manipulator produces a newline character, exactly as the insertion of '\n'does, but it also has an
additional behavior when it is used with buffered streams: the buffer is flushed. Anyway, cout will be an
unbuffered stream in most cases, so you can generally use both the \nescape character and the end l manipulator
in order to specify a new line without any difference in its behavior.

Basic Input/Output

Until now, the example programs of previous sections provided very little interaction with the user, if any at all.
Using the standard input and output library, we will be able to interact with the user by printing messages on the
screen and getting the user's input from the keyboard.
C++ uses a convenient abstraction called streams to perform input and output operations in sequential media such
as the screen or the keyboard. A stream is an object where a program can either insert or extract characters
to/from it. We do not really need to care about many specifications about the physical media associated with the
stream - we only need to know it will accept or provide characters sequentially.
The standard C++ library includes the header file iostream , where the standard input and output stream objects
are declared.

Precedence of operators

When writing complex expressions with several operands, we may have some doubts about which operand is
evaluated first and which later. For example, in this expression:



we may doubt if it really means:



The correct answer is the first of the two expressions, with a result of 6. There is an established order with the
priority of each operator, and not only the arithmetic ones (those whose preference come from mathematics) but
for all the operators which can appear in C++. From greatest to lowest priority, the priority order isas follows:




Grouping defines the precedence order in which operators are evaluated in the case that there are several
operators of the same level in an expression.
All these precedence levels for operators can be manipulated or become more legible by removing possible
ambiguities using parentheses signs (and ), as in this example:




might be written either as:


or

depending on the operation that we want to perform.
So if you want to write complicated expressions and you are not completely sure of the precedence levels, always
include parentheses. It will also become a code easier to read.

Bitwise Operators ( &, |, ^, ~, <<, >> )

Bitwise operators modify variables considering the bit patterns that represent the values they store.

Explicit type casting operator

Type casting operators allow you to convert a datum of a given type to another. There are several ways to do this
in C++. The simplest one, which has been inherited from the C language, is to precede the expression to be
converted by the new type enclosed between parentheses (()):


The previous code converts the float number 3.14to an integer value (3), the remainder is lost. Here, the
typecasting operator was (int). Another way to do the same thing in C++ is using the functional notation:
preceding the expression to be converted by the type and enclosing the expression between parentheses:


Both ways of type casting are valid in C++.

size of ()
This operator accepts one parameter, which can be either a type or a variable itself and returns the size in bytes of
that type or object:

This will assign the value 1to a because char is a one-byte long type.
The value returned by size of is a constant, so it is always determined before program execution.

Other operators
Later in these tutorials, we will see a few more operators, like the ones referring to pointers or the specifics for
object-oriented programming. Each one is treated in its respective section.

Conditional operator ( ? )

The conditional operator evaluates an expression returning a value if that expression is true and a different one if
the expression is evaluated as false. Its format is: 
condition ? result1 : result2

If condition is true the expression will return result1, if it is not it will return result2.

 
In this example a was 2 and b was 7, so the expression being evaluated (a>b) was not true, thus the first value
specified after the question mark was discarded in favor of the second value (the one after the colon)which was b,
with a value of 7.

Comma operator ( , )

The comma operator (,) is used to separate two or more expressions that are included where only one expression
is expected. When the set of expressions has to be evaluated for a value, only the rightmost expression is
considered.
For example, the following code: 

Would first assign the value 3to b, and then assign b+2to variable a. So, at the end, variable a would contain the
value 5while variable b would contain value 3.

Logical operators ( !, &&, || )

The Operator !is the C++ operator to perform the Boolean operation NOT, it has only one operand, located at its
right, and the only thing that it does is to inverse the value of it, producing false if its operand is true and true if its
operand is false. Basically, it returns the opposite Boolean value of evaluating its operand. For example: 

The logical operators &&and ||are used when evaluating two expressions to obtain a single relational result. The
operator &&corresponds with Boolean logical operation AND. This operation results true if both its two operands
are true, and false otherwise. The following panel shows the result of operator &&evaluating the expression a &&
b:
&& OPERATOR



The operator ||corresponds with Boolean logical operation OR. This operation results true if either one of its two
operands is true, thus being false only when both operands are false themselves. Here are the possible results of a
|| b: 


|| OPERATOR



For example:

Relational and equality operators ( ==, !=, >, <, >=, <= )

In order to evaluate a comparison between two expressions we can use the relational and equality operators. The
result of a relational operation is a Boolean value that can only be true or false, according to its Boolean result.
We may want to compare two expressions, for example, to know if they are equal or if one is greater than the
other is. Here is a list of the relational and equality operators that can be used in C++:



Here there are some examples:



Of course, instead of using only numeric constants,we can use any valid expression, including variables. Suppose
that a=2, b=3and c=6, 

 

Be careful! The operator =(one equal sign) is not the same as the operator ==(two equal signs), the first one is an
assignment operator (assigns the value at its right to the variable at its left) and the other one (==) is the equality
operator that compares whether both expressions in the two sides of it are equal to each other. Thus, in the last
expression ((b=2) == a), we first assigned the value 2to band then we compared it to a, that also stores the
value 2, so the result of the operation is true.

Increase and decrease (++, --)

Shortening even more some expressions, the increase operator (++) and the decrease operator (--) increase or
reduce by one the value stored in a variable. They are equivalent to +=1and to -=1, respectively. Thus:


are all equivalent in its functionality: the three of them increase by one the value of c.
In the early C compilers, the three previous expressions probably produced different executable code depending on
which one was used. Nowadays, this type of code optimization is generally done automatically by the compiler,
thus the three expressions should produce exactly the same executable code.
A characteristic of this operator is that it can be used both as a prefix and as a suffix. That means that it can be
written either before the variable identifier (++a) or after it (a++). Although in simple expressions like a++or ++a
both have exactly the same meaning, in other expressions in which the result of the increase or decrease operation
is evaluated as a value in an outer expression they may have an important difference in their meaning:In the case
that the increase operator is used as a prefix (++a) the value is increased before the result of the expression is
evaluated and therefore the increased value is considered in the outer expression; in case that it is used as a suffix
(a++) the value stored in a is increased after being evaluated and therefore the value stored before the increase
operation is evaluated in the outer expression. Notice the difference:

In Example 1, B is increased before its value is copied to A. While in Example 2, the value of Bis copied to A and then B is increased.

Arithmetic operators ( +, -, *, /, % )

The five arithmetical operations supported by the C++ language are:



Operations of addition, subtraction, multiplication and division literally correspond with their respective
mathematical operators. The only one that you might not be so used to see is modulo; whose operator is the
percentage sign (%). Modulo is the operation that gives the remainder of a division of two values. For example, if
we write:



the variable a will contain the value 2, since 2is the remainder from dividing 11between 3. 

Compound assignment (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

When we want to modify the value of a variable by performing an operation on the value currently stored in that
variable we can use compound assignment operators:



and the same for all other operators. For example:

Assignment ( = )

The assignment operator assigns a value to a variable.

This statement assigns the integer value 5 to the variable a. The part at the left of the assignment operator (=) is
known as the l value(left value) and the right one as the r value (right value). The l value has to be a variable
whereas the r value can be either a constant, a variable, the result of an operation or any combination of these.
The most important rule when assigning is the right-to-left rule: The assignment operation always takes place from
right to left, and never the other way: 



This statement assigns to variable a(the l value) the value contained in variable b(the r value). The value that was
stored until this moment in a is not considered at all in this operation, and in fact that value is lost.
Consider also that we are only assigning the value of b to a at the moment of the assignment operation. Therefore
a later change of b will not affect the new value of a.
For example, let us have a look at the following code - I have included the evolution of the content stored in the
variables as comments:





This code will give us as result that the value contained in ais 4and the one contained in bis 7. Notice how a was
not affected by the final modification of b, even though we declared a = bear lier (that is because of the right-to-left rule). 


A property that C++ has over other programming languages is that the assignment operation can be used as the
r value (or part of an r value) for another assignment operation. For example: 



is equivalent to: 



that means: first assign 5to variable band then assign to a the value 2plus the result of the previous assignment
of b(i.e. 5), leaving a with a final value of 7.
The following expression is also valid in C++: 




It assigns 5to the all the three variables: a, band c.

Declared constants

With the const prefix you can declare constants with a specific type in the same way as you would do with a
variable: 

Here, path width and tabulator are two typed constants. They are treated just like regular variables except that
their values cannot be modified after their definition.


Operators 

Once we know of the existence of variables and constants, we can begin to operate with them. For that purpose,
C++ integrates operators. Unlike other languages whose operators are mainly keywords, operators in C++are
mostly made of signs that are not part of the alphabet but are available in all keyboards. This makes C++ code
shorter and more international, since it relies less on English words, but requires a little of learning effort in the
beginning.
You do not have to memorize all the content of thispage. Most details are only provided to serve as alater
reference in case you need it.

Defined constants define

You can define your own names for constants that you use very often without having to resort to memory-consuming variables, simply by using the #definepreprocessor directive. Its format is:
#define identifier value
For example:

This defines two new constants: PI and NEWLINE. Once they are defined, you can use them in the rest of the code
as if they were any other regular constant, for example: 



In fact the only thing that the compiler preprocessor does when it encounters #define directives is to literally
replace any occurrence of their identifier (in the previous example, these were PIand NEWLINE) by the code to
which they have been defined (3.14159and '\n'respectively).
The #definedirective is not a C++ statement but a directive for the preprocessor; therefore it assumes the entire
line as the directive and does not require a semicolon (;) at its end. If you append a semicolon character (;) at the
end, it will also be appended in all occurrences within the body of the program that the pre \processor replaces.