Welcome to Bukkit France

Inscrivez-vous maintenant pour profiter d'un accès total à tout le contenu offert par la meilleur communauté Bukkit française ! Une fois inscrit et connecté, vous pourrez contribuez à la communauté en postant vos propres sujets et questions ou en répondant à ceux existants. Vous pourrez aussi customiser votre profil, recevoir des points de réputations, communiquer avec les autres membres via le chat, et plus encore! 

  • Annonces

    • Pskyco

      Bukkit France passe sous Discord !   02/20/16

      Bukkit France est désormais passé sur Discord, au revoir donc notre vieux Teamspeak ! Téléchargez le client et venez nous rejoindre sur notre salon en suivant les instructions suivantes.
      M-à-j du 25/02/2017 : Désormais, seuls les comptes actifs sur le forum se verront donner l'accès au Discord, ce dernier n'est pas une plateforme d'aide de la même manière que le chat.

Blogs

Billets mis en évidence

  • Pskyco

    Bukkit France passe sous Discord !

    Par Pskyco

    Edit du 25/02/2017 : Désormais, seuls les comptes actifs sur le forum se verront donner l'accès au Discord, ce dernier n'est pas une plateforme d'aide de la même manière que le chat.

    Bonjour,   Nous vous écrivons ce petit billet afin de vous annoncer que Bukkit France passe sous le client VoIP Discord qui offre des services plus que convenables !   Cette envie de changer de plateforme s'est manifestée grâce aux nombreux avantages qu'offre Discord. L'accessibilité directe depuis le navigateur est d'ailleurs l'une des raisons principales.   Vous pouvez vous procurer Discord sur de nombreux systèmes,            Pour nous rejoindre, rien de plus simple, cliquez sur l'image ci-dessous et attendez qu'un membre du staff ne vous attribue le grade "Vérifié", vous permettant de parler librement avec les autres. Nous demandons un minimum d'une semaine d'ancienneté sur le forum et 20 messages pour y être accepté. En effet le Discord Bukkit.fr n'est pas une communauté à part mais bel et bien une extension de Bukkit.fr.     Nous vous attendons très nombreux !   Bien à vous, l'équipe Bukkit France
    • 7 commentaires
    • 3304 vues
  • CitronVert

    Recrutement été 2016 - Résultats de la deuxième vague

    Par CitronVert

    Bonjour à toutes et à tous,   Comme vous le savez, nous avons lancé une nouvelle campagne de recrutement début août. Nous avons récolté vos candidatures et nous avons voté pour ou contre chaque personne qui s'était présentée. Pour cette deuxième vague, nous avons reçu plusieurs candidatures modérateurs, nous les avons refusées car nous étions en surplus de modérateur, ne prenez pas ça comme un refus personnel ;).   Petites informations   Les membres ayant été acceptés sont en période de test. Concernant ceux qui n'ont pas été retenus, votre 'refus' n'est pas un refus définitif. Les raisons pourront vous être communiqués en MP, sur demande. La prochaine vague de recrutements aura lieu l'année prochaine   Changements dans le staff   Horld3n, recruté en tant que Community Manager   L'équipe compte donc aujourd'hui un Community Manager, seize modérateurs, trois administrateurs et deux fondateurs   L'équipe Bukkit France aujourd'hui   Fondateurs : abclive, iooner Administrateurs : Eldra, Mentalow, Pskyco Modérateurs : Alishk, Azerkiller, Chk, Chipie, CitronVert, como89, Crumble14, Dartasen, Dragorn421, Jackblue, JeremGamer, Jimi, Mac', Manercraft, Tanki, Technowix. Community Manager : Horld3n Bien à vous, le staff Bukkit France.
    • 0 commentaire
    • 880 vues
  • SystemGlitch

    Prologue

    Par SystemGlitch

    Bonjour chers/chères Bukkitiens/Bukkitiennes !   Bienvenue dans le cours de développement Java! Que pensez-vous de commencer par l'introduction?           Java, non, on ne parle pas de la danse ridicule des années 1920!   Le Java est un langage de programmation apparu en 1995, et oui! 1995! Mais il était alors bien différent de celui que nous connaissons aujourd'hui! Il fut développé par l'entreprise Sun MicroSystems qui fut rachetée par Oracle Corporation en 2009. Il n'y pas si longtemps que ça finalement!   Java est un langage orienté objet robuste, puissant et surtout, très portable car il est multi-plateforme. Sa grande portabilité réside dans un concept utilisé auparavant par le Pascal, il utilise une machine virtuelle que l'on nomme Java Runtime Environment (JRE), qui va faire l'intermédiaire entre le bytecode (écrit par le compilateur grâce au code de l'utilisateur), et va le transformer en langage compréhensible par la machine concernée. Il y a un autre aspect de sa "portabilité", se fût à sa création, sa syntaxe ressemble beaucoup à celle du C++ et ce n'est pas une coïncidence, les ingénieurs de l'époque travaillaient essentiellement en C, reprendre cette syntaxe permettait à une large communauté de pouvoir utiliser leur langage très rapidement, et c'est en grande partie grâce à cela que le Java est devenu vite populaire. Sa puissante API permet de gérer un grand nombre de domaines comme les interfaces graphiques, la gestion des fichiers, que ce soit en local ou sur une base de données, et bien plus encore!   Ses possibilités sont très diversifiées. Les bases sont faciles à intégrer mais maîtriser les différents domaines demande plusieurs années de pratique... Mais ne vous inquiétez pas, nous irons pas-à-pas.   Contrairement à d'autres cours sur Internet, nous ne nous contenterons pas de dresser une liste exhaustive des possibilités du Java et de Bukkit car ce serait trop long et inutile! Nous ne somme pas là pour faire du bourrage de crane! Nous voulons vous fournir les outils nécessaires pour que vous sachiez vous débrouiller tout seul, sans être un assisté qui se contente de recopier un tutoriel! Et plus important encore, vous comprendrez cette superbe vidéo!               Ne plongez pas la tête la première!   Afin de développer avec ce merveilleux langage, il vous faut d'abord installer Java, mais pas une simple JRE, la version Java SE Development Kit (JDK). Nous tenons aussi à signaler que rien ne vous empêche d'installer plusieurs JDK et de choisir celle que vous voulez pour votre projet, via votre IDE.   Il est évidemment possible de développer à l'aide d'un simple éditeur de texte, mais avouez que l'idée même en est repoussante! Pour développer, il vous faudra des couleurs, de l'ordre et un environnement agréable, afin de mieux s'y retrouver au sein de son code. On appelle ces logiciels IDE (Integrated development environment). Nous allons explorer le monde du Java avec un IDE répondant au nom d'Eclipse. Vous pouvez télécharger la version dont nous aurons besoin ici!   Vous voila prêt à commencer me direz-vous! Et bien désolé de vous décevoir, mais non, il y a encore des choses à savoir avant de débuter. Vous vous doutez que ce genre d'outil n'est pas ce qu'il y a de plus simple à utiliser.   Je pense que vous n'aurez pas trop de difficultés à apprendre les différents raccourcis clavier, ceux-ci sont spécifiés dans les menus. Ceux-ci sont les plus importants: Ctrl + Shift + O : Il vous permet de rapidement générer les imports dont vous aurez besoin pour faire fonctionner votre code. Ctrl + S : Il permet de sauvegarder la classe sur laquelle vous travaillez actuellement. Ctrl + Shift + S : Il permet de tout sauvegarder. Toutes les classes modifiées depuis la dernière sauvegarde seront sauvegardées !   Jetez un œil à cette rapide visite guidée de votre IDE :       Vous pourrez trouver plus d'informations à propos de votre IDE en consultant la documentation officielle d'Eclipse. Nous apprendrons tout de même quelques unes de ses fonctionnalités ensemble!   Lancez Eclipse. Une boite de dialogue apparaîtra. Spécifiez le dossier dans lequel vous voulez que tous vos projets soient sauvegardés. On appelle ce dossier "Workspace".   Faites un clic droit dans l'explorateur de packages et créez un nouveau projet :     Une boite de dialogue s'ouvrira pour vous demander de définir les paramètres de votre projet. Assurez-vous que ces derniers soient bien les mêmes que sur l'image suivante :     Cliquez sur "Finish". Votre projet est créé! Nous le remplirons plus tard! Maintenant, passons aux choses sérieuses!     JeremGamer et JackBlue  
    • 9 commentaires
    • 2527 vues
  • while(true);

    Chapitre II : Les variables

    Par while(true);

    Une variable permet de stocker en mémoire une valeur d'un typé donné. On peut ensuite s'en servir comme bon nous semble.

    Rappels de base:
    Un octet est égal à 8 bits (sauf dans de la très vieille informatique ou dans de rares domaines de la communication).
    Un bit est un chiffre en binaire. C'est-à-dire soit 0, soit 1.
    Pour connaître le nombre de possibilités en fonction du nombre de chiffres avec une base donnée, il suffit de faire : basechiffres.
    Si on a 32 bits on a donc 232 possibilités soit 4 294 967 296 - un joli paquet.   Types courants:   Il existe de nombreux types de variables dits "primitifs" en C++. En voici une liste non-exhaustive : bool : C'est un booléen, qui ne peut contenir que true (1) ou false (0). Il est souvent utilisé dans les conditions (voir le prochain chapitre). Attention, il ne mesure pas qu'un seul bit. int : C'est probablement le plus couramment utilisé. Sa taille dépend du type d'architecture cible : Dans le cas du x86, il fait 4 octets (et en x86-64 8 octets). C'est un nombre entier (qui peut être négatif). Il mesure au moins 16 bits. Exemple : 37 char : Il est identique au int mais ne mesure généralement qu'un seul octet - attention, cela n'est pas forcément vrai sur certaines architectures exotiques. Il est très souvent utilisé pour la manipulation de texte puisqu'il peut stocker un caractère ASCII (on peut en fait directement assigner un caractère à un char). Exemple : 'a' ou 78. Faites attention : le caractère " permet de délimiter du texte tandis que ' délimite un seul caractère. Vous ne pouvez pas assigner du texte à un char. short : Il est identique au int mais mesure au moins 16 bits, très souvent moins que int. Exemple : 298 long : C'est un int de taille supérieure ou égale au int. Il mesure au moins 32 bits. long long : C'est un int de taille supérieure ou égale au long. Il mesure au moins 64 bits. Note: Celui-ci a été introduit par C++11, veillez à utiliser un compilateur récent et à passer -std=c++11 (ou -std=c++14) au compilateur. float : C'est une valeur "flottante". Il permet de stocker des nombres à virgule. Il mesure 4 octets comme le int. Il est préférable de ne l'utiliser que lorsqu'on en a besoin car sa manipulation est plus lente. Exemple : 37.876 double : Il est identique au float mais mesure 8 octets. Exemple : 37.876   Utilisation & mots-clés:   Toutes les variables de ces types peuvent être affichés grâce à std::cout. Il suffit alors de mettre le nom de la variable à la place du "Hello World" que l'on a vu dans le tutoriel. On peut préfixer les valeurs intégrales (int, char, short) du mot-clé unsigned ce qui fait que les valeurs négatives ne seront plus acceptées. Du coup, cela nous permet d'économiser un bit si on a pas besoin de valeurs négatives (de plus, le compilateur peut mieux pousser ses optimisations). Si vous essayez d'assigner une valeur négative à votre variable unsigned, le compilateur devrait vous avertir. Le mot clé const permet de rendre une variable non modifiable, par exemple. Dans le cas des primitifs, sa valeur doit donc être assignée lors de la déclaration. Dans cet exemple simple, on place le mot clé const avant le type (voir Approfondir). #include <iostream> int main() {      float valeurFlottante = 376.84; // Attention! Le nom de cette variable n'est donné qu'à titre d'exemple. Evitez à tout prix de nommer des variables avec des noms peu explicite dans votre code (comme a, b, etc.)      unsigned int entierPositif = 73;      char lettreX = 'X'; std::cout << "La valeur flottante est : " << valeurFlottante << std::endl << "L'entier positif est : " << entierPositif << std::endl << "La lettre est : " << lettreX << std::endl; return 0; } Testez en ligne!
      Il est possible de déclarer plusieurs variables à la suite, pour alléger le code visuellement : int a = 0, b = 3, c = 4; // a, b et c sont tous des int, et on leur donne une valeur de départ int d, e, f = 4; // Attention : cela ne donne pas la valeur 4 pour d, e et f, mais seulement à f.   Portée des variables   Une variable déclarée dans un scope anonyme (rappel : délimité par des accolades) ne sera plus accessible en dehors de celle-ci. Par exemple : #include <iostream> int main() { { // On a tout à fait le droit de faire ça! int maValeur = 5; } std::cout << maValeur << std::endl; // Erreur : maValeur n'existe pas ici return 0; } clang++ prévient en effet : main.cpp:7:19: error: use of undeclared identifier 'maValeur'
    g++ nous alerte également : main.cpp:7:19: error: 'maValeur' was not declared in this scope   Si le compilateur est bien assez intelligent pour éliminer les variables inutilisées, cela peut être une bonne pratique d'utiliser des scopes anonymes quand on peut, notamment dans les grosses fonctions (il faut tout de même mieux diviser les grandes fonctions en plus petites fonctions selon le cas).   Valeur des primitifs non initialisés
    De plus, une variable que nous définissons mais que nous n'initialisons pas est indéfinie. Cela signifie que sa valeur ne sera pas garantie tant que nous lui donnons pas une valeur. De ce fait, il ne faut pas lire la valeur de cette variable si l'on ne l'a pas initialisée. Sinon, cela relève du comportement indéfini. En effet, cette variable aura des chances d'hériter de bouts de mémoire d'un ancien programme ou de bouts de mémoire que le programme a libéré. #include <iostream> int main() { int a; // La valeur de a ne sera pas forcément zéro! a = 3; // Maintenant on peut utiliser a. return 0; }   Allocation
    Quand nous définissons une variable ainsi, cela s'appelle de l'allocation automatique. Dans l'exemple précédent, a est un local à la fonction main.
    Nous verrons plus tard l'allocation dynamique moderne avec le C++11, grâce à des pointeurs intelligents qui permettent de s'abstraire de la gestion manuelle de la mémoire.
    Java utilise presque exclusivement l'allocation dynamique et abstrait la gestion manuelle de la mémoire avec un ramasse-miettes (GC). Si cela rend Java plus performant lors de l'allocation dynamique que le C++, l'allocation automatique en reste plus performante et cela permet d'éviter les coûts inévitables d'un GC.

    Nous verrons d'ici peu comment manipuler ces variables.   Approfondir (avec des concepts plus avancés) :   Taille et capacité d'un type: La fonction sizeof permet d'obtenir le nombre d'octets qu'utilise un type. Par exemple sizeof(int) retournera la taille du type int. Attention : Pour des pointeurs, par exemple sizeof(float*) mesurera la taille du pointeur plutôt que de la cible.
    Vous pouvez inclure le fichier "limits" pour pouvoir connaître de nombreuses informations sur un type donné - par exemple pour la taille maximale d'un float : std::numeric_limits<float>::max(). Documentation

    Sur coliru: int : -2147483648 to 2147483647 unsigned int : 0 to 4294967295 long : -9223372036854775808 to 9223372036854775807 unsigned long : 0 to 18446744073709551615 long long : -9223372036854775808 to 9223372036854775807 unsigned long long : 0 to 18446744073709551615 char : -128 to 127 unsigned char : 0 to 255 short : -32768 to 32767 unsigned short : 0 to 65535 float : 1.17549e-38 to 3.40282e+38 double : 2.22507e-308 to 1.79769e+308   Notez qu'il est presque toujours préféré d'utiliser un type plus petit quand on a pas besoin de plus de capacité. Cela aura pour but de réduire l'empreinte mémoire et de potentiellement légèrement accélérer le programme, mais trop se préoccuper de cela est inutile (souvenez vous, l'optimisation prématurée est la cause de tous les maux).

    Si il est nécessaire d'avoir des variables de taille fixée (les types normaux ci-dessus ont une taille définie par l'implémentation, variant ainsi entre les machines voire les compilateurs), il est mieux d'utiliser les types du header <cstdint>. Le type size_t est souvent utilisé pour désigner des tailles (ex. vector::size()). C'est un type non signé de taille définie par l'implémentation.   Const, const-correctness et const_cast en C++: Les const sont plus puissants qu'ils en ont l'air. En effet, si vous construisez un objet ou définissez une référence const, vous ne pourrez utiliser que ses méthodes définies comme const, garantissant ainsi que vous ne modifierez pas l'objet, contrairement aux final de Java. De plus, il est également possible d'avoir une version const et une version normale d'une méthode en C++. Comme dit précédemment, le mot-clé const s'applique à l'objet avant lui (ou après lui s'il se trouve au début). Par exemple : const int a = 0; int const b = 0; Les deux cas précédents sont identiques. Un exemple avec des pointeurs : int val = 0, val2 = 0; const int* a = &val; // Pointeur non-const vers un int const int const *b = &val; // Idem que a int *const c = &val; // Pointeur const vers un int non-const int const *const d = &val; // Pointeur const vers un int const const int *const e = &val; // Idem que d *a = val2; // Erreur : Assignation de valeur const a = &val2; // Correct : Assignation d'un pointeur non-const *c = val2; // Correct : Assignation de valeur non-const c = &val2; // Erreur : Assignation de pointeur const *d = val2; // Erreur : Assignation de valeur const d = &val2; // Erreur : Assignation de pointeur const On ne peut pas abandonner le const en cours de route de manière implicite: const int a = 0; int& b = a; // Erreur: Assigner un 'const int' à une référence de type 'int' élimine le 'const' Cependant, si on a un objet de départ non-const et une référence vers celui-ci qui est const, il est possible d'utiliser const_cast pour obtenir une référence non-const à partir de cette référence const. Attention au comportement indéfini, il ne faut surtout pas faire ça si l'objet de départ est const! int a = 0; const int& ref = a; int& b = const_cast<int&>(ref); // Correct const int a = 0; const int& ref = a; int& b = const_cast<int&>(ref); // ATTENTION: Comportement indéfini!   Comportements spéciaux:
    Quand on dépasse la capacité maximale d'une variable, il se passe ce qu'on appelle un overflow.
    Le standard du C++ ne définit pas le comportement d'un overflow sur des types signés (c'est-à-dire qui peuvent avoir une valeur positive ou négative, comme int, char, short). Il ne faut donc pas baser le fonctionnement de son programme sur de tels overflow, car on ne sait pas ce qui va se passer, et en général les optimiseurs et leurs compilateurs se basent sur le principe que le code de l'utilisateur ne se base pas sur du comportement indéfini. Cela peut paraître agaçant, mais c'est une des puissances (ou faiblesses) du C++ : Cela permet de laisser place à de puissantes optimisations au niveau de compilateur.
    Avec les variables unsigned, c'est différent : En cas d'overflow, la variable revient à 0, cette fois-ci le standard le définit bien!   Notez qu'il existe des cas comme ceux-ci : Utiliser l'opérateur binaire << sur un entier négatif cause un comportement indéfini, utiliser l'opérateur binaire >> sur un entier négatif cause un comportement défini par l'implémentation.
    Pour les types flottants, l'overflow provoque un comportement indéfini surtout car le fonctionnement des float est plus compliqué (et serait inutilement complexe à implémenter de manière standardisée pour diverses raisons).
    • 4 commentaires
    • 1163 vues

