In a previous video, we introduced the conditional branch instruction, the if. We also saw that in order to work, this instruction needs to express conditions. The conditions we used until now were simple conditions, which consisted of, for example, comparing the value of a variable with a value. We are now going to see that in C++, it is possible to express more complex conditions. Here you see an example of a condition branch instructions, an if, as we have already seen previously. We can see that in order to write down this instruction, we need to formulate a condition, as we can concretely see here. The condition in the present case is a simple condition, which consist in comparing the value of a variable n to the value 5. Small syntactic detail : the condition in a conditional branch instruction is always surrounded by parentheses, as we can concretely see here. A condition in C++ is in fact a sort of expression whose particularity is to return two possible values. These values are either "true", or "false". Simply enough, a condition will be evaluated to "true" when it is true, and evaluated to "false" when it is false. Let's take a concrete example. Let's imagine I have a variable n whose value is zero, and I write the condition n smaller than five, that I want to evaluate. Here the value of n, zero, is less than 5, which means that this condition is true when I evaluate it it will therefore return the value "true". Now let's imagine n has a value of 10. I evaluate the same expression. Obviously this isn't verified anymore, the condition is false, therefore the evaluation of the condition will return the value "false". Let's begin by examining in a more exhaustive way how to formulate simple conditions in C++. The purpose of a simple condition is to compare two expressions. and to do so we need to use comparison operators. "Less than", "greater than" are two examples which you already had the opportunity to see before. So obviously C++ offers a whole range of predefined operators to formulate simple conditions. Let's imagine for example that I have two variables x, y. I want to know if the value of x is less than the value of y. Naturally, I'm going to use the "less than" operator and write my condition like so. Similarly, if I want to know if the value of x is equal to the value of y, I am going to use the comparison operator ==, which lets me test this condition. You have the operators "less than or equal", "greater or equal", and "different than", which let you express all sorts of simple conditions. Here's a little warning : in C++, the operator used to check if two values are equal is defined by two "equal" symbols. Don't confuse it with the = symbol, which is used to formulate an assignment. If I want to check if the value of a variable n is 5, I'm going to use the operator == to formulate my condition, and not the simple equal operator. You must be aware however that this way of writing a condition is considered licit by C++ compilers, we are going to examine why in the next slide. Licit indeed, yet discouraged, at this stage of learning at least. What you must know is that in C++, every expression whatsoever does something, but also has a value. Let's examine this wtih a concrete example. Here we have an expression, n = 5, this expression clearly does something. What it does is assigning to a variable n the value 5. In C++, this expression also has a value. It's value is the the value of n after the assignment. Thus, the expression "n = 5" has value 5. That is why it is perfectly licit to write something like this : m = n = 5, 5, which aims to assign to a variable m the value of this expression, that is 5. It is therefore totally correct to write something like this : "if (n = 5)" which is the same as writing "if (5)". Knowing that in C++, every non-zero value is equivalent to "true", this condition will always be evaluated as true. Note that in terms of best practices, it is totally discouraged to do it this way. I have shown you this in detail and explicitly only because to confuse == and = to perform a comparison is a mistake beginners often make. So in absolute, this way of doing it is to avoid, even if it is tolerated by the compiler. Now let's illustrate the use of simple conditions in C++ on small examples. Here we have a small program that begins by declaring two variables a and b and affects initial values to them, respectively 1 and 2. We then encounter a conditional branch instruction, which tests if the value of a is the same as the value of b with a simple condition. This is done with the comparison operator ==. Since this condition isn't verified, the result of the condition's evaluation will be the value "false", which will result in branching the execution on the else block of the if instruction, therefore causing to print the message "cas 2", which we can see here. We then continue the execution of the sequences, and we encounter a second conditional branch instruction, which will this time compare the value of two times a to the value of b. By the way, we can here observe that the comparison operators not only allow to compare the values of two variables, as it is the case here, but also the values of two expressions, in a more general sense. Here if we evaluate two times a, we obtain the value 2, which is the same as the value of b, and the result of the condition's evaluation will therefore be "true", which will have as a consequence to branch the execution on the positive block, the true block of the if instruction. This will cause the message "b est égal au double de a" to be printed, as can be seen here. In terms of good practices, we here have a relatively simple expression. You will however note that it is recommended, when the expression becomes more complex, to use parentheses, as we could already do here, by adding parentheses around, for example, this part of the expression, which makes the expression more readable. We have just seen how to use simple conditions by using comparison operators. In practice, it is often necessary to combine many of these simple conditions to formulate a more complex condition. To combine simple expressions, we need to use another type of operator, the logical operators. For example, the logical operator AND, which is defined in C++ either by the key-word "and", or by the symbol "&&", is an operator operating with two operands, which are two logical expressions, that is to say expressions returning either "true" or "false". The result of the evaluation involving the and is "true" only in the case where each operand has the value "true". In every other case, let's say for example that one of the two operands, and a fortiori the two, are "false", the result of the global expression's evaluation will also be "false", here. Now let's have a look, with a concrete example, at how to use the logical operator "and". Here an example of a small program, which asks the user to enter a number, and we want this number to be between 1 and 10. The number is read from the standard input, and stored in a variable n. We want to verify that the number entered by the user meets our expectations, is between the boundary numbers in question, and that's why the two following conditions must simultaneously verified. The entered number must be greater than or equal to 1, and less than or equal to 10. Since we want the two conditions to be simultaneously verified, we must use the logical operator AND. Now let's imagine that the user has entered the value zero, this will mean that this expression's evaluation will return "false". An expression that involves an and returns "true" only if its two operands are "true", which isn't the case here. So here, the result of the evaluation of the expression with the and is also "false". As a result, we will branch on the else part of the if, and print "incorrect" to show the user that he hasn't entered a number according to our expectations. Contrariwise, if the user now enters the value 5, this expression's evaluation will return "true", the evaluation of this second expression will also return "true", which will mean that the evaluation of the expression with the and also returns "true". At this moment, we will branch on the positive part of the if and print "correct" to tell the user that the entered number is indeed correct. Another usual logical operator, the OR, which is defined in C++ either by the reserved word or, or by a double vertical bar. As with the logical operator AND, the logical operator OR requires two operands, which are the logical expressions, meaning that they return "true" or "false". The expression's evaluation with an OR returns "true" if one or the other, not necessarily the two, one or the other of the operands is "true". It is therefore quite clear that the only situation or logical expression involving and OR returning "false" is a situation where the two operands return "false". In this case, the expression with the OR also returns "false". Now let's illustrate the use of the logical OR with a small concrete example. Here we have a small program which asks the user to choose two values. These two values are entered from the standard input and are stored in two variables m and n. In the present case, we want one or the other of them to be positive, as we only need one of the two values to be positive. We test these conditions by using the logical operator OR. Initially, let's suppose that the user enters the values 1 and -1. In this case, the first operand will be evaluated as "true", because it is indeed positive, and therefore the expression's evaluation returns "true", as it is sufficient that one or the other of the operands be "true" for the result to be "true" for the global expression. Therefore, it is indeed the message "au moins une valeur est positive" that will be printed in the present case. Now let's suppose that the entered values are -1 and 1. In this case, the evaluation of this first expression will return "false", and the evaluation of the second expression, on the other hand, will return "true", as it sufficient that one or the other of the operands be "true" for all of it to be "true". The global expression's evaluation returns "true", and once again the message "au moins une valeur est positive" is printed. Last case : let's imagine that the user enters the values minus 1 and -1 for each variable m and n. In this case, the evaluation of the first expression will return "false", the evaluation of the second expression will also return "false", as the two operands are evaluated as "false", the global expression also returns "false" and in this case, it's the message "les deux valeurs sont négatives" that will be printed. Last usual logical operator, the NOT, the negation, which is defined in C++ either by the reserved word not, or by the exclamation mark. The logical operator NOT is a unary logical operator, which means that it expects only one operand, which is once again a logical expression returning "true" or "false". The purpose of the logical operator NOT is to return the negation of the value of its operand. For example, let's suppose that the operand is evaluated as "false", which means that a is greater than or equal to b, the global expression's evaluation with the not will return the negation of "false", namely "true". Now let's suppose that the evaluation of this operand returns "true", the global expression will this time return the negation of "true", namely "false". We'll have the opportunity to see many examples of the use of the operator NOT in the following chapters of this course.
