The assignment operator assigns a value to a variable.
Assignment operations are expressions that can be evaluated. That means that the assignment itself has a value, and - for fundamental types - this value is the one assigned in the operation.
y = x + (x = 5);
x = y = z = 5;
+, -, *, /, %
)Operator | Description |
---|---|
+ | addition |
- | subtraction |
* | multiplication |
/ | division |
% | modulo 模除(取余), gives the remainder(余数) of a division of two values |
+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=
) 复合赋值Compound assignment operators modify the current value of a variable by performing an operation on it. They are equivalent to assigning the result of an operation to the first operand(运算对象):
expression | equivalent to … |
---|---|
y += x; | y = y + x; |
x -= 5; | x = x -5; |
x /= y; | x = x / y; |
price *= units + 1; | price = price * (units + 1); |
++, --
)The increase operator (++
) and the decrease operator (--
) increase or reduce by one the value stored in a variable. They are equivalent to +=1
and to -=1
, respectively.
A peculiarity 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 name(++x
) or after it (x++
).
In simple expressions like x++
or ++x
, both have exactly the same meaning
In other expressions in which the result of the increment or decrement operation is evaluated, they may have an important difference in their meaning:
In the case that the increase operator is used as a prefix(++x) of the value, the expression evaluates to the final value of x, once it is already increased
On the other hand, in case that it is used as a suffix (x++), the value is also increased, but the expression evaluates to the value that x had before being increased
Example 1 | Example 2 |
---|---|
x = 3; y = ++x; // x contains 4, y contains 4 |
x = 3; y = x++; //x contains 4, y contains 3 |
==, !=, >, <, >=, <=
)The result of such an operations is either true
or false
.
Operator | Description |
---|---|
== | Equal to |
!= | Not equal to |
< | Less than |
> | Greater than |
<= | Less than or equal to |
>= | Greater than or equal to |
Of course, it’s not just numeric constants that can be compared, but just any value, including, of course, variables.
!, &&, ||
)The operator !
is the C++ operator for the Boolean operation NOT
. It has only one operand , to its right, and inverts it.
!true // evaluates to false
&& and
|| or
The logical operators &&
and ||
are used when evaluating two expressions to obtain a single relational result.
?
)The conditional operator evaluates an expression, returning one value if that exprssion evaluates to true
, and a different one if the expression evaluates as false
. Its syntax is :
condition ? result1 : result2
If condition
is true
, the entire expression evaluates to result1
, and otherwise to result2
.
,
)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 right-most expression is considered.
For example, the following code:
a = (b=3, b+2);
would first assign the value 3
to b
, and then assign b+2
to variable a
. At the end, variable a
would contain the value 5
while variable b
would contain value 3
.
&, |, ^, ~, <<, >>
)Bitwise operators modify variables considering the bit patterns that represent the values they store.
Operator | Asm Equivalent | Description |
---|---|---|
& | AND | Bitwise AND |
| | OR | Bitwise inclusive OR (位或) |
^ | XOR | Bitwise exclusive OR |
~ | NOT | Unary complement (bit inversion) |
<< | SHL | Shift bits left |
>> | SHR | Shift bits right |
Type casting operators allow to convert a value
of a given type
to another type
.
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(())
int i;
float f = 3.14;
i = (int) f;
Another way to do the same thing in C++ is to use the functional notation preceding the expression to be converted by the type and enclosing the expression between parentheses:
i = int (f);
This operator accepts one parameter, which can be either a type or a vaiable, and returns the size in bytes of that type or object:
x = sizeof(char);
Here, x
is assigned the value 1
, because char is a type with a size of one byte.
The value returned by sizeof is a compile-time constant, so it is always determined before program execution.
From greatest to smallest priority, C++ operators are evaluated in the following order:
When an expression has two operators with the same precedence level, grouping determines which one is evaluated first: either left-to-right or right-to-left .
C++ uses a convenient abstraction called streams to perform input and output operations in sequential media such as the screen, the keyboard or a file.
A stream is an entity where a program can either insert or extract characters to/from.
All we need to know about the media associated to the stream is that strams are a source/destination of characters, and that these characters are provided/accepted seqentially (i.e., one after another).
The standard library defines a handful of stream objects that can be used to access what are considered the standard sources and destinations of characters by the environment where the program runs:
Stream | Description |
---|---|
cin | standard input stream |
cout | standard output stream |
cerr | standard error (output) stream |
clog | standard logging (output) stream |
We are going to see in more detail only cout
and cin
(the standard output and input streams); cerr
and clog
are also output streams, so they essentially work like cout
, with the only difference being that they identify streams for specific purposes: error messages and logging.
On most program environments, the standard output by default is the screen, and the C++ stream object defined to access it is cout
.
For formatted output operations, cout
is used together with the insertion operator, which is written as << (i.e., two “less than” signs)
cout << "Output sentence";
cout << 120;
cout << x;
// Multiple insertion operations may be chained in a single statement
cout << "This " << "is a " << "Single C++ statement"; // print the text This is a single C++ statement
The <<
operator inserts the data that follows it into the stream that precedes it.
Chaining insertions is especially useful to mix literals and variables in a single statement.
What cout
does not do automatically is add line breaks at the end, unless instructed to do so.
In C++, a new-line character can be specified as \n
. Alternatively, the endl
manipulator can also be used to break lines. What’s the differences between them is the endl
also has an additional behavior: the stream’s buffer is flushed.
cout << 'First sentence.\n';
cout << "First sentence." << endl;
In most program environments, the standard input by default is the keyboard, and the C++ stream object defined to access it is cin
.
For formatted input operations, cin
is used together with the extraction operator
, which is written as >>
(i.e., two greater than signs). The operator is then followed by the variable where the extracted data is stored.
int age;
cin >> age;
The first statement declares a variable of type int
called age
, and the second extracts from cin
a value to be stored in it.
This operation makes the program wait for input from cin
; generally, this means that the program will wait for the user to enter some sequence with the keyboard.
Extractions on cin can also be chained to request more than one datum in a single statement:
cin >> a >> b;
The extraction operator can be used on cin to get strings of characters in the same way as with fundamental data types:
string mystring;
cin >> mystring;
However, cin
extraction always considers spaces (whitespaces, tabs, new-line, ...
) as terminating the value being extracted, and thus extracting a string means to always extract a single word, not a phrase or an entire sentence.
To get an entire line from cin, there exists a function, called getline
, that takes the stream (cin
) as first argument, and the string variable as second.
Unless you have a strong reason not to, you should always use getline
to get input in your console programs instead of extracting from cin
.
The standard header defines a type called stringstream
that allows a string to be treated as a stream, and thus allowing extraction or insertion operations from/to strings in the same way as they are performed on cin
and cout
.
This feature is most useful to convert strings to numerical values and vice versa.