---
# System prepended metadata

title: La puissance des conditions (Mazz)
tags: [Tips]

---

# ***La puissance des conditions***


<br>

Une condition en C c’est ce que vous mettez à l’intérieur des ***(parenthèses)***. C'est simple vu comme ça, mais vous verrez que plusieurs spécifités permettent de faire un code très ***propre*** avec !

---
- ***Le short circuiting***

C'est un principe assez facile à comprendre et qui permettra à votre programme d'aller beaucoup plus vite car évitera tous les calculs non-nécessaires.

Le but c'est que, dans une condition avec un OU du genre : 

```c
    if ((condition1) || (condition2))
        ...;
```
Si la condition1 est vraie, alors la condition2 ne sera même pas checkée ! Cette règle ne s'applique pas au && car elle s'applique inversement !

Vu qu'il faut que les 2 conditions soient respéctées, si la première ne l'est pas, la 2e ne sera même pas checkée

Exemple : 
```c

int main(void)
{
    int a = 1, b = 1, c = 0;
    // le short circuiting

    // se fait car la première condition est respectée
    if (a == b || c++)
        printf("c = %d\n", c);
    
    // ne se fait pas car les 2 conditions doivent etre respectees
    if (a == b && c++)
        printf("c = %d\n", c);
    
    // se fait car la premiere condition n'est pas respectee
    if (a != b && c++)
        printf("c = %d\n", c);
    
    return 0;
}

// output :
   // c = 0
   // c = 1
   // c = 1
```


---
- ***Calculer avec des conditions ???***

Imaginons que l’on veuille une fonction qui return la valeur la plus petite entre a et b, on la coderai tous comme ça vu que c’est facile :

```c
int smaller(int a, int b)
{
    if (a < b)
        return a;
    else
        return b;
}
```

Dans cet exemple, la condition (a < b) est soit juste ou ***true*** (1 < 3), soit fausse ou ***false*** (3 ≤ 1).       Ce que vous ne savez peut-être pas c’est que true = 1 et false = 0. D’où le fait que l’on peut utiliser **!** pour checker si quelque chose est négatif ou inexistant (0 ou un nombre négatif, '\0' ou NULL)

*on dira merci à <stdbool.h> qui fait 3 lignes :skull::skull::skull:.*

<br>

> Mais dis moi Noah si true = 1 et false = 0, on peut les utiliser dans des ***calculs*** ?

> — ***Eh bien oui*** ! Et si vous vous demandez pourquoi c’est utile, je vous dirais que *la vie c’est avant tout des rencontres, des gens qui étaient là pour moi lorsque je n’étais pas là, où que j’étais seul chez moi, et c'est marrant de se dire que les hasards forgent une destinée...* Nan je rigole. (regardez Astérix et Obélix)

Nan en sah c’est important parce que pour optimiser un code, ***cette technique va plus vite que des if***. (Après c’est quand même bien hein mais c’est pas le plus opti).

Alors, on parle en terme de millisecondes, mais faut savoir que le C est converti en Assembler avant d’être lu par l’ordinateur.

Et le code d’exemple que je vais vous montrer est un poil plus rapide car la machine a moins de commandes ASM à réaliser :

```c
int smaller(int a, int b)
{
    return   a * (a < b)   +   b * (a >= b);
}
// si a est inférieur à b alors ce sera a*1 + b*0
// et inversement
```

Je vous jure sur la tête de mes futurs enfants que c’est plus rapide.

**Autre exemple encore plus fun** :

Imaginons que l’on veuille avoir une fonction qui va transformer les caractères minuscules en majuscules dans une string.

```c
char *strUpper(char *str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] >= 'a' && str[i] <= 'z') {
            str[i] = str[i] + 32;
        }
    }
    return str;
}
```

Bah on peut aussi enlever le if ici regardez :

```c
char *strUpper(char *str)
{
    for (int i = 0; str[i] != '\0'; i++)
        str[i]   +=   32 * (str[i] <= 'z' && str[i] >= 'a');
    return str;
}
```

D’ailleurs, il vous arrivera de vouloir augmenter d’une valeur autre que 32, des fois peut-être juste de 1. 

Dans ce cas-là... Rendez vous compte que le C permet une fonction ressemblant à ça :


```c

// petite fonction pour compter le nombre de lignes 
// que vous allez malloc pour créer un tableau à partir d'une string

int countLigns(char *str)
{
    int i = 1;

    while (*str != '\0')
        i += (*(str++) == '\n');
    return i;
}

```




# >:)

<br>


Voilà ça vous donnera des idées pour faire en sorte que vos fonctions fassent 20 lignes, tout en étant plus rapide.
Je donne des exemples de toutes petites fonctions alors imaginez dans une structure plus complexe !