L'environnement de développement intégré (IDE) Code::Blocks (ci-après dénommé CB) est un produit à part entière permettant de développer des applications en langage C/C++. CB est un framework multiplateforme développé à l'aide de la bibliothèque d'outils wxWidgets. Il existe des versions de l'environnement pour Windows et d'autres systèmes d'exploitation (OS) - Linux et Mac OS. Cet IDE est entièrement gratuit, open source et entièrement construit à l'aide de technologies open source. L'un des plus grands atouts de CB est sa prise en charge de la création d'applications wxWidgets, c'est-à-dire des logiciels qui utilisent l'API du système d'exploitation pour afficher une interface utilisateur graphique (GUI). En d’autres termes, CB vous permet de créer des logiciels multiplateformes pour tous les goûts.

CB peut fonctionner avec un grand nombre de compilateurs. S'il y en a plusieurs installés dans le système, vous pouvez facilement basculer entre eux, en fonction de vos besoins. De plus, au stade de l'installation, l'EDI lui-même analysera le système à la recherche des compilateurs disponibles et proposera d'en utiliser un comme principal. Il est possible de modifier ces paramètres ultérieurement, tant globalement qu'individuellement pour les projets. Pour les paramètres d'environnement globaux, il y a toute une section « Paramètres » dans le menu principal du CB. Pour définir des paramètres spécifiques à un projet particulier, vous devez ouvrir la fenêtre des propriétés du projet. Pour ce faire, vous devez appeler le menu contextuel du projet en faisant un clic droit dessus et en sélectionnant « Propriétés ». Les projets eux-mêmes (actuellement ouverts dans l'EDI) sont affichés sous forme d'arborescence dans le panneau du dock « Gestion », dans son onglet « Projets ». Désormais, dans la fenêtre des propriétés qui s'ouvre, vous pouvez configurer une grande variété de paramètres, depuis la modification des cibles de build jusqu'à la connexion de bibliothèques tierces. Le bouton « Options de build du projet » sur l'onglet « Paramètres du projet » de la même fenêtre de propriétés permet de configurer de manière très flexible la configuration de build pour un projet spécifique : clés du compilateur, sélection du compilateur lui-même, connexion des bibliothèques pour l'éditeur de liens, etc. cela peut être fait pour des modes individuels : "Release" "Debug".

L'interface graphique CB est construite autour de panneaux de dock flottants et extensibles qui peuvent être ancrés sur n'importe quel côté de la fenêtre principale de l'IDE en les faisant simplement glisser avec la souris. Grâce à cela, vous pouvez configurer de manière très flexible différentes dispositions d'interface pour différentes tailles d'écran, optimisant ainsi l'ergonomie de l'interface graphique. S'il y a plusieurs moniteurs, il est pratique de séparer certains panneaux de la fenêtre principale et de les placer sur des moniteurs adjacents.

Les outils de mise en évidence, de complétion de code et d'édition dans CB rendent le processus de travail avec le code facile et confortable. Un vaste arsenal de paramètres vous permet de personnaliser très finement l'environnement « pour vous-même ». Il est très utile d'avoir un support pour travailler avec des variables d'environnement. Grâce à cette fonctionnalité, CB peut être très étroitement intégré au système et ses capacités peuvent être étendues, par exemple en connectant la bibliothèque wxWidgets.

À propos, pour développer des applications GUI basées sur wxWidgets, CB dispose d'un outil RAD intégré pour la conception GUI - wxSmith. Il s'agit d'un utilitaire assez puissant, bien que pas entièrement facile à apprendre.

Code::Blocks est un environnement de développement intégré (IDE) gratuit et open source qui prend en charge l'utilisation de divers compilateurs. Par défaut, Code::Blocks utilise le compilateur MinGW, inclus dans le kit (vous pouvez télécharger la distribution sans compilateur intégré). MinGW est une variante du compilateur GNU C/C++ pour Windows. MinGW est l'abréviation de « GNU minimaliste pour Windows ». La suite MinGW comprend des outils de programmation open source qui ne reposent sur aucune bibliothèque tierce payante. Il est utilisé par de nombreux environnements de développement (Visual Studio utilise son propre compilateur). MinGW inclut la GNU Compiler Collection (GCC), comprenant les compilateurs C, C++, ADA et Fortran. Code::Blocks a une architecture ouverte, ce qui lui permet d'évoluer à l'aide de plug-ins (vous pouvez écrire des programmes pour Windows, Linux et divers microprocesseurs tels que avr et stm32). Le débogueur de code dans Code::Blocks prend en charge les points d'arrêt dans le code source ou dans les données traitées par le programme.

Code :: Blocks est disponible pour Windows, Linux et Mac OS X. Le site Web du projet est codeblocks.org.

Installation du compilateur MinGW

L’installation de Code :: Blocks lui-même n’est pas difficile. Il est uniquement conseillé de l'installer dans un dossier où il n'y a pas d'espaces ni de caractères cyrilliques dans le chemin. Regardons l'installation du compilateur MinGW. En règle générale, la distribution Code::Blocks contient une ancienne version du compilateur MinGW, il est donc conseillé de télécharger Code::Blocks sans le compilateur MinGW et d'installer le compilateur séparément. Tout d’abord, téléchargez le programme d’installation depuis le site Web du projet mingw.org. Après le lancement, la fenêtre suivante apparaîtra.

Cliquez sur Installer et nous obtenons la fenêtre suivante.

Ici sur le terrain Répertoire d'installation indiquer l'emplacement des fichiers du compilateur. La valeur par défaut est C:\MinGW, on le laisse. Cliquez sur Continuer et le téléchargement et l'installation du gestionnaire d'installation de MinGW commencent.

Cliquez sur Continuer et nous obtenons la fenêtre suivante.

Pour la programmation en C++, sélectionnez les packages à installer mingw32-base-bin (Une installation de base de MinGW) Et mingw32-gcc-g++-bin (le compilateur GNU C++), puis cliquez sur le menu Installation -> Appliquer les modifications. Une fenêtre apparaîtra affichant le téléchargement des packages sélectionnés.

Lorsque les packages sont téléchargés, cliquez sur le bouton Fermer

La première fois que vous exécutez Code::Blocks, il détectera automatiquement le compilateur installé. Si des problèmes surviennent, vous devez accéder au menu Paramètres -> Compilateur... et sur l'onglet Exécutables de la chaîne d'outils vérifiez l'exactitude du chemin d'accès à MinGW, ainsi que les noms des fichiers du compilateur et de l'éditeur de liens. Vous pouvez maintenant créer un projet.

Créer un projet

Pour créer un projet, vous devez aller dans le menu Fichier -> Nouveau -> Projet...

Dans la fenêtre qui apparaît, sélectionnez le type de projet souhaité. Nous voyons ici que Code::Blocks possède un grand nombre de modèles de projet. Dans notre cas c'est Application de la console(application de la console).

Dans la fenêtre suivante, sélectionnez le langage de programmation à utiliser. Sélectionnez C++ et cliquez sur le bouton Suivant.

Suivant sur le terrain Titre du projet entrez le nom du projet. Dans notre cas c'est Test. Nous indiquons immédiatement l'emplacement du projet sur le disque (champ Dossier dans lequel créer le projet). Dans le dossier que nous avons spécifié, Codeblcoks créera automatiquement un dossier avec le nom de projet précédemment spécifié. Après avoir spécifié le nom du dossier et le nom du fichier, cliquez sur le bouton Suivant.

Dans la fenêtre suivante, sélectionnez le compilateur. Par défaut, le compilateur GNU GCC est sélectionné, que nous utiliserons.

Cliquez sur Finition et nous obtenons un programme minimal, appelé Hello World!

Appuyez sur F9 pour compiler et exécuter le programme et obtenir la fenêtre suivante.

Prise en charge du cyrillique dans la console

Le code de projet standard généré par l'environnement Code::Blocks ne prend pas en charge l'entrée et la sortie de caractères cyrilliques dans la console. Pour résoudre ce problème, vous devez d'abord apporter de petites modifications au code du projet. Un exemple de code source est présenté ci-dessous.

Source

#inclure #inclure en utilisant l'espace de noms std ; int main() ( SetConsoleCP(1251); // définition de la page de codes win-cp 1251 sur le flux d'entrée SetConsoleOutputCP(1251); // définition de la page de codes win-cp 1251 sur le flux de sortie cout

Ensuite, vous devez exécuter le programme, cliquer avec le bouton gauche sur le titre de la fenêtre (où le chemin d'accès au fichier .exe en cours d'exécution est affiché) et sélectionner l'élément dans le menu contextuel. Propriétés. Puis sur l'onglet Police de caractère installer la police Console Lucida et choisissez une taille de police pratique. Après cela, les messages dans les applications console prendront en charge les caractères cyrilliques.

Bonjour chers amis. Avec cet article, je commence une série de leçons dédiées à l'un des langages de programmation les plus populaires - le C++. Les cours s'adressent principalement aux utilisateurs qui ne sont pas familiers avec la programmation, donc les professionnels, ne soyez pas stricts, même si je soutiens les critiques, notamment contre moi-même. Dans mes cours, j'utiliserai l'environnement de développement Code::Blocks, dont le téléchargement et l'utilisation sont gratuits. Commençons bien sûr par le classique Hello, world =)

J'espère que vous avez déjà téléchargé et installé Code::Blocks, si c'est le cas, commençons. Lancement de l'environnement de développement

Tout d'abord, créez un nouveau projet vide Fichier->Nouveau->Projet et sélectionnez Projet vide

cliquez sur Aller, puis sur Suivant

et dans la fenêtre qui apparaît, dans le champ Titre du projet, tapez le titre du projet, dans Nom de fichier du projet le nom du projet et encore Suivant.

Dans la fenêtre suivante, supprimez le répertoire Objets des sections Créer une configuration « Debug » et Créer une configuration « Release », comme indiqué dans la capture d'écran ci-dessus, puis cliquez sur le bouton Terminer. Un projet intitulé « Hello world » devrait apparaître à droite.

L'étape suivante consiste à ajouter le fichier File->New->FIle... au projet et à sélectionner la source c/c++ dans la fenêtre qui apparaît.

Allez, Suivant encore, sélectionnez C++, Suivant et voyez la fenêtre suivante

,

ici, nous devons spécifier le nom du fichier (j'ai nommé main) et son chemin, de préférence le dossier contenant le projet. Cochez les cases Debug et Release et cliquez sur Finish.

Et nous avons reçu un fichier C++ vide dans lequel nous écrirons le code du programme lui-même.

Nous commençons maintenant à écrire le code du programme lui-même. Pour afficher des informations à l'écran, nous avons besoin de la bibliothèque d'E/S iostream.

#inclure

en utilisant l'espace de noms std ;

Ensuite nous écrirons la fonction principale qui sera exécutée au démarrage du programme

int main()

il faut l'appeler « main » et on indique son type int (nous en reparlerons dans les prochaines leçons). Entre les accolades et sera le code du programme. Nous allons écrire un programme simple qui affichera le message d'accueil « Bonjour tout le monde ! » dans la console.

cout<<"Bonjour le monde!" ;

Après chaque commande vous devez mettre un ";", cela indique au compilateur que la commande est terminée et que la suivante peut être traitée. cout - Imprime les valeurs des variables ou les chaînes sur la ligne de commande.

Liste complète du programme.

#inclure

en utilisant l'espace de noms std ;

int main ()

cout<< "Hello, world!" ;

retour 0 ;

Nous lançons le projet et voyons le résultat.

Ci-dessous, je joins une leçon vidéo à cet article.

Si vous avez des questions, veuillez écrire des commentaires à Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez avoir activé JavaScript pour le visualiser. ,">Cette adresse e-mail est protégée du spam. Vous devez avoir activé JavaScript pour le visualiser., j'affinerai les cours ou simplement aiderai à étudier les matières.

• < Назад

Bonjour chers amis. Avec cet article, je commence une série de leçons dédiées à l'un des langages de programmation les plus populaires - le C++. Les cours s'adressent principalement aux utilisateurs qui ne sont pas familiers avec la programmation, donc les professionnels, ne soyez pas stricts, même si je soutiens les critiques, notamment contre moi-même. Dans mes cours, j'utiliserai l'environnement de développement Code::Blocks, dont le téléchargement et l'utilisation sont gratuits. Commençons bien sûr par le classique Hello, world =)

J'espère que vous avez déjà téléchargé et installé Code::Blocks, si c'est le cas, commençons. Lancement de l'environnement de développement

Tout d'abord, créez un nouveau projet vide Fichier->Nouveau->Projet et sélectionnez Projet vide

cliquez sur Aller, puis sur Suivant

et dans la fenêtre qui apparaît, dans le champ Titre du projet, tapez le titre du projet, dans Nom de fichier du projet le nom du projet et encore Suivant.

Dans la fenêtre suivante, supprimez le répertoire Objets des sections Créer une configuration « Debug » et Créer une configuration « Release », comme indiqué dans la capture d'écran ci-dessus, puis cliquez sur le bouton Terminer. Un projet intitulé « Hello world » devrait apparaître à droite.

L'étape suivante consiste à ajouter le fichier File->New->FIle... au projet et à sélectionner la source c/c++ dans la fenêtre qui apparaît.

Allez, Suivant encore, sélectionnez C++, Suivant et voyez la fenêtre suivante

,

ici, nous devons spécifier le nom du fichier (j'ai nommé main) et son chemin, de préférence le dossier contenant le projet. Cochez les cases Debug et Release et cliquez sur Finish.

Et nous avons reçu un fichier C++ vide dans lequel nous écrirons le code du programme lui-même.

Nous commençons maintenant à écrire le code du programme lui-même. Pour afficher des informations à l'écran, nous avons besoin de la bibliothèque d'E/S iostream.

#inclure

en utilisant l'espace de noms std ;

Ensuite nous écrirons la fonction principale qui sera exécutée au démarrage du programme

int main()

il faut l'appeler « main » et on indique son type int (nous en reparlerons dans les prochaines leçons). Entre les accolades et sera le code du programme. Nous allons écrire un programme simple qui affichera le message d'accueil « Bonjour tout le monde ! » dans la console.

cout<<"Bonjour le monde!" ;

Après chaque commande vous devez mettre un ";", cela indique au compilateur que la commande est terminée et que la suivante peut être traitée. cout - Imprime les valeurs des variables ou les chaînes sur la ligne de commande.

Liste complète du programme.

#inclure

en utilisant l'espace de noms std ;

int main ()

cout<< "Hello, world!" ;

retour 0 ;

Nous lançons le projet et voyons le résultat.

Ci-dessous, je joins une leçon vidéo à cet article.

Si vous avez des questions, veuillez écrire des commentaires à Cette adresse e-mail est protégée contre les robots spammeurs. Vous devez avoir activé JavaScript pour le visualiser. ,">Cette adresse e-mail est protégée du spam. Vous devez avoir activé JavaScript pour le visualiser., j'affinerai les cours ou simplement aiderai à étudier les matières.

• < Назад

Version préliminaire (inachevée)

1 Installation et configuration de l'environnement de développement

1.1 Informations générales

Vous devez d’abord installer un environnement de développement, qui sera l’environnement logiciel intégré Code :: Blocks. Les principaux avantages de Code::Blocks incluent :

• licence gratuite GPL v3.0, en particulier, la distribution et l'utilisation gratuites sont autorisées ;
• l'environnement peut fonctionner sur les systèmes d'exploitation des familles Windows, Linux, OS X (c'est-à-dire qu'il est multiplateforme) ;
• capacité à travailler avec divers compilateurs.

Ce fichier installe à la fois l'environnement Code::Blocks et l'environnement MinGW, qui fournit la famille de compilateurs GCC. L'environnement MinGW est également un logiciel gratuit.

1.2.1.2 Processus d'installation

Vous devez exécuter le fichier codeblocks-10.05mingw-setup.exe. La fenêtre du programme d'installation apparaîtra.

Vous devez cliquer sur "Suivant". Une fenêtre apparaîtra avec le texte de la licence gratuite GPL v3.0.

Cliquer sur le bouton « J'accepte » signifie que vous acceptez les termes de la licence et vous permet de poursuivre l'installation du programme, au cours de laquelle la fenêtre de sélection des composants apparaîtra alors. Dans cette fenêtre, vous devez sélectionner le type d'installation "Complète : Tous les plugins, tous les outils, juste tout".

Après cela, vous devez cliquer sur le bouton « Suivant ». Une fenêtre apparaîtra avec le nom du répertoire d'installation. Il est préférable que le nom complet du répertoire ne contienne pas d'espaces ou de lettres autres que le latin. Par conséquent, par exemple, il est préférable de remplacer le nom C:\Program Files\CodeBlocks par autre chose, par exemple C:\CodeBlocks ou C:\Programs\CodeBlocks .

Après cela, vous pouvez cliquer sur le bouton "Installer", qui démarre le processus d'installation lui-même.

A la fin du processus, une fenêtre apparaîtra vous demandant de lancer Code::Blocks. Il est préférable de cliquer sur « Non » ici, puis de vérifier que Code::Blocks démarre de la manière habituelle.

Après cela, cliquez simplement sur le bouton « Suivant » puis sur « Terminer » pour terminer le processus d'installation.

1.2.1.3 Premier lancement

Un raccourci pour lancer Code::Blocks devrait apparaître dans la barre d'outils de lancement rapide. Un raccourci similaire devrait également apparaître sur le bureau.

Code::Blocks peut être lancé à l'aide de ces raccourcis, ainsi qu'à l'aide du menu du programme système standard.

À d'abord Lorsque vous démarrez Code::Blocks, une fenêtre devrait apparaître pour trouver automatiquement le compilateur.

Notez que la première ligne doit contenir le mot « Détecté ». Cela signifie que le compilateur a été trouvé. Vous devez cliquer sur "OK". Le processus de première exécution se poursuivra et l'environnement de développement sera lancé. Une fenêtre avec le conseil du jour apparaîtra.

Si vous ne souhaitez pas que cette fenêtre apparaisse à chaque démarrage de Code::Blocks, décochez la case "Afficher les astuces au démarrage dans cette fenêtre". Cliquez sur "Fermer" pour fermer cette fenêtre.

Après cela, la fenêtre suivante peut apparaître.

Ici, il est préférable de cliquer sur "OK" pour que les fichiers liés au C/C++ soient liés à Code::Blocks.

Vous pouvez également fermer la fenêtre "Console de script".

1.2.2 Installation pour un système d'exploitation Linux

Dans le cas de Linux, vous pouvez installer Code::Blocks en utilisant le package de la distribution souhaitée parmi ceux répertoriés sur cette page.

Vous pouvez également essayer de rechercher Code :: Blocks dans le référentiel de votre distribution Linux. Par exemple, le package Code::Blocks (10.05-1) est disponible dans le référentiel Ubuntu 11.04.

1.3 Configuration

Pour commencer, vous pouvez répartir les barres d'outils de manière plus compacte en haut de la fenêtre.

Après cela, vous devez apporter quelques modifications aux paramètres de base.

Sélectionnez le menu "Paramètres=>Compilateur et débogueur...". Une fenêtre de paramètres apparaîtra.

Dans cette fenêtre, vous avez besoin mettre cochez la case "Produire des symboles de débogage". Ce changement vous permettra d'effectuer un mode débogage, qui sera abordé dans une conférence ultérieure.

Sans fermer cette fenêtre, vous devez cliquer sur l'onglet "Autres options".

Et dans le champ d'édition, vous devez ajouter la ligne suivante.

Finput-charset=CP1251 -fexec-charset=CP866

Cela permettra à l'alphabet cyrillique de s'afficher correctement dans la console dans le cas d'un système d'exploitation Windows. Lorsque vous utilisez Code::Blocks sur d'autres systèmes d'exploitation (par exemple Linux), vous n'avez pas besoin d'ajouter cette ligne.

Sans fermer cette fenêtre, vous devez cliquer sur l'image de gauche avec l'inscription "Paramètres du débogueur", puis mettre cochez la case "Évaluer l'expression sous le curseur".

Après cela, cliquez sur "OK". Toutes les modifications apportées doivent prendre effet.

2 Premier projet

2.1 Créer un projet

Essayons maintenant de créer un programme en C.

Pour ce faire, vous devez créer un projet. En général, un projet est nécessaire pour combiner plusieurs fichiers en un seul tout. Mais dans ce cas, il est plus pratique de créer un projet pour un seul fichier. De plus, à l'avenir, il sera plus courant de travailler sur le projet.

Ainsi, pour créer un projet, sélectionnez le menu "Fichier", puis sélectionnez "Nouveau" dans la liste qui apparaît, puis sélectionnez "Projet" dans la liste qui apparaît (par souci de concision, cette action peut être désignée comme "Fichier=>Nouveau =>Projet", et à l'avenir, des notations plus courtes seront utilisées). En conséquence, une boîte de dialogue devrait apparaître.

Dans celui-ci, sélectionnez "Application console" et cliquez sur "Go". L'Assistant Nouveau projet apparaît.

Cliquez sur Suivant". La fenêtre suivante apparaîtra.

Ici, vous devez sélectionner C (pas C++) et cliquer sur "Suivant". La fenêtre suivante apparaîtra.

Dans la ligne "Titre du projet", saisissez le nom du projet, par exemple Projet01. Notez que dans la ligne "Nom du fichier du projet", ce nom sera copié. Ce nom de fichier peut être modifié (pour être différent du nom du projet), mais pour plus de commodité, il est préférable de les laisser identiques. Ensuite, dans la ligne « Dossier dans lequel créer le projet » (dossier pour y créer un projet), vous devez spécifier le dossier dans lequel se trouvera le dossier avec le projet. Vous pouvez soit sélectionner un dossier parmi ceux disponibles à l'aide du bouton "...", soit saisir manuellement le nom du dossier, par exemple C:\Projects.

Ensuite, un dossier portant le nom du projet sera créé dans le dossier sélectionné, où se trouvera le projet lui-même. Vous pouvez le vérifier en faisant attention à la ligne "Nom de fichier résultant".

Lorsque vous spécifiez un nom de projet et un nom de dossier pour un projet, n'autorisez pas les noms de dossier contenant des espaces ou des lettres qui ne sont pas latines.(la ligne "Nom de fichier résultant" ne doit pas contenir d'espaces dans les noms de dossiers, et ne doit pas non plus contenir de lettres autres que le latin).

Cliquez sur Suivant. La fenêtre suivante apparaîtra.

Laissez ces paramètres inchangés. Cliquez sur "Terminer". Le projet sera créé.

Dans la partie supérieure gauche (dans la fenêtre "Gestion") sera affiché le projet avec le dossier "Sources".

Vous devez cliquer sur «+» (ou double-cliquer sur un dossier) et ce dossier s'ouvrira.

Il contiendra un seul fichier main.c. Vous devez double-cliquer dessus, puis le champ d'édition s'ouvrira à droite, dans lequel le contenu de ce fichier sera affiché (en haut il y aura un onglet avec le nom du fichier).

La fenêtre d'édition affichera le texte du premier programme en surbrillance. Veuillez noter que différentes parties du texte utilisent des couleurs différentes pour faciliter la lecture du texte.

Il s'agit du premier programme simple qui affiche le texte "Bonjour tout le monde !" ("Bonjour le monde!"). Traditionnellement, c'est le programme qui est utilisé comme premier programme pour se familiariser avec un langage de programmation. Dans le cas de Code::Blocks, ce programme est automatiquement créé lorsque vous créez un nouveau projet.

La taille de la police dans la fenêtre d'édition peut être modifiée très facilement. Pour ce faire, faites tourner la molette de la souris tout en maintenant la touche Ctrl enfoncée.

Vous pouvez également utiliser le menu « Paramètres=>Éditeur » et, en cliquant sur le bouton « Choisir » en haut à droite, modifier non seulement la taille de la police, mais également la police elle-même. Gardez simplement à l’esprit que lors de l’écriture de programmes, il est préférable d’utiliser des polices dans lesquelles toutes les lettres ont la même largeur. Ces polices incluent, par exemple, les polices suivantes : Courier New, Courier, Liberation Mono, Lucida Console, Monospace, etc.

S'il s'avère que la fenêtre « Gestion » ou une autre fenêtre nécessaire manque à l'écran, vous devez alors sélectionner le menu Affichage et dans le menu qui apparaît, sélectionner l'élément correspondant à la fenêtre souhaitée.

Si du coup le projet était fermé, par exemple, lors de la sortie et de la rentrée de Code::Blocks, il peut être rouvert. Pour cela, sélectionnez le menu "Fichier=>Projets récents", puis, dans la liste qui apparaît, sélectionnez le projet souhaité. Ou vous pouvez utiliser le menu "Fichier=>Ouvrir", puis sélectionner le fichier Project01.cbp.

2.2 Construction et exécution du programme

Ce programme sera discuté en détail un peu plus tard, mais essayons maintenant de l'exécuter.

Pour ce faire, il faut le faire compilation texte du programme (compilation) et utilisation mise en page(Lien) un fichier exécutable avec l'extension .exe doit être créé, qui sera lancé. L'ensemble de ce processus de compilation et de liaison est appelé assemblée(Bâtiment).

Il convient de noter que le processus désigné ici par le mot Compilation est aussi souvent appelé le processus émissions. Il existe différentes variantes de terminologie dans ce domaine. Par exemple, le processus d'assemblage ci-dessus peut être appelé compilation, qui consiste à son tour en étapes de traduction et de liaison. Mais maintenant, nous n'aborderons pas les questions de terminologie et utiliserons simplement la version anglaise des termes comme base, bien entendu, avec une traduction en russe. Nous parlerons donc de assemblée(Bâtiment), composé d'étages compilation(Compilation) et mise en page(Mise en relation). Cette option dans ce cas semble plus pratique, puisque les noms correspondants en anglais peuvent être observés lors du processus d'assemblage.

L'environnement de développement intégré Code::Blocks vous permet d'automatiser l'assemblage et le lancement (Run) du programme. Pour créer et exécuter le programme, exécutez simplement la commande « Construire et exécuter » en appuyant sur le bouton ou sur la touche F9. Une autre option consiste à sélectionner le menu "Build=>Build and run".

Dans la fenêtre inférieure (messages sur le processus de construction), les mots « Compilation », « Liaison », etc. apparaîtront, qui reflètent la progression de la compilation et de la liaison du programme.

En conséquence, une fenêtre de console devrait apparaître, où en haut sera affichée la phrase spécifiée dans le programme entre guillemets, à savoir la phrase « Hello world ! »

Ainsi, le programme affiche la chaîne donnée à l'écran.

En dessous de cette ligne, il y aura deux lignes. Le premier affiche le code retour du programme et le temps passé à exécuter le programme. Le second affiche un message indiquant que vous devez appuyer sur n'importe quelle touche pour continuer. Ces deux lignes sont générées automatiquement si le programme est exécuté depuis Code::Blocks.

La police utilisée dans la fenêtre de la console peut être modifiée si nécessaire. Par exemple, dans le cas d'un système d'exploitation Windows, vous pouvez essayer les étapes suivantes.

Cliquez sur droite cliquez sur l'icône dans le coin supérieur gauche de la fenêtre de la console. Un menu contextuel devrait apparaître dans lequel vous devez sélectionner l'élément "Par défaut".

Une fenêtre de paramètres apparaîtra.

Dans cette fenêtre, vous devez sélectionner la police souhaitée (par exemple, Lucida Console). Ensuite, pour cette police, vous devez sélectionner la taille souhaitée (par exemple, 14). Après cela, vous devez cliquer sur « OK » pour enregistrer les paramètres.

Ensuite, vous devez fermer la fenêtre de la console en appuyant sur n'importe quelle touche.

Après cela, vous devez redémarrer le programme en appuyant sur le bouton ou sur la touche F9 (ou en sélectionnant le menu "Build=>Build and run").

La fenêtre de la console devrait maintenant avoir la nouvelle police.

2.3 Explication du programme

Désormais, après avoir lancé avec succès le programme et vérifié son fonctionnement, vous pouvez examiner de plus près les composants du programme qui ont été automatiquement créés lors de la création du projet. Regardons le texte de ce programme.

#inclure #inclure int main() { printf("Bonjour tout le monde !\n" ); renvoie 0 ; }

Le mot principal est donné dans lequel commence l'exécution de tout programme. Cela signifie la fonction principale à partir de laquelle tout commence. Il peut y avoir des appels à d'autres fonctions au sein de cette fonction, mais tout commence par l'exécution du contenu de main . Après le nom de cette fonction, il y a des parenthèses sans rien entre elles. Cela signifie que cette fonction n'a aucun argument. Chaque fonction doit avoir des parenthèses, même si elle n'a aucun argument.

Le contenu de la fonction, et dans ce cas le contenu de l'ensemble du programme, est situé entre les accolades. Ils correspondent au début et à la fin appliqués au langage Pascal.

Avant le nom main se trouve le mot int, qui spécifie le type de valeur renvoyée par la fonction. Dans ce cas, il s'agit d'un type entier (à l'avenir, différents types de données seront discutés séparément). La fonction principale (c'est-à-dire essentiellement le programme principal) renvoie le code de sortie du programme. Il est généralement admis qu'un programme doit renvoyer la valeur 0 lors d'une exécution normale. Le renvoi de cette valeur se fait en utilisant l'accolade fermante return 0.

Entre les accolades se trouve également un appel de fonction appelé printf . Cette fonction est utilisée dans ce cas pour afficher du texte à l'écran. Les parenthèses de cette fonction indiquent ses arguments. Ici, le seul argument est une chaîne entourée de guillemets doubles. C'est cette ligne qui est imprimée à l'écran par la fonction printf. Mais la combinaison de caractères \n ne s'affiche pas à l'écran. Cette combinaison indique un caractère de nouvelle ligne, qui n'est pas imprimé à l'écran, mais signifie qu'une nouvelle ligne doit être effectuée à cet emplacement.

Pour comprendre la signification du caractère de nouvelle ligne, essayez de supprimer la combinaison \n de la ligne, exécutez le programme et voyez le résultat. Essayez également d'utiliser la combinaison \n plusieurs fois de suite, exécutez le programme et voyez le résultat. Renvoyez ensuite la version originale du programme.

Il y a un point-virgule après l'appel de la fonction printf. Cela permet de séparer les différents opérateurs les uns des autres. Plus précisément, il sépare l'appel de la fonction printf de l'instruction return.

Reste à comprendre pourquoi la ligne de ce programme est nécessaire. Sans entrer dans les détails, on peut dire que la ligne est nécessaire pour permettre d'utiliser la fonction printf, puisque cette ligne permet d'obtenir des informations sur cette fonction. Cette ligne comprend le fichier stdio.h, dont le nom est indiqué entre parenthèses sous forme de caractères< и >. La commande #include indique l'inclusion de ce fichier. Cette connexion permet d'utiliser les fonctions déclarées dans ce fichier, notamment la fonction printf. La ligne de ce programme n'est généralement pas nécessaire, mais son principe de fonctionnement est similaire, seul un autre fichier (stdlib.h) est inclus ici.

2.4 Changement de programme

Vous pouvez maintenant passer à la modification du fichier main.c.

Vous pouvez saisir n'importe quel texte dans le champ d'édition, comme dans un éditeur classique. À l'avenir, les exemples de programmes et les fragments de programmes pourront être simplement collés dans le champ d'édition en copiant régulièrement des blocs de texte. Considérons une action similaire dans l'exemple suivant.

Le contenu du fichier main.c a été généré automatiquement. Mais un tel programme peut être écrit un peu plus brièvement, et également légèrement modifié en ajoutant des points d'exclamation.

#inclure int main()( printf("Bonjour tout le monde !!!\n" ); renvoie 0 ; )

Ce programme doit maintenant être transféré vers la fenêtre d'édition en utilisant une copie régulière. Pour ce faire, vous devez sélectionner le texte du programme et copier le texte sélectionné dans le presse-papiers, par exemple en cliquant sur le bouton droit de la souris et en sélectionnant « Copier » dans le menu). Ensuite, vous devez passer à la fenêtre d'édition Code::Blocks, surlignez le texte ici, et collez le texte depuis le presse-papier, par exemple en sélectionnant le menu "Edition=>Coller" ou en sélectionnant, après un clic droit, le menu "Edition=>Coller". Cette version du programme devrait apparaître dans la fenêtre d'édition.

Enregistrez la nouvelle version du programme. Pour cela, il suffit d'appuyer sur Ctrl-S (ou de sélectionner le menu "Fichier=>Enregistrer le fichier"). Entraînez-vous à enregistrer le fichier après chaque modification, même minime, du texte du programme. Sinon, lorsqu'il gèle, une certaine quantité de travail peut être perdue.

Essayez d'exécuter cette nouvelle version des programmes.

Tâches de maîtrise de soi

1. Modifiez le texte "Bonjour tout le monde !!!" vers une autre langue, tout en utilisant le russe. Exécutez le programme pour vérifier les modifications.
2. Remplacez la valeur 0 après le retour par une autre valeur numérique, par exemple 5. Exécutez le programme et vérifiez qu'après « Processus renvoyé », une nouvelle valeur numérique s'affiche dans la fenêtre de la console.
3. Assurez-vous que lorsque vous démarrez le programme, avant d'imprimer la ligne "Hello world !!!" il y a eu un décalage d'une ligne vers le bas sur l'écran. Pour ce faire, mettez \n au tout début de la ligne utilisée comme argument de la fonction printf. Exécutez le programme pour vous assurer que la tâche est terminée correctement.
4. Assurez-vous que lorsque vous démarrez le programme, avant d'imprimer la ligne "Hello World!" il y avait un décalage de plusieurs lignes sur l'écran. Pour cela, placez la combinaison \n plusieurs fois de suite au tout début de la ligne utilisée comme argument de la fonction printf (c'est-à-dire la chaîne située entre parenthèses entre guillemets). Exécutez le programme pour vous assurer que la tâche est terminée correctement.
5. Imprimez la ligne "Bonjour tout le monde !!!" trois fois sur trois lignes consécutives à l'écran (une copie par ligne), en plaçant la combinaison \n aux bons endroits.
6. Assurez-vous que lorsque vous démarrez le programme, la ligne "Hello world!!!" affiché exactement au centre de l’écran. Pour ce faire, vous devez déplacer la ligne vers le bas et vers la droite en utilisant \n et les espaces.
7. Affichez trois mots différents simultanément à trois endroits de l'écran : dans les coins supérieurs et au centre de l'écran. Utilisez deux appels printf d'affilée avec des chaînes différentes comme arguments, en utilisant \n et des espaces d'une manière spéciale dans chaque cas.

2.5 Exécuter un programme en dehors de l'environnement de développement dans le cas de Windows

Le dossier du projet, dont le chemin a été spécifié lors de la création du projet (voir), doit contenir le dossier bin/Debug. Et dans ce dossier, il devrait y avoir un fichier exécutable Project01.exe, obtenu à la suite de la construction du programme.

Ce fichier exécutable (application) peut être lancé par des moyens standards (par exemple, à l'aide de l'Explorateur), c'est-à-dire dehors Code :: Bloque l’environnement de développement. Par exemple, vous pouvez également créer un raccourci vers ce fichier et le placer sur votre bureau afin de pouvoir le lancer à partir de là.

Mais lorsqu'elle est lancée de cette manière, la fenêtre de la console avec la ligne de sortie apparaît et disparaît immédiatement, puisque le programme se termine immédiatement, sans attendre la commande de l'utilisateur. Pourquoi cela arrive-t-il? Le fait est que lors du lancement à partir de Code::Blocks, une attente pour appuyer sur n'importe quelle touche est automatiquement ajoutée, mais l'application elle-même ne le fournit pas.

Pour mettre en œuvre l'attente d'une touche enfoncée (dans le cas de Windows), vous devez modifier le programme en ajoutant plusieurs lignes. Il prendra alors la forme suivante.

#inclure #inclure int main () ( printf("Bonjour tout le monde!!!\n" ); getch(); return 0; )

Essayez d'exécuter ce programme à partir de Code :: Blocks. Pour ce faire, placez le programme spécifié dans le champ d'édition au lieu de disponible, et exécutez le programme en appuyant sur le bouton ou sur la touche F9 (ou en sélectionnant le menu "Build=>Build and run").

Notez qu'après avoir imprimé "Bonjour tout le monde !!!" Désormais, rien d'autre n'est imprimé car il attend qu'une touche soit enfoncée. Mais après avoir appuyé sur une touche, les deux lignes déjà familières sont affichées ("Processus renvoyé..." et "Appuyez sur n'importe quelle touche pour continuer."). Après ces lignes, nous attendons à nouveau une pression sur une touche (qui est fournie par l'environnement Code::Blocks).

Maintenant, si vous exécutez ce programme dehors Code::Blocks, en exécutant le fichier Project01.exe, le texte spécifié sera affiché dans la fenêtre et le programme attendra qu'une touche soit enfoncée pour terminer.

Pour modifier le programme de cette manière, deux lignes sont nécessaires : une contenant conio.h et une contenant getch . conio.h est nécessaire pour permettre d'appeler la fonction getch. Ceci revient à connecter stdio.h pour pouvoir appeler la fonction printf. La fonction getch attend une pression sur une touche.

De tels changements ne seront pas indiqués à l'avenir, mais si nécessaire, vous pouvez toujours les effectuer pour vous assurer de la même manière que vous attendez qu'une touche soit enfoncée avant de terminer le programme.

2.6 Messages sur les avertissements et les erreurs dans le programme

Lors de la construction d'un programme (lorsque vous essayez de l'exécuter après des modifications), des avertissements et des erreurs peuvent apparaître. Voyons comment cela se produit à l'aide d'un exemple. Essayez d'exécuter le programme suivant.

#inclure int main () ( printf("Bonjour tout le monde !!!\n" ); )

Ce programme ne contient pas de retour, mais il s'exécutera. Essayez de l'exécuter.

Cependant, lors de la compilation, un avertissement sera émis car il n'y a pas d'instruction return. Lorsque vous démarrez le programme, cet avertissement disparaît car il n'affecte pas le démarrage du programme. Mais il peut être lu si vous construisez uniquement le fichier (sans exécuter l'application). Pour cela, vous devez créer la commande « Build » en appuyant sur Ctrl-F9, ou en cliquant sur le bouton, ou en sélectionnant le menu « Build=>Build ».

Mais si le programme n’a pas changé depuis la version ou le lancement précédent, la nouvelle version ne sera pas exécutée. Et dans la fenêtre ci-dessous, un message s'affichera indiquant que l'assembly est déjà le plus récent et que rien d'autre ne doit être fait pour cette commande (« La cible est à jour. Rien à faire. »).

Dans ce cas, vous devez le remonter. Pour cela, vous devez créer la commande « Reconstruire » en appuyant sur Ctrl-F11, ou en cliquant sur le bouton, ou en sélectionnant le menu « Build=>Rebuild ». Une fois cette commande générée, une fenêtre apparaît pour la confirmer. Pour confirmer cette commande, cliquez sur « Oui » dans la fenêtre spécifiée.

Ensuite, dans la fenêtre inférieure, vous pouvez voir une ligne avec un avertissement (bleu), ainsi qu'un message concernant la présence d'un avertissement (1 avertissements).

En général, un avertissement permet l'exécution du programme, mais alerte le programmeur d'éventuelles erreurs ou inexactitudes.

À l'avenir, l'instruction return de la fonction main ne pourra plus être utilisée par souci de concision, comme c'est le cas dans . Mais il faut tenir compte du fait que cela provoque l'apparition d'un avertissement.

Essayez maintenant d'exécuter le programme suivant.

#inclure int main() ( printf( Bonjour tout le monde !!!\n); }

Notez que le programme ne démarre pas. Au lieu de cela, des lignes en rouge apparaîtront dans la fenêtre inférieure indiquant les erreurs.

La ligne du programme où il y a une erreur est mise en évidence par un carré rouge.

Il convient de garder à l'esprit qu'une erreur valide peut entraîner plusieurs messages d'erreur à la fois. Dans cet exemple, 5 erreurs sont générées, donc 5 lignes sont affichées en rouge.

En comparant le programme, il n'est pas difficile de comprendre que l'erreur est due au fait que les guillemets ne sont pas spécifiés. En conséquence, l'erreur "Bonjour" non déclarée s'affiche. Le mot « non déclaré » signifie « non déclaré », c'est-à-dire que le compilateur essaie de comprendre ce que signifie Hello et ce qu'il doit faire. Il ne peut pas trouver ce mot parmi les mots connus, il génère donc une erreur. Si ce mot est entre guillemets doubles, alors il est perçu comme une chaîne à l'intérieur de laquelle tout peut se trouver. La chaîne peut être affichée à l'écran. Par conséquent, après avoir corrigé le programme (en ajoutant des guillemets si nécessaire), tout devrait bien se passer.

Corrigez le programme et vérifiez qu'il fonctionne correctement.

Tâches de maîtrise de soi

1. Essayez de supprimer la dernière accolade et d'exécuter le programme. Notez que l'erreur est notée sur la ligne contenant printf , qui est la ligne précédente. Restaurez le bon programme.
2. Essayez de supprimer les deux parenthèses après main . Notez que l’erreur est notée sur la ligne contenant l’accolade, qui est la ligne suivante. Restaurez le bon programme.
3. Essayez de supprimer la première parenthèse après main . Notez que l'erreur est notée sur la ligne contenant main , qui est la même ligne. Restaurez le bon programme.

En considérant les tâches de maîtrise de soi, il est facile de voir qu'une erreur peut être contenue à côté de la ligne marquée d'un carré rouge. Ainsi, lorsqu’une erreur survient, les lignes adjacentes doivent également être analysées.

3 Informations de base

3.1 Nombres entiers

Pour travailler avec des données, en particulier avec des nombres entiers, vous aurez besoin de variables utilisées pour stocker ces nombres. Tout d’abord, vous devez déclarer une variable afin de commencer à travailler avec elle.

La déclaration des variables se fait comme suit.

type_variable nom_variable ;

Par exemple, la variable entière a est déclarée comme suit.

int un ;

Dans ce cas, la variable a est de type int , ce qui désigne un type entier.

Une déclaration de variable spécifie un bloc de mémoire pour stocker les données du type spécifié. Naturellement, vous pouvez sélectionner plusieurs blocs similaires. Pour les distinguer les uns des autres, ces blocs sont nommés. Par exemple, la déclaration de int a alloue un bloc portant le nom a, la déclaration de int b alloue un bloc portant le nom b, etc. Dans ce cas, vous pouvez déclarer simultanément plusieurs variables, c'est-à-dire sélectionner plusieurs blocs du même type avec des noms différents. Pour ce faire, les noms de ces blocs sont répertoriés, séparés par des virgules, après la désignation du type.

int x, y, z ;

Cette déclaration identifie trois blocs différents du même type avec des noms différents.

Pour écrire une valeur dans un bloc de données sélectionné, vous devez affecter cette valeur à la variable correspondante, par exemple l'expression

attribue à la variable a la valeur 10. Vous pouvez également attribuer à une variable la valeur d'une autre variable, par exemple l'expression

attribue à la variable a la valeur de la variable b. Vous pouvez attribuer la même valeur à plusieurs variables à la fois. Pour ce faire, vous pouvez par exemple utiliser l'expression suivante.

X = y = z = 100 ;

N'oubliez pas qu'une variable ne peut se voir attribuer une valeur que si la variable a été déclarée (plus précisément, son type a été spécifié).

La valeur d'une variable peut être imprimée à l'écran à l'aide de la fonction printf. A titre d'exemple, vérifiez l'exécution du programme suivant.

#inclure int main()( int un ; /* déclaration de variable a*/ une = 10 ; printf( "Valeur variable a = %d\n", un); }

Veuillez noter que dans le programme il y a un commentaire « déclarer la variable a ». Un commentaire est un fragment nécessaire pour décrire une partie particulière du programme. Le commentaire n'affecte pas le programme final, il s'agit simplement d'un ajout au texte, qui n'est pas utilisé ultérieurement lors de l'exécution du programme. Un commentaire doit commencer par la combinaison de caractères /* et se terminer par la combinaison de caractères */. Dans ce cas, le commentaire peut être localisé sur plusieurs lignes ; pour cela, la combinaison /* sera située au début de la première ligne du commentaire, et la combinaison */ sera située à la fin de la dernière ligne de le commentaire.

Au tout début de la fonction principale, la variable a. Cette variable a alors la valeur 10. Dans la ligne suivante, utilisez la fonction printf pour afficher la valeur de la variable à l'écran. Pour ce faire, ajoutez un argument supplémentaire à la fonction printf, séparé par une virgule après la chaîne citée. Cet argument supplémentaire est la variable a elle-même, dont la valeur doit être imprimée à l'écran. Pour indiquer à la fonction printf où imprimer la valeur d'une variable, une combinaison de deux caractères, à savoir %d , est ajoutée à la chaîne de sortie. Ces caractères eux-mêmes ne seront pas affichés à l'écran, mais à leur place la valeur de la variable séparée par une virgule après la ligne sera affichée. Exécutez le programme et vérifiez son fonctionnement.

Lorsque vous tapez un programme, notez que les lettres minuscules et majuscules sont des lettres différentes du point de vue du compilateur. Par conséquent, par exemple, taper Main au lieu de main entraînera une erreur.

Tâches de maîtrise de soi

1. Remplacez la valeur de la variable a par une autre valeur et
2. Essayez d'ajouter des commentaires à différentes parties du programme. Assurez-vous qu'ils n'affectent pas l'exécution du programme. Vérifiez l’utilisation de commentaires s’étendant sur plusieurs lignes.
3. Vérifiez ce qui se passe lorsque vous modifiez la casse d'une lettre particulière, c'est-à-dire, par exemple, lorsque vous changez une petite lettre en grande lettre et vice versa.

Pour déclarer la variable a et l'initialiser, on obtient deux lignes consécutives ( et ). Mais vous pouvez combiner déclaration de variable et initialisation. Au lieu des deux lignes indiquées, vous ne pouvez écrire qu'une seule ligne du type suivant.

entier a = 10 ;

Vérifiez que le programme fonctionne correctement après un tel changement.

La fonction printf peut également imprimer les valeurs de plusieurs variables à la fois. Pour tester cette possibilité, déclarez la variable b et attribuez une valeur à cette variable avant d'appeler la fonction printf. Il est important de noter qu'une déclaration de variable peut apparaître n'importe où à l'intérieur des accolades d'une fonction, en particulier la fonction principale. Après cela, convertissez la chaîne de fonction printf comme suit.

Printf("a = %d, b = %d \n" , a, b);

Vérifiez que le programme fonctionne correctement.

Ainsi, pour afficher les valeurs de plusieurs variables à la fois, vous devez disposer les caractères de sortie formatés %d dans la ligne de sortie en conséquence, et également répertorier les variables séparées par des virgules immédiatement après la ligne de sortie dans l'ordre de sortie. Ensuite, à la place de chaque combinaison %d, la valeur de la variable suivante de la liste des variables, séparée par des virgules, sera remplacée.

Dans ce cas, vous pouvez également spécifier une expression comme argument de la fonction printf. Par exemple, pour mettre au carré et au cube une variable, vous pouvez utiliser le signe * pour indiquer la multiplication. Ajoutez l'extrait suivant après l'appel de fonction printf existant.

Imprimerf( "a = %d\n(a au carré) = %d\n(a au cube) = %d\n", une, une * une, une * une * une);

Vérifiez que le programme fonctionne correctement.

Notez que si un appel de fonction est une ligne trop longue, alors il est pratique de le diviser en plusieurs lignes, séparées par des virgules. Par exemple, comme cela a été fait dans ce texte, mais le même fragment peut être écrit sur une seule ligne à la demande du programmeur.

3.2 Expressions arithmétiques

Maintenant, pour mettre au carré ou au cube un entier, il suffit de corriger l'affectation initiale à la variable a et de réexécuter le programme. Expérimentez avec ceci. En plus de la mise au carré et du cube, vous pouvez utiliser diverses expressions basées sur des opérations arithmétiques : +, -, *, /.

Tâches de maîtrise de soi

1. Implémentez le calcul d'une formule qui utilise les 4 opérations arithmétiques. Définissez la valeur de la variable dans le programme. Vérifiez que cette formule est calculée correctement.
2. Calculez une formule à partir de deux variables. Définissez les valeurs des variables dans le programme.

Le langage C a également la capacité d’écrire de manière plus concise certaines constructions fréquemment utilisées. Ainsi, pour augmenter une variable d’une valeur donnée, l’opération += est utilisée. Il s'avère que l'expression

Un += 10 ;

est équivalent à l'expression

A = a + 10 ;

dans ce cas, de la même manière, au lieu du signe +, il peut également y avoir des signes -, *, /, ainsi que d'autres signes d'opération.

Le fragment de programme suivant illustre des exemples d'utilisation de ces fonctionnalités, avec des commentaires indiquant les valeurs que prend la variable à la suite du calcul de l'expression arithmétique.

entier je = 10 ; je = (je * 2 + 1) / 3 - 5 ; /* je = 2 */ je += 5; /* je = 7 */ int j = 3; je *= j; /* je = 21 */ je /= 7; /* je = 3 */

Tâche de maîtrise de soi

1. Implémentez le calcul d'une formule qui utilise les capacités spécifiées (une forme plus concise d'écriture de certaines expressions arithmétiques).

De plus, l'expression

désigne une augmentation de la variable a de 1, ce qui équivaut à l'expression

UNE = une + 1;

De même, l'expression

ici signifie diminuer de 1.

Il est important de noter qu'il existe également des expressions de la forme

A++ ; un--;

Ils indiquent également une augmentation de 1 et une diminution de 1.

Cependant, il existe une différence entre les formes préfixe (++a) et suffixe (a++) dans les expressions plus complexes.

Quand préfixe form (++a) augmente (diminue) d'abord de 1, puis évalue le reste de l'expression.

Quand suffixe(a++), l'expression est d'abord évaluée puis incrémentée (décrémentée) de 1.

L'exemple suivant illustre cette différence.

Regardons le même fragment où ++y (forme de préfixe) est utilisé.

entier x = 10 ; entier y = 2 ; x = x * (++y); printf("x = %d y = %d\n" , x, y);

X = 30 et oui = 3

Ici, d'abord y dû à ++y recevra la valeur 3, et après cela la multiplication de 10 par 3 se produira.

Regardons le même fragment où y++ (forme postfix) est utilisé.

entier x = 10 ; entier y = 2 ; x = x * (y++); printf("x = %d y = %d\n" , x, y);

Lors de l'exécution de ce fragment, la ligne suivante s'affichera à l'écran.

X = 20 et = 3

Ici, 10 sera d'abord multiplié par la valeur de y égale à 2, puis y++ sera exécuté.

Il convient de noter que dans ces fragments, il n'est pas du tout nécessaire de mettre des parenthèses autour de ++y et y++ .

Tâches de maîtrise de soi

1. Vérifiez l'exécution des fragments de programme spécifiés. Il ne faut pas oublier qu'il ne s'agit que de fragments de programmes. Ils doivent être ajoutés à l’intérieur des accolades de la fonction principale.
2. Essayez de supprimer les parenthèses autour de ++y et y++ dans ces fragments. Assurez-vous que le résultat ne change pas.

3.3 Types d'entiers

Jusqu’à présent, nous n’avons considéré que le type int pour les entiers. Quelles sont les valeurs maximales pouvant être définies pour une variable int ?

Garanti vous pouvez définir des valeurs comprises entre -32768 et 32767, puisqu'une variable int est allouée pas moins 16 bits.

Mais de nos jours, vous verrez souvent des implémentations de compilateur qui allouent 32 bits à une variable int, ce qui signifie que la variable peut prendre des valeurs comprises entre -2147483648 et 2147483647.

Cependant, vous pouvez être absolument sûr que la plage de valeurs valides pour la variable x ne sera pas inférieure à la plage allant de -32768 à 32767.

Lorsque vous utilisez la version proposée de Code::Blocks et le compilateur gcc qui l'accompagne (ou un compilateur similaire précédemment installé), vous vous retrouverez très probablement dans une situation où une variable int peut prendre des valeurs comprises dans la plage -2147483648. au 2147483647.

Vérifions cela avec l'exemple suivant.

#inclure int main () ( int x1 = -2147483648; int x2 = 2147483647; printf("x1 = %d x2 = %d\n" , x1, x2); )

X1 = -2147483648 x2 = 2147483647

Si tel est le cas, cela montre qu'une variable de type int peut prendre de telles valeurs.

Maintenant, avant la ligne printf, vous pouvez définir la variable x2 sur 1

#inclure int main () ( int x1 = -2147483648; int x2 = 2147483647; ++x2; printf("x1 = %d x2 = %d\n" , x1, x2); )

Lorsque vous exécutez ce programme, la ligne suivante sera probablement imprimée.

X1 = -2147483648 x2 = -2147483648

Notez que la valeur de x2 est devenue une valeur limite négative. On peut dire qu'en essayant d'ajouter 1 à la valeur positive maximale (valeur 2147483647), la valeur est sortie hors plage et la valeur est passée "circulairement" à la valeur négative maximale (valeur -2147483648). Ce qu'on appelle s'est produit débordement.

Si vous augmentez x2 non pas de 1, mais de 2, alors la variable x2 prendra la valeur -2147483647 (qui est différente de 1 de la valeur négative maximale). Vérifie ça.

Si vous augmentez x2 non pas de 1, mais de 3, alors la variable x2 prendra la valeur -2147483646 (qui est différente de 2 de la valeur négative maximale). Vérifie ça.

Ainsi, vous pourrez comprendre le principe de comportement des variables entières en cas de débordement.

Tâches de maîtrise de soi

1. De même, vérifiez le débordement de la variable x1 vers la valeur extrême négative, c'est-à-dire en soustrayant un certain nombre à cette variable.
2. Un débordement se produit également lorsque vous essayez simplement d'attribuer une valeur à une variable qui se situe en dehors de la plage autorisée. Vérifie ça.

En plus du type int, il existe d'autres types entiers pour déclarer des variables.

Par exemple, le type long permet de garantir -2147483648 à 2147483647 (le type int n'offre pas cette garantie pour tous les compilateurs).

Également dans les compilateurs modernes du langage C, le type long long (écrit en deux mots) est apparu, qui alloue 64 bits pour une variable. Et cela correspond à la plage de nombres allant de -9223372036854775808 à 9223372036854775807.

Vérifions ce type en utilisant le programme suivant comme exemple.

#inclure int main() ( long long x1 = -9223372036854775808; long long x2 = 9223372036854775807; printf("x1 = %lld x2 = %lld\n" , x1, x2); }

X1 = -9223372036854775808 x2 = 9223372036854775807

Notez que dans ce cas, lors de l'appel de la fonction printf, la combinaison de caractères est %lld , et non %d . Ceci est nécessaire pour que la fonction printf affiche correctement un grand nombre de types long long .

Tâches de maîtrise de soi

1. De même, vérifiez le débordement de variables de type long long dans cet exemple (comme ce fut le cas avec les variables de type int).
2. Essayez d'utiliser %d au lieu de %lld dans la fonction printf de cet exemple.

De plus, vous pouvez créer de nouveaux types entiers en ajoutant le mot-clé non signé avant son nom, ce qui déplace la plage de valeurs possibles vers la région positive, c'est-à-dire rendant le type non signé. L'exemple de programme suivant explique cela.

#inclure int main() (int non signé x1 = 0 ; int non signé x2 = 4294967295 ; printf("x1 = %u x2 = %u\n" , x1, x2); }

Lorsque ce programme est exécuté, une chaîne doit être imprimée.

X1 = 0 x2 = 4294967295

Notez que dans ce cas, lors de l'appel de la fonction printf, la combinaison de caractères est %u et non %d. Ceci est nécessaire pour que la fonction printf affiche correctement les nombres correspondant à un type non signé.

Tâches de maîtrise de soi

1. De même, vérifiez le débordement de variables de type unsigned int dans cet exemple (comme ce fut le cas avec les variables de type int).
2. Essayez d'utiliser %d au lieu de %u dans la fonction printf dans cet exemple.
3. A partir de cet exemple, essayez d'afficher la valeur maximale pouvant être écrite dans une variable de type unsigned long long (à savoir le nombre 18446744073709551615). Pour un affichage correct, la fonction printf utilise la combinaison de caractères %llu (au lieu de %u).

3.4 Nombres réels

Pour spécifier des nombres réels, vous pouvez utiliser le type float ou le type double. Dans ce cas, une variable de type float occupe 4 octets, et une variable de type double occupe 8 octets. Par conséquent, en général, le type double offre une gamme plus large de nombres possibles et plus de décimales après la virgule, mais il présente l'inconvénient d'une consommation de mémoire deux fois supérieure à celle du type float.

Il existe également le type long double, et une variable de ce type peut occuper de 8 à 16 octets, selon l'implémentation du compilateur. Par conséquent, le type long double offre souvent une précision encore plus grande en échange d’une plus grande consommation de mémoire.

Vérifions l'exécution du programme suivant.

#inclure int main () ( double x = 10,5; printf("x = %f\n" , x); )

L'écran affichera :

X = 10,500000

Notez que %f est utilisé à la place de %d, en raison de l'utilisation d'un type réel au lieu d'un entier. Vérifiez ce qui se passe si vous mettez %d au lieu de %f .

Comment supprimer les zéros supplémentaires lors de l’affichage d’un nombre ? Pour ce faire, vous pouvez spécifier le nombre de chiffres après la virgule, par exemple comme suit.

Printf("x = %.1f \n" ,x);

Dans ce cas, le nombre après le point indique le nombre de chiffres après la virgule décimale. Expérimentez avec ceci.

De plus, vous pouvez définir le nombre de caractères utilisés pour afficher le numéro, par exemple, vous pouvez définir ce numéro sur 10 comme suit.

Printf("x = %10.1f \n" ,x);

Vérifiez ce qui change.

De plus, au lieu de la lettre f, qui va en combinaison avec %, vous pouvez utiliser la lettre e pour afficher un nombre sous forme exponentielle, ainsi que la lettre g pour sélectionner automatiquement le format de sortie en fonction de la valeur du nombre. De plus, les lettres E et G peuvent également être utilisées.

Tâches de maîtrise de soi

1. Essayez différentes variantes d'écriture d'un nombre réel et voyez ce qui se passe (y compris en utilisant les lettres e et g au lieu de f en combinaison avec %).
2. Déterminez vous-même quelles sont les conséquences de l'utilisation des lettres E et G par rapport aux lettres e et g.
3. Implémentez le carré et le cube d'un nombre réel, en vous assurant que les valeurs résultantes sont affichées à l'écran. Sélectionnez le format de sortie de nombres réels approprié.