[Klaar] 5. Operators

[Laloeka]

Code: [Selecteer]

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 this page. Most details are only provided to serve as a later reference in case you need it.

<h3>Assignment (=)</h3>
The assignment operator assigns a value to a variable.

<sourcecode language="c++">
a = 5;
</sourcecode>

This statement assigns the integer value 5 to the variable <tt>a</tt>. The part at the left of the assignment operator (<tt>=</tt>) is known as the <i>lvalue</i> (left value) and the right one as the <i>rvalue</i> (right value). The lvalue has to be a variable whereas the rvalue 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 <i>right-to-left</i> rule: The assignment operation always takes place from right to left, and never the other way:

<sourcecode language="c++">
a = b;
</sourcecode>

This statement assigns to variable <tt>a</tt> (the lvalue) the value contained in variable <tt>b</tt> (the rvalue). The value that was stored until this moment in <tt>a</tt> 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 <tt>b</tt> to <tt>a</tt> at the moment of the assignment operation. Therefore a later change of <tt>b</tt> will not affect the new value of <tt>a</tt>.

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:

<sourcecode language="c++">
// assignment operator

#include <iostream>
using namespace std;

int main ()
{
int a, b; // a:?, b:?
a = 10; // a:10, b:?
b = 4; // a:10, b:4
a = b; // a:4, b:4
b = 7; // a:4, b:7

cout << "a:";
cout << a;
cout << " b:";
cout << b;

return 0;
}
-----
a:4 b:7
</sourcecode>

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

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

<sourcecode language="c++">
a = 2 + (b = 5);
</sourcecode>

is equivalent to:

<sourcecode language="c++">
b = 5;
a = 2 + b;
</sourcecode>

that means: first assign <tt>5</tt> to variable <tt>b</tt> and then assign to <tt>a</tt> the value <tt>2</tt> plus the result of the previous assignment of <tt>b</tt> (i.e. 5), leaving <tt>a</tt> with a final value of <tt>7</tt>.

The following expression is also valid in C++:

<sourcecode language="c++">
a = b = c = 5;
</sourcecode>

It assigns <tt>5</tt> to the all three variables: <tt>a</tt>, <tt>b</tt> and <tt>c</tt>.

<h3>Arithmetic operators ( +, -, *, /, % )</h3>
The five arithmetical operations supported by the C++ language are:

<table>
<tr><td>+</td><td>addition</td></tr>
<tr><td>-</td><td>subtraction</td></tr>
<tr><td>*</td><td>multiplication</td></tr>
<tr><td>/</td><td>division</td></tr>
<tr><td>%</td><td>modulo</td></tr>
</table>

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 <i>modulo</i>; whose operator is the percentage sign (<tt>%</tt>). Modulo is the operation that gives the remainder of a division of two values. For example, if we write:

<sourcecode language="c++">
a = 11 % 3;
</sourcecode>

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

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

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:

<table>
<tr><th>expression</th><th>is equivalent to</th></tr>
<tr><td><tt>value += increase;</tt></td><td><tt>value = value + increase;</tt></td></tr>
<tr><td><tt>a -= 5;</tt></td><td><tt>a = a - 5;</tt></td></tr>
<tr><td><tt>a /= b;</tt></td><td><tt>a = a / b;</tt></td></tr>
<tr><td><tt>price *= units + 1;</tt></td><td><tt>price = price * (units + 1);</tt></td></tr>
</table>

and the same for all other operators. For example:

<sourcecode language="c++">
// compound assignment operators

#include <iostream>
using namespace std;

int main ()
{
int a, b=3;
a = b;
a+=2; // equivalent to a=a+2
cout << a;
return 0;
}
-----
5
</sourcecode>

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

<sourcecode language="c++">
c++;
c+=1;
c=c+1;
</sourcecode>

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 (<tt>++a</tt>) or after it (<tt>a++</tt>). Although in simple expressions like <tt>a++</tt> or <tt>++a</tt> 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 <strong>before</strong> 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 (<tt>a++</tt>) 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:

<table>
<tr><th>Example 1</th><th>Example 2</th></tr>
<tr><td class="code"><tt>B=3;
A=++B;
// A contains 4, B contains 4</tt></td>
<td class="code"><tt>B=3;
A=B++;
// A contains 3, B contains 4</tt></td></tr>
</table>

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

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

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++:

<table>
<tr><td>==</td><td>Equal to</td></tr>
<tr><td>!=</td><td>Not equal to</td></tr>
<tr><td>></td><td>Greater than</td></tr>
<tr><td><</td><td>Less than</td></tr>
<tr><td>>=</td><td>Greater than or equal to</td></tr>
<tr><td><=</td><td>Less than or equal to</td></tr>
</table>

Here there are some examples:

<sourcecode language="c++">
(7 == 5) // evaluates to false.
(5 > 4) // evaluates to true.
(3 != 2) // evaluates to true.
(6 >= 6) // evaluates to true.
(5 < 5) // evaluates to false.
</sourcecode>

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

<sourcecode language="c++">
(a == 5) // evaluates to false since a is not equal to 5.
(a*b >= c) // evaluates to true since (2*3 >= 6) is true.
(b+4 > a*c) // evaluates to false since (3+4 > 2*6) is false.
((b=2) == a) // evaluates to true.
</sourcecode>