Nos blogs communautaires

  1. Bonjour à toutes et tous,

     

    Lors du passage à la dernière version d'IPBoard il y a quelques mois, il y a eu un problème avec les balises codes et le format en général dans les blogs. Parmi ces problèmes, on peut retrouver la perte de police, ou les retours à la ligne dans les balises code. Cela rendait les cours parfaitement illisibles.

     

    J'ai récemment reformaté l'intégralité des cours, des TPs et des Hors-série pour qu'ils soient de nouveau lisibles ! :) Cela a pris beaucoup de temps mais je pense que cela en vaut la peine.

     

    Si vous n'avez pas encore commencé votre aventure dans le monde de Java, c'est le moment !

     

    Votre prof de Java préféré,

    JeremGamer

  2. Bonjour à toutes et à tous,

     

    Comme vous le savez, nous avons lancé une nouvelle campagne de recrutement début août. Nous avons récolté vos candidatures et nous avons voté pour ou contre chaque personne qui s'était présentée. Pour cette deuxième vague, nous avons reçu plusieurs candidatures modérateurs, nous les avons refusées car nous étions en surplus de modérateur, ne prenez pas ça comme un refus personnel ;).

     

    Petites informations

     

    • Les membres ayant été acceptés sont en période de test.
    • Concernant ceux qui n'ont pas été retenus, votre 'refus' n'est pas un refus définitif. Les raisons pourront vous être communiqués en MP, sur demande.
    • La prochaine vague de recrutements aura lieu l'année prochaine

     

    Changements dans le staff

     

    Horld3n, recruté en tant que Community Manager

     

    L'équipe compte donc aujourd'hui un Community Manager, seize modérateurs, trois administrateurs et deux fondateurs

     

    L'équipe Bukkit France aujourd'hui

     

    Fondateurs : abclive, iooner

    Administrateurs : Eldra, Mentalow, Pskyco

    Modérateurs : Alishk, Azerkiller, Chk, Chipie, CitronVert, como89, Crumble14, Dartasen, Dragorn421, Jackblue, JeremGamer, Jimi, Mac', Manercraft, Tanki, Technowix.

    Community Manager : Horld3n

    Bien à vous,

    le staff Bukkit France.

    • 2
      billets
    • 0
      commentaire
    • 230
      vues

    Billets récents

    TheElectronWill
    Dernier billet

    2 - Les Bases

     

    Variables & Constantes

    Scala utilise deux mots-clés différents pour les variables et pour les constantes.

    var nom: Type = valeur // variable, contient une valeur
    val nom: Type = valeur // constante, ne peux pas être modifiée

    :excl:Remarquez que, contrairement à Java, C et d'autres, le type de la valeur est après son nom, pas avant.

     

    Scala est capable de trouver le type des expressions lui-même, donc vous pouvez écrire par exemple :

    var i = 0 // pas besoin de préciser que c'est un int

     

    En Scala les types "primitifs" se notent avec une majuscule: Int, Long, Float, Double, Boolean. Puisque tout est objet, ils ont aussi leur classe ! Mais ce n'est pas comme si on remplaçait les types primitifs de Java par leur wrappers : au final, le compilateur Scala utilise les types primitifs (dès que c'est possible).

     

     

    Méthodes

    Une méthode se définit avec le mot-clé def, comme en Python.

    def nom(param1: Type, param2: Type): TypeResultat = {
        // code ...
        resultat // pas besoin de return
    }

    Le mot-clé return existe en scala, mais il est peu utilisé. En effet, un bloc de code qui doit retourner une valeur prend automatiquement celle de sa dernière expression.

     

    Là encore, Scala peut trouver le type du résultat tout seul. Cependant c'est une bonne habitude d'écrire le type, d'une part pour éviter les surprises (résultat qui n'est pas du type auquel on s'attendait) et pour informer les autres développeurs, ainsi que votre vous du futur qui aura oublié comment il a fait cette fonction :)

     

    Petit exemple, attention c'est difficile ! On va additionner deux nombres :o

    def add(a: Int, b: Int) = {
        a + b
    }

    Et voilà B)

     

    On peut aussi écrire la fonction en une seule ligne et enlever les accolades:

    def add(a: Int, b: Int) = a + b

     

    Conditions

    Les conditions sont similaires à celles du Java, avec un truc en plus : une condition est une expression qui donne un résultat. Il n'y a pas d'opérateur ternaire en Scala, juste des conditions.

    var v = if(condition1) "a" else if (condition2) "b" else "c"

     

    Boucles

    On retrouve les classiques while(condition) (tant que) et do { ... } while(condition) (répéter) que vous connaissez bien.

    Là où il y a du changement c'est au niveau de la boucle for. Vous avez peut-être l'habitude d'utiliser ce type de boucle :

    for (int i = 0; i < 10; i++) {
        //code
    }

    En Scala, ça n'existe pas ! Il n'y a que le "foreach" :

    for (i <- 0 until 10) { // i prend les valeurs 0,1,2,3,4,5,6,7,8,9
        //code
    }
    for (element <- array) { // parcourt un tableau
        //code
    }

    Cette écriture n'est en fait que du "sucre syntaxique" qui se traduit par un appel à la méthode foreach :

    (0 until 10).foreach(/*code*/)

     

  3. Une condition peut être soit vraie, soit fausse.
    Par exemple, la condition 2 < 3 est vraie, mais la condition 5 < 2 sera fausse.

    Attention : Pour vérifier si un nombre est égal à un autre, on utilise == et non pas =, qui est l'opérateur d'assignation (pour assigner une valeur à une variable) et non pas celui de comparaison.

    Il existe la structure conditionnelle if en C++. Elle permet de vérifier une condition (= tester) et si elle est vraie, alors du code sera exécuté. Il est possible de la compléter avec else, qui exécute du code dans le cas où la condition est fausse, ou else if, qui permet de vérifier une autre condition dans le cas où la première est fausse.
    Pour délimiter le code à exécuter si la condition est vraie, on utilise soit des accolades, soit rien si on veut n'exécuter qu'une seule instruction (cela ne compte pas autres conditions et boucles).

    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur < 7)
        {
            std::cout << valeur << " est bel et bien inférieur à 7!" << std::endl;
        }
        else if (valeur == 7)
        {
            std::cout << "La valeur est égale à 7" << std::endl;
        }
        else
        {
            std::cout << valeur << " est inférieur à 7." << std::endl;
        }
      
        return 0;
    }
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur < 7)
            std::cout << valeur << " est bel et bien inférieur à 7!" << std::endl;
        else if (valeur == 7)
            std::cout << "La valeur est égale à 7" << std::endl;
        else
            std::cout << valeur << " est inférieur à 7." << std::endl;
      
        return 0;
    }

    Attention, deux erreurs très courantes chez les débutants (et pas que) :

    • On ne rajoute jamais de point-virgule après une structure conditionnelle (et plus tard, pareil avec les boucles)!
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur > 7); // Surtout pas ça! Cela équivaut au code ci-dessous...
            std::cout << valeur << " est supérieur à 7!" << std::endl;
    
      
        return 0;
    }
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur > 7)
        {
            // Mettre un point-virgule après une condition, ça équivaut à dire : si quelque chose, alors ne rien faire.
            // Ce n'est pas du tout ce qu'on veut! Le pire dans tout ça, c'est que le code en dessous va être toujours exécuté.
            // En effet, rien n'empêche de mettre du code dans une scope "sauvage".
        }
    
        {
            std::cout << valeur << " est supérieur à 7!" << std::endl;
        }
    
      
        return 0;
    }
    • Quand on ne met pas de scope, on ne peut pas mettre deux instructions à la suite!
    #include <iostream>
    
    int main()
    {
        int valeur = 2;
      
        if (valeur > 7)
            std::cout << valeur << " est supérieur à 7!" << std::endl; // Cela ne va être exécuté que lorsque la valeur est supérieure à 7...
            std::cout << "Cette valeur est vraiment supérieure à 7!" << std::endl; // Ce code va être exécuté peut importe quelle est la condition! Une faille majeure dans OSX était justement due à ce genre d'erreur. Faites attention!
      
        return 0;
    }

    Approfondir :

    Si on utilise un quelconque nombre en tant que condition, la condition sera fausse si nombre == 0 et vraie sinon.
    Pour vérifier si un tel nombre est non nul (non égal à zéro), nous avons complètement le droit de faire if (nombre) et c'est couramment fait. Par soucis de clarté, j'évite de faire if (!nombre) pour vérifie si le nombre est nul. Sachez que cela ne cause aucun problème cependant, mais je préfère garder mon code explicite au possible.

     

    Les opérateurs logiques nous permettent de vérifier plusieurs conditions à la fois dans une seule boucle if.

    En voici la liste :

    • || signifie OU. Par exemple, if (valeur < 3 || valeur > 8) permet de vérifier si la valeur est inférieure à 3 OU supérieure à 8.
    • && signifie ET. Par exemple, if (valeur1 == 7 && valeur2 == 3) permet de vérifier si valeur1 est égale à 7 ET si valeur2 est égale à 3.
    • ! signifie NON. Cet opérateur permet d'inverser la valeur d'un booléen (ou de rendre un nombre non égal à 0 égal à 0 (pas zéro => 0) ou un nombre égal à zéro égal à 1 (0 => 1).
      Le C++ ne fournit pas d'opérateur OU EXCLUSIF logique (qui serait ^^) mais !a != !b permet d'obtenir le même résultat, c'est-à-dire que la condition sera vraie seulement si a est vrai mais pas b.
      Vous pouvez englober cela dans une simple fonction :
      inline bool xor(const bool& a, const bool& b)
      {
      	return (!a) != (!b);
      }

      Au passage : inline informe au compilateur qu'on souhaite que la fonction soit directement intégrée au code. C'est bien pour du petit code ou du code exécuté peu de fois pour gagner en performances en éradiquant le temps perdu par l'exécution de la fonction, mais peut ralentir et grandement alourdir le code binaire résultant pour de larges fonctions ou des fonctions appelées à divers endroits du code. Ce n'est pas une garantie et cela n'arrive en général que lorsqu'on active les optimisations (-O3 par exemple).
      const bool& passe les deux variables par référence constante pour permettre au compilateur de pousser ses optimisations (ici ça ne servirait que si l'inline n'est pas possible).


    On peut englober une condition de parenthèses pour obtenir une meilleure clarté du code ou pour palier la priorité des opérateurs, par exemple : if ((valeur1 < 3) && ((8 + valeur2) > 7)).