Be careful! The operator <tt>=</tt> (one equal sign) is not the same as the operator <tt>==</tt> (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 (<tt>==</tt>) 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 <tt>((b=2) == a)</tt>, we first assigned the value <tt>2</tt> to <tt>b</tt> and then we compared it to <tt>a</tt>, that also stores the value <tt>2</tt>, so the result of the operation is true.

<h3>Logical operators ( !, &&, || )</h3>

The Operator <tt>!</tt> 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:

<sourcecode language="c++">
!(5 == 5) // evaluates to false because the expression at its right (5 == 5) is true.
!(6 <= 4) // evaluates to true because (6 <= 4) would be false.
!true // evaluates to false
!false // evaluates to true.
</sourcecode>

The logical operators <tt>&&</tt> and <tt>||</tt> are used when evaluating two expressions to obtain a single relational result. The operator <tt>&&</tt> 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 <tt>&&</tt> evaluating the expression <tt>a && b</tt>:

<b>&& OPERATOR</b>
<table>
<tr><th>a</th><th>b</th><th>a && b</th></tr>
<tr><td>true</td><td>true</td><td>true</td></tr>
<tr><td>true</td><td>false</td><td>false</td></tr>
<tr><td>false</td><td>true</td><td>false</td></tr>
<tr><td>false</td><td>false</td><td>false</td></tr>
</table>

The operator <tt>||</tt> 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 <tt>a || b</tt>:

<b>|| OPERATOR</b>
<table>
<tr><th>a</th><th>b</th><th>a || b</th></tr>
<tr><td>true</td><td>true</td><td>true</td></tr>
<tr><td>true</td><td>false</td><td>true</td></tr>
<tr><td>false</td><td>true</td><td>true</td></tr>
<tr><td>false</td><td>false</td><td>false</td></tr>
</table>

For example:

<sourcecode language="c++">
( (5 == 5) && (3 > 6) ) // evaluates to false ( true && false ).
( (5 == 5) || (3 > 6) ) // evaluates to true ( true || false ).
</sourcecode>

<h3>Conditional operator ( ? )</h3>

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:

<tt>
condition ? result1 : result2
</tt>

If <tt>condition</tt> is true the expression will return <tt>result1</tt>, if it is not it will return <tt>result2</tt>.

<sourcecode language="c++">
7==5 ? 4 : 3 // returns 3, since 7 is not equal to 5.
7==5+2 ? 4 : 3 // returns 4, since 7 is equal to 5+2.
5>3 ? a : b // returns the value of a, since 5 is greater than 3.
a>b ? a : b // returns whichever is greater, a or b.
</sourcecode>

<sourcecode language="c++">
// conditional operator

#include <iostream>
using namespace std;

int main ()
{
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;

cout << c;

return 0;
}
-----
7
</sourcecode>

In this example <tt>a</tt> was <tt>2</tt> and <tt>b</tt> was <tt>7</tt>, so the expression being evaluated (<tt>a>b</tt>) 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 <tt>b</tt>, with a value of <tt>7</tt>.

<h3>Comma operator ( , )</h3>
The comma operator (<tt>,</tt>) 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:

<sourcecode language="c++">
a = (b=3, b+2);
</sourcecode>

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

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

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

<table>
<tr><th>operator</th><th>asm equivalent</th><th>description</th></tr>
<tr><td><tt>&</tt></td><td>AND</td><td>Bitwise AND</td></tr>
<tr><td><tt>|</tt></td><td>OR</td><td>Bitwise Inclusive OR</td></tr>
<tr><td><tt>^</tt></td><td>XOR</td><td>Bitwise Exclusive OR</td></tr>
<tr><td><tt>~</tt></td><td>NOT</td><td>Unary complement (bit inversion)</td></tr>
<tr><td><tt><<</tt></td><td>SHL</td><td>Shift Left</td></tr>
<tr><td><tt>>></tt></td><td>SHR</td><td>Shift Right</td></tr>
</table>

<h3>Explicit type casting operator</h3>
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 (<tt>()</tt>):

<sourcecode language="c++">
int i;
float f = 3.14;
i = (int) f;
</sourcecode>

The previous code converts the float number <tt>3.14</tt> to an integer value (<tt>3</tt>), the remainder is lost. Here, the typecasting operator was <tt>(int)</tt>. 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:

<sourcecode language="c++">
i = int ( f );
</sourcecode>

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

<h3>sizeof()</h3>
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:

<sourcecode language="c++">
a = sizeof (char);
</sourcecode>

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

<h3>Other operators</h3>
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.

<h3>Precedence of operators</h3>
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:

<sourcecode language="c++">
a = 5 + 7 % 2
</sourcecode>

we may doubt if it really means:

<sourcecode language="c++">
a = 5 + (7 % 2) // with a result of 6, or
a = (5 + 7) % 2 // with a result of 0
</sourcecode>

The correct answer is the first of the two expressions, with a result of <tt>6</tt>. 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 is as follows:

<table>
<tr><th>Level</th><th>Operator</th><th>Description</th><th>Grouping</th></tr>
<tr><td>1</td><td><tt>::</tt></td><td>scope</td><td>Left-to-right</td></tr>
<tr><td>2</td><td><tt>() [] . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid</tt></td><td>postfix</td><td>Left-to-right</td></tr>
<tr><td rowspan="3">3</td><td><tt>++ -- ~ ! sizeof new delete</tt></td><td>unary (prefix)</td><td rowspan="3">Right-to-left</td></tr>
<tr><td><tt>* &</tt></td><td>indirection and reference (pointers)</td></tr>
<tr><td><tt>+ -</tt></td><td>unary sign operator</td></tr>
<tr><td>4</td><td><tt>(type)</tt></td><td>type casting</td><td>Right-to-left</td></tr>
<tr><td>5</td><td><tt>.* ->*</tt></td><td>pointer-to-member</td><td>Left-to-right</td></tr>
<tr><td>6</td><td><tt>* / %</tt></td><td>multiplicative</td><td>Left-to-right</td></tr>
<tr><td>7</td><td><tt>+ -</tt></td><td>additive</td><td>Left-to-right</td></tr>
<tr><td>8</td><td><tt><< >></tt></td><td>shift</td><td>Left-to-right</td></tr>
<tr><td>9</td><td><tt>< > <= >=</tt></td><td>relational</td><td>Left-to-right</td></tr>
<tr><td>10</td><td><tt>== !=</tt></td><td>equality</td><td>Left-to-right</td></tr>
<tr><td>11</td><td><tt>&</tt></td><td>bitwise AND</td><td>Left-to-right</td></tr>
<tr><td>12</td><td><tt>^</tt></td><td>bitwise XOR</td><td>Left-to-right</td></tr>
<tr><td>13</td><td><tt>|</tt></td><td>bitwise OR</td><td>Left-to-right</td></tr>
<tr><td>14</td><td><tt>&&</tt></td><td>logical AND</td><td>Left-to-right</td></tr>
<tr><td>15</td><td><tt>||</tt></td><td>logical OR</td><td>Left-to-right</td></tr>
<tr><td>16</td><td><tt>?:</tt></td><td>conditional</td><td>Right-to-left</td></tr>
<tr><td>17</td><td><tt>= *= /= %= += -= >>= <<= &= ^= |=</tt></td><td>assignment</td><td>Right-to-left</td></tr>
<tr><td>18</td><td><tt>,</tt></td><td>comma</td><td>Left-to-right</td></tr>
</table>

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 <tt>(</tt> and <tt>)</tt>, as in this example:

<sourcecode language="c++">
a = 5 + 7 % 2;
</sourcecode>

might be written either as:

<sourcecode language="c++">
a = 5 + (7 % 2);
</sourcecode>
or
<sourcecode language="c++">
a = (5 + 7) % 2;
</sourcecode>

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 make your code easier to read.

[marcoo]

Code: [Selecteer]

Nu we weten van het bestaan van variabelen en constanten, kunnen we beginnen met het werken met variabelen en constanten. Speciaal voor dat doel zitten er in C++ operators. In tegenstelling tot andere programmeertalen waar operators voornamelijk woorden zijn, zijn operators in C++ meestal tekens die niet in het alfabet zitten. Het zijn tekens die op ieder toetsenbord aanwezig zijn. Dit maakt de C++ code korter en meer internationaal, omdat er minder Engelse woorden inzitten, maar het vereist wat inspanning aan het begin.

Je hoeft niet de hele inhoud van deze pagina te onthouden. De meeste gegevens zijn alleen bedoeld om te dienen als naslagwerk voor het geval je het nodig hebt.

In C++ zitten zogenaamde <tt>assignment operators</tt>. Dit is Engels voor ?opdracht exploitant?. De operator (de exploitant) voert een opdracht (assignment) uit. In deze tutorial zal gebruik gemaakt worden van de Engelse term.

<h3>Assignment (=)</h3>
De assignment operator geeft een waarde aan een variabele.

<sourcecode language="c++">
a = 5;
</sourcecode>

De assignment = geeft hier de waarde 5 aan de integer <tt>a</tt>. Het deel links van de assignment operator (<tt>=</tt>) staat bekend als de <i>lwaarde</i> (linker waarde) en het rechter deel staat bekend als de <i>rwaarde</i> (rechter waarde). De lwaarde moet een variabele zijn, terwijl de rwaarde een constante, een variabele, het resultaat van een berekening, of een combinatie van deze kan zijn.
De belangrijkste regel bij het toewijzen is de <i>rechts-naar-links</i> regel: De assignment operator vindt altijd plaats van rechts naar links, en nooit andersom:


<sourcecode language="c++">
a = b;
</sourcecode>

Deze verklaring geeft de variabele <tt>a</tt> (de lwaarde) de waarde in de variabele <tt>b</tt> (de rwaarde). De waarde die werd opgeslagen in <tt>a</tt> is niet belangrijk, want eigenlijk is deze waarde verloren gegaan.

Bedenk ook dat we alleen de waarde van <tt>b</tt> aan <tt>a</tt> geven op het moment dat de assignment operator wordt aangeroepn. Daarom heeft een latere verandering van <tt>b</tt> geen invloed op de nieuwe waarde van <tt>a</tt>.

Laten we bijvoorbeeld eens kijken naar de volgende code ? Ook de verandering van de inhoud, opgeslagen in de variabelen, is weergegeven als commentaar:

<sourcecode language="c++">
// assignment operator

#include <iostream>
using namespace std;

int main ()
{
int a, b; // a:?, b:?
a = 10; // a:10, b:?
b = 4; // a:10, b:4
a = b; // a:4, b:4
b = 7; // a:4, b:7

cout << "a:";
cout << a;
cout << " b:";
cout << b;

return 0;
}
-----
a:4 b:7
</sourcecode>

Deze code code geeft als resultaat dat de waarde van <tt>a</tt> is <tt>4</tt> en de waarde van <tt>b</tt> is <tt>7</tt>. Merk op dat de waarde van <tt>a</tt> niet veranderd werd door de laatste verandering van <tt>b</tt>, ook al hebben we eerder <tt>a = b</tt> getypt (dit is vanwege de <i>rechts-naar-links</i> regel).

Een eigenschap van C++ ten opzichte van andere programmeertalen is dat de assignment operator kan worden gebruikt als rwaarde (of een deel van de rwaarde) voor een andere assignment operation. Bijvoorbeeld:

<sourcecode language="c++">
a = 2 + (b = 5);
</sourcecode>

Is hetzelfde als:

<sourcecode language="c++">
b = 5;
a = 2 + b;
</sourcecode>

Dat betekend: eerst wijzen we <tt>5</tt> toe aan de variabele <tt>b</tt> en vervolgens wijzen we aan de variabele <tt>a</tt> de waarde <tt>2</tt> plus het resultaat van de vorige assignment van <tt>b</tt> (5) toe, en <tt>a</tt> heeft als eindwaarde dus <tt>7</tt>.

De volgende expressie is ook geldig in C++:

<sourcecode language="c++">
a = b = c = 5;
</sourcecode>

Dit wijst de waarde <tt>5</tt> toe aan de volgende drie variabelen: <tt>a</tt>, <tt>b</tt> en <tt>c</tt>.

<h3>Rekenkundige operators (+, -, *, /, % )</h3>
De vijf rekenkundige operators die ondersteund worden in C++ zijn:

<table>
<tr><td>+</td><td>optelling</td></tr>
<tr><td>-</td><td>aftrekking</td></tr>
<tr><td>*</td><td>vermenigvuldiging</td></tr>
<tr><td>/</td><td>delen</td></tr>
<tr><td>%</td><td>modulo</td></tr>
</table>

Operations van optelling, aftrekking, vermenigvuldiging en deling komen letterlijk overeen met hun wiskunde operators. De enige die u misschien niet bij wiskunde gebruikt is <i>modulo</i>; wiens operator het percentage teken (<tt>%</tt>) is. Modulo is de operation die de rest van een deling van twee waarden geeft. Bijvoorbeeld:

<sourcecode language="c++">
a = 11 % 3;
</sourcecode>

The variabele <tt>a</tt> zal de waarde <tt>2</tt> bevatten, want <tt>2</tt> is de rest van de deling van <tt>11</tt> tussen <tt>3</tt>.

<h3> Samengestelde assignments (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)</h3>

Als we de waarde van een variabele willen wijzigen door het uitvoeren van een operation aan de waarde die momenteel opgeslagen is, kunnen we de volgende samengestelde assignments operators gebruiken.

<table>
<tr><th>uitdrukking</th><th>is hetzelfde als</th></tr>
<tr><td><tt>waarde += toename;</tt></td><td><tt>waarde = waarde + toename;</tt></td></tr>
<tr><td><tt>a -= 5;</tt></td><td><tt>a = a - 5;</tt></td></tr>
<tr><td><tt>a /= b;</tt></td><td><tt>a = a / b;</tt></td></tr>
<tr><td><tt>prijs *= eenheden + 1;</tt></td><td><tt>prijs = prijs * (eenheden + 1);</tt></td></tr>
</table>

Hetzelfde geldt voor de andere operators. Bijvoorbeeld:
<sourcecode language="c++">
// samengestelde assignment operators

#include <iostream>
using namespace std;

int main ()
{
int a, b=3;
a = b;
a+=2; // hetzelfde als: a=a+2
cout << a;
return 0;
}
-----
5
</sourcecode>

<h3>Toename en afname (++, --)</h3>
Verkorting van nog een aantal expressions, de toename operator (<tt>++</tt>) en de afname operator (<tt>--</tt>) verhogen of verlagen een waarde die is opgeslagen in een variabele. Ze zijn hetzelfde als <tt>+=1</tt> en als <tt>--</tt>. Dus:

<sourcecode language="c++">
c++;
c+=1;
c=c+1;
</sourcecode>

zijn allemaal hetzelfde in hun functionaliteit: alle drie verhogen de waarde van c met 1.

In het begin van de C compilers, de drie eerder expressions werden waarschijnlijk verschillende uitvoerbare codes, afhankelijk van het type compiler. Tegenwoordig word dit type van code optimalisatie doorgaans automatisch gedaan door de compiler, dus de drie expressions zouden exact dezelfde uitvoerbare code moeten produceren.

Een kenmerk van deze operator is dat het gebruik kan worden als voorvoegsel en achtervoegsel. Dat betekend dat het geschreven kan worden voor of na het variabele id (<tt>++a</tt> of <tt>a++</tt>). In eenvoudige expressions als <tt>++a</tt> of <tt>a++</tt> betekenen beide exact hetzelfde. In andere expressions waarin het resultaat van de toename of afname van belang is om andere variabelen van waarde veranderen, kunnen ze een belangrijk verschil hebben. Als de toename operator het voorvoegsel is (<tt>++a</tt>), wordt de waarde verhoogd <strong>voordat</strong> het resultaat van de andere waarde is veranderd. In het geval dat de toename operator het achtervoegsel is (<tt>a++</tt>), wordt de waarde van a verhoogd <strong>nadat</strong> de andere waarde veranderd. Let op het verschil:

<table>
<tr><th>Voorbeeld 1</th><th>Voorbeeld 2</th></tr>
<tr><td class="code"><tt>B=3;
A=++B;
// A heeft waarde 4, B heeft waarde 4</tt></td>
<td class="code"><tt>B=3;
A=B++;
// A heeft waarde 3, B heeft waarde 4</tt></td></tr>
</table>

In Voorbeeld 1, <tt>B</tt> wordt verhoogd voordat de waarde gekopieerd wordt naar <tt>A</tt>. Terwijl in Voorbeeld 2 de waarde van <tt>B</tt> gekopieerd wordt naar <tt>A</tt> en dan wordt <tt>B</tt> verhoogd.

<h3>Relationele en gelijkheid operators ( ==, !=, >, <, >=, <= )</h3>

Om een vergelijking tussen twee expressions te maken, maken we gebruik van de relationele en gelijkheid operators. Het resultaat van de relationele operator is en Boolean waarde die alleen true (waar) of false (niet waar) kan bevatten. Dit is afhankelijk van het resultaat.

We willen misschien twee expressions vergelijken om te weten of ze hetzelfde zijn of als er een groter is als de andere. Hier is een lijst van relationele operators die in C++ gebruikt kunnen worden:


<table>
<tr><td>==</td><td>Hetzelfde als</td></tr>
<tr><td>!=</td><td>Niet hetzelfde als</td></tr>
<tr><td>></td><td>Groter dan</td></tr>
<tr><td><</td><td>Kleiner dan</td></tr>
<tr><td>>=</td><td>Groter dan of gelijk aan</td></tr>
<tr><td><=</td><td>Kleiner dan of gelijk aan</td></tr>
</table>

Hier zijn een aantal voorbeelden:

<sourcecode language="c++">
(7 == 5) // geeft false.
(5 > 4) // geeft true.
(3 != 2) // geeft true.
(6 >= 6) // geeft true.
(5 < 5) // geeft false.
</sourcecode>

Natuurlijk kunnen we in plaats van numerieke constantan, ook gebruik maken van geldige expressions, inclusief variabelen. Stel dat <tt>a=2</tt>, <tt>b=3</tt> en <tt>c=6</tt>:

<sourcecode language="c++">
(a == 5) // geeft false want a is niet hetzelfde als 5.
(a*b >= c) // geeft true want (2*3 >= 6) is waar.
(b+4 > a*c) // geeft false want (3+4 > 2*6) is niet waar.
((b=2) == a) // geeft true.
</sourcecode>

Wees voorzichtig! De operator <tt>=</tt> (één gelijk teken) is niet hetzelfde als de operator <tt>==</tt> (twee gelijk tekens). De eerste is een assignment operator (wijst de rechter waarde toe aan de linker variabele) en de andere (<tt>==</tt>) is de gelijkheid operator die kijkt of twee expressions hetzelfde zijn. Zo is in de laatste expression <tt>((b=2)==a</tt>, eerst de waarde <tt>2</tt> aan de variabele <tt>b</tt> gegeven, en toen keken we of dat hetzelfde was als <tt>a</tt>, die ook de waarde <tt>2</tt> had, waardoor het resultaat van de operation true (waar) was.

<h3>Logische operators ( !, &&, || )</h3>

De operator <tt>!</tt> is de C++ operator aan de Boolean operation NOT, het heeft slechts één operand, gelegen aan de rechterkant. Het enige wat het doet is de waarde omkeren. Het geeft false als de operand true is, en het geeft true als de operand false is. Kortom, het geeft de tegenovergestelde Booleanse waarde van de operand. Bijvoorbeeld:

<sourcecode language="c++">
!(5 == 5) // geeft false want de expression rechts (5 == 5) is waar.
!(6 <= 4) // geeft true want (6 <= 4) is niet waar.
!true // geeft false
!false // geeft true.
</sourcecode>

De logische operatoren <tt>&&</tt> en <tt>||</tt> worden gebruikt bij het bekijken van twee expressions om een relationeel resultaat te krijgen. De operator <tt>&&</tt> komt overeen met de Boolean logische operation AND. Deze operation geeft als resultaat true (waar) als beide operands true zijn, en false als dat niet zo is. De volgende tabel toont het resultaat van de operator <tt>&&</tt>, als gevolg van de expression <tt>a && b</tt>:

<b>&& OPERATOR</b>
<table>
<tr><th>a</th><th>b</th><th>a && b</th></tr>
<tr><td>true</td><td>true</td><td>true</td></tr>
<tr><td>true</td><td>false</td><td>false</td></tr>
<tr><td>false</td><td>true</td><td>false</td></tr>
<tr><td>false</td><td>false</td><td>false</td></tr>
</table>

De operator <tt>||</tt> komt overeen met de Boolean logische operation OR. Deze operator geeft als resultaat true als één van de waarden true is. Het geeft dus false als beide waarden false zijn. Hier zijn de mogelijke resultaten van <tt>a || b</tt>:

<b>|| OPERATOR</b>
<table>
<tr><th>a</th><th>b</th><th>a || b</th></tr>
<tr><td>true</td><td>true</td><td>true</td></tr>
<tr><td>true</td><td>false</td><td>true</td></tr>
<tr><td>false</td><td>true</td><td>true</td></tr>
<tr><td>false</td><td>false</td><td>false</td></tr>
</table>

Bijvoorbeeld:

<sourcecode language="c++">
( (5 == 5) && (3 > 6) ) // geeft false ( true && false ).
( (5 == 5) || (3 > 6) ) // geeft true ( true || false ).
</sourcecode>

<h3>Condition operator ( ? )</h3>

De condition operator geeft een waarde als de expression true is, en het geeft een andere waarde als de expression false is. Het ziet eruit als:

<tt>
condition ? resultaat1 : resultaat2
</tt>

Als <tt>condition</tt> true is, de expression zal <tt>resultaat1</tt> geven, als <tt>condition</tt> false is, zal de expression <tt>resultaat2</tt> geven.

<sourcecode language="c++">
7==5 ? 4 : 3 // geeft 3, want 7 is niet hetzelfde als 5.
7==5+2 ? 4 : 3 // geeft 4, want 7 is hetzelfde als 5+2.
5>3 ? a : b // geeft de waarde van a, want 5 is groter dan 3.
a>b ? a : b // geeft terug wat groter is, a of b.
</sourcecode>

<sourcecode language="c++">
// conditional operator

#include <iostream>
using namespace std;

int main ()
{
int a,b,c;

a=2;
b=7;
c = (a>b) ? a : b;

cout << c;

return 0;
}
-----
7
</sourcecode>

In dit voorbeeld was <tt>a 2</tt> en <tt>b</tt> was <tt>7</tt>. De expression wordt doorlopen (<tt>a>b</tt>) en was niet waar, dus de eerste waarde werd weggegooid, en de tweede waarde (de ene na de dubbele punt) werd door de functie teruggegeven. Dat was <tt>b</tt> met als waarde <tt>7</tt>.

<h3>Comma operator ( , )</h3>
De comma operator (<tt>,</tt>) wordt gebruikt om twee of meer expressions die zijn opgenomen waar slechts een expression wordt verwacht, te scheiden. Wanneer de set van expressions een waarde moet krijgen, wordt alleen de meest rechtse expression gebruikt.

Bijvoorbeeld de volgende code:

<sourcecode language="c++">
a = (b=3, b+2);
</sourcecode>

Eerst geven we de waarde <tt>3</tt> aan de variabele <tt>b</tt>, en dan geven we <tt>b+2</tt> aan de variabele <tt>a</tt>. Aan het eind, de variabele <tt>a</tt> bevat de waarde <tt>5</tt>, terwijl de variabele <tt>b</tt> de waarde <tt>3</tt> bevat.

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

Bitwise operators wijzigen variabelen gelet op het bitpatroon die de waarden opslaan die ze vertegenwoordigen.

<table>
<tr><th>operator</th><th>asm gelijkwaardig</th><th>beschrijving</th></tr>
<tr><td><tt>&</tt></td><td>AND</td><td>Bitwise AND</td></tr>
<tr><td><tt>|</tt></td><td>OR</td><td>Bitwise Inclusive OR</td></tr>
<tr><td><tt>^</tt></td><td>XOR</td><td>Bitwise Exclusive OR</td></tr>
<tr><td><tt>~</tt></td><td>NOT</td><td>Unary complement (bit omdraaiing)</td></tr>
<tr><td><tt><<</tt></td><td>SHL</td><td>Shift Links</td></tr>
<tr><td><tt>>></tt></td><td>SHR</td><td>Shift Rechts</td></tr>
</table>

<h3>Expliciete type casting operator</h3>
Met type casting operators kunt u een waarde van een bepaald type converteren naar een ander type. Er zijn verschillende manieren om dit in C++ te doen. De eenvoudigste is, die is overgenomen uit C, is de uitdrukking vooraf om te zetten door het nieuwe type tussen haakjes (<tt>()</tt>) te zetten:

<sourcecode language="c++">
int i;
float f = 3.14;
i = (int) f;
</sourcecode>

De vorige code converteert het nummer <tt>3.14</tt> van het type float naar de integer waarde (<tt>3</tt>), de rest is verloren. Hier was de type casting operator <tt>(int</tt>. Een andere manier om precies hetzelfde te doen in C++ is het gebruiken van de functionele notatie: je typt gewoon het type waarnaar het geconverteerd moet worden, en het nummer dat geconverteerd moet worden, zet je tussen haakjes:

<sourcecode language="c++">
i = int ( f );
</sourcecode>

Beide manieren van type casting zijn geldig in C++

<h3>sizeof()</h3>
Deze operator accepteert maar één parameter, die kan bestaan uit een type of uit een variabele. Deze functie geeft het aantal bytes van het type of variabele:

<sourcecode language="c++">
a = sizeof (char);
</sourcecode>

Deze code zal <tt>a</tt> de waarde <tt>1</tt> geven, omdat een <tt>char</tt> slechts één byte lang is.
De waarde die <tt>sizeof</tt> teruggeeft is een constante, dus het is altijd bepaald v??r de uitvoering van het programma.

<h3>Andere operators</h3>
Later in deze tutorials zullen we nog een paar operators tegenkomen, zoals die met betrekking tot pointersof de specifieke voor object-geori?nteerd programmeren. Ieder wordt behandeld in de respectievelijke sectie.

<h3>Hi?rarchie in operators</h3>
Bij het schrijven van complexe expressions met meerdere operanden, kunnen we enkele twijfels krijgen over welke operand eerst gebruikt wordt, en welke later. Zoals bijvoorbeeld in de volgende expression:

<sourcecode language="c++">
a = 5 + 7 % 2
</sourcecode>

We kunnen twijfelen wat het werkelijk betekent:

<sourcecode language="c++">
a = 5 + (7 % 2) // met als resultaat 6, of
a = (5 + 7) % 2 // met als resultaat 0
</sourcecode>

Het juiste antwoord is de eerste van de twee expressions, met als resultaat <tt>6</tt>. Er is een bepaalde hi?rarchie tussen de operators, en niet alleen voor de wiskunde, maar voor alle operators die voor kunnen komen in C++. Van de hoogste tot de laagste prioriteit is de rangorde als volgt:

<table>
<tr><th>Prioriteit</th><th>Operator</th><th>Beschrijving</th><th>Groepering</th></tr>
<tr><td>1</td><td><tt>::</tt></td><td>scope</td><td>Links-naar-rechts</td></tr>
<tr><td>2</td><td><tt>() [] . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid</tt></td><td>postfix</td><td> Links-naar-rechts </td></tr>
<tr><td rowspan="3">3</td><td><tt>++ -- ~ ! sizeof new delete</tt></td><td>unary (prefix)</td><td rowspan="3">Rechts-naar-links</td></tr>
<tr><td><tt>* &</tt></td><td>indirection and reference (pointers)</td></tr>
<tr><td><tt>+ -</tt></td><td>unary sign operator</td></tr>
<tr><td>4</td><td><tt>(type)</tt></td><td>type casting</td><td> Rechts-naar-links </td></tr>
<tr><td>5</td><td><tt>.* ->*</tt></td><td>pointer-to-member</td><td>Links-naar-rechts </td></tr>
<tr><td>6</td><td><tt>* / %</tt></td><td>multiplicative</td><td>Links-naar-rechts </td></tr>
<tr><td>7</td><td><tt>+ -</tt></td><td>additive</td><td>Links-naar-rechts </td></tr>
<tr><td>8</td><td><tt><< >></tt></td><td>shift</td><td>Links-naar-rechts </td></tr>
<tr><td>9</td><td><tt>< > <= >=</tt></td><td>relational</td><td>Links-naar-rechts </td></tr>
<tr><td>10</td><td><tt>== !=</tt></td><td>equality</td><td>Links-naar-rechts </td></tr>
<tr><td>11</td><td><tt>&</tt></td><td>bitwise AND</td><td>Links-naar-rechts </td></tr>
<tr><td>12</td><td><tt>^</tt></td><td>bitwise XOR</td><td>Links-naar-rechts </td></tr>
<tr><td>13</td><td><tt>|</tt></td><td>bitwise OR</td><td>Links-naar-rechts </td></tr>
<tr><td>14</td><td><tt>&&</tt></td><td>logical AND</td><td>Links-naar-rechts </td></tr>
<tr><td>15</td><td><tt>||</tt></td><td>logical OR</td><td>Links-naar-rechts </td></tr>
<tr><td>16</td><td><tt>?:</tt></td><td>conditional</td><td> Rechts-naar-links </td></tr>
<tr><td>17</td><td><tt>= *= /= %= += -= >>= <<= &= ^= |=</tt></td><td>assignment</td><td> Rechts-naar-links </td></tr>
<tr><td>18</td><td><tt>,</tt></td><td>comma</td><td>Links-naar-rechts </td></tr>
</table>

Groepering bepaald de volgorde van prioriteit waarin de operators worden gebruikt in het geval dat meerdere operators van dezelfde prioriteit in één expression zitten.

All deze hi?rarchie niveaus voor operators kunnen worden gemanipuleerd of worden beter leesbaar door het wegnemen van onduidelijkheden of het gebruik van haakjes <tt>(</tt> en <tt>)</tt>, zoals in het onderstaande voorbeeld:

<sourcecode language="c++">
a = 5 + 7 % 2;
</sourcecode>

Dit kan ook geschreven worden als:

<sourcecode language="c++">
a = 5 + (7 % 2);
</sourcecode>
of als:
<sourcecode language="c++">
a = (5 + 7) % 2;
</sourcecode>

Dit is afhankelijk van de operation die we willen uitvoeren.

Als je ingewikkelde expressions wilt schrijven en je bent niet helemaal zeker van de hi?rarchie, gebruik dan altijd haakjes. Dit zal ook helpen bij het makkelijker lezen van uw code.


[Laloeka]

[Deze is voor mij] (7-2 of 8-2)

Je bent er mee bezig bedoel je?
Dat is mooi

[marcoo]

Ja, ik ben bezig. Ik post hem morgen of overmorgen.

[marcoo]

Gepost

[marcoo]

Niemand bezwaren Dat lijkt me namelijk vreemd, want er zitten nog flink wat Engelse termen in, waarvan ik de Nederlandse term niet ken.

[Divendo]

Assignment operators kun je beter vertalen als 'toekennings operatoren', omdat je een waarde ergens aan toekent.
Verder goed dat je in de rest van de tutorial de Engelse term hanteert.
Misschien dat je dit voor lwaarde en rwaarde ook beter kan doen, dus daar gewoon de term lvalue en rvalue hanteren.
Alleen dan wel bij die eerste keer er achter zetten "(linker waarde)" en "(rechter waarde)" zoals er nu ook al staat

Ik heb even niet verder kunnen lezen dan het 3e stukje sourcode, maar nu heb iig wat om te verbeteren

[Laloeka]

Deze code code geeft als resultaat dat de waarde van..

2x code

Value heb ik telkens wel vertaald met 'waarde', omdat dat logischer klinkt in een nederlandse tekst, maar dat is aan jou.

<table>
<tr><td>+</td><td>optelling</td></tr>
<tr><td>-</td><td>aftrekking</td></tr>
<tr><td>*</td><td>vermenigvuldiging</td></tr>
<tr><td>/</td><td>delen</td></tr>
<tr><td>%</td><td>modulo</td></tr>
</table>

Operations van optelling, aftrekking, vermenigvuldiging en deling komen [...]  is <i>modulo</i>; wiens [...]

Misschien passen: Optellen, aftrekken, vermenigvuldigen, delen en rest (want modulo is toch de 'rest' na een deling?, de term modulo ken ik verder niet in het Nederlands)?

[Divendo]

Modulo is idd rest.
Het normale woord 'value' moet ook vertaald worden met waarde, maar lvalue en rvalue zijn meer een soort term.
En ik ken daar niet echt een Nederlandse term voor.
Volgens mij werd in mijn boeken ook lvalue en rvalue gebruikt, maar werd de eerste keer wel uitgelegd dat de een linker-waarde is en de ander rechter-waarde.

[marcoo]

<table>
<tr><td>+</td><td>optelling</td></tr>
<tr><td>-</td><td>aftrekking</td></tr>
<tr><td>*</td><td>vermenigvuldiging</td></tr>
<tr><td>/</td><td>delen</td></tr>
<tr><td>%</td><td>modulo</td></tr>
</table>

Operations van optelling, aftrekking, vermenigvuldiging en deling komen [...]  is <i>modulo</i>; wiens [...]

Misschien passen: Optellen, aftrekken, vermenigvuldigen, delen en rest (want modulo is toch de 'rest' na een deling?, de term modulo ken ik verder niet in het Nederlands)?

Nee, modulo doet het volgende: het haalt steeds de de rwaarde van de lwaarde af, tot de lwaarde kleiner is dan de rwaarde. 2%2 is dus 0 (want lwaarde is niet kleiner dan rwaarde), en 3%2 is 1 (want 3 is groter dan 2, dus doe je 3-2 = 1. 1 is kleiner dan 2), en 456%360 is 96 (bijvoorbeeld voor de richting in graden).

[Divendo]

<table>
<tr><td>+</td><td>optelling</td></tr>
<tr><td>-</td><td>aftrekking</td></tr>
<tr><td>*</td><td>vermenigvuldiging</td></tr>
<tr><td>/</td><td>delen</td></tr>
<tr><td>%</td><td>modulo</td></tr>
</table>

Operations van optelling, aftrekking, vermenigvuldiging en deling komen [...]  is <i>modulo</i>; wiens [...]

Misschien passen: Optellen, aftrekken, vermenigvuldigen, delen en rest (want modulo is toch de 'rest' na een deling?, de term modulo ken ik verder niet in het Nederlands)?

Nee, modulo doet het volgende: het haalt steeds de de rwaarde van de lwaarde af, tot de lwaarde kleiner is dan de rwaarde. 2%2 is dus 0 (want lwaarde is niet kleiner dan rwaarde), en 3%2 is 1 (want 3 is groter dan 2, dus doe je 3-2 = 1. 1 is kleiner dan 2), en 456%360 is 96 (bijvoorbeeld voor de richting in graden).

Wat jij nu omschrijft is precies wat rest betekent
Want als je niet met kommagetallen werkt (wat zo is bij een char, short, int of long) dan is 3/2 gelijk aan 1. Maar dan hou je nog 1 van die 3 over, dat heet rest.
In het geval van 456%360,  past 360 1x in 456. Dan blijft er 96 over en dat noem je 96.
Ander voorbeeldje: 102%10 = 2, want 10 past 10x in 102, dan blijft er 2 over.
In formule vorm: a % b = a-floor(a / b)*b

[marcoo]

Dan snap ik rest niet

[Divendo]

Dan snap ik rest niet

Dat is dus eigenlijk wat jij had uitgelegd en wat ik ook had uitgelegd (die 2 dingen zijn wiskundig hetzelfde).
Weer wat geleerd lijkt me

[Laloeka]

10 gedeeld door 6 = 1 rest 4, basis-school manier.
We hebben nu geleerd dat 10 gedeeld door 6,  1²/₃ is, want 4/6 = ²/₃.
Als je dus de rest wilt weten moet je weer gaan delen op de basis-school manier(, staartdelingen?) zodat je de rest overhoud

Laten we het hier bij laten qua 'rest'

[BlueMoonProductions]

Even een klein vraagje tussendoor..

a = 2 + (b = 5);

Is hetzelfde als:

b = 5;
a = 2 + b;

Hu? De eerste lijkt me 2 te geven als b geen 5 is, en 3 als b wel 5 is((b=5) returnt toch true/false?), en de tweede 7?