text: C est un langage de programmation impératif, généraliste et de bas niveau. Inventé au début des années 1970 pour réécrire Unix, C est devenu un des langages les plus utilisés, encore de nos jours. De nombreux langages plus modernes comme C++, C#, Java et PHP ou JavaScript ont repris une syntaxe similaire au C et reprennent en partie sa logique. C offre au développeur une marge de contrôle importante sur la machine (notamment sur la gestion de la mémoire) et est de ce fait utilisé pour réaliser les « fondations » (compilateurs, interpréteurs...) de ces langages plus modernes. Histoire Le langage C a été inventé au cours de l'année 1972 dans les Laboratoires Bell. Il était développé en même temps qu'Unix par Dennis Ritchie et Ken Thompson. Kenneth Thompson avait développé le prédécesseur direct de C, le langage B, qui est lui-même largement inspiré de BCPL. Dennis Ritchie a fait évoluer le langage B dans une nouvelle version suffisamment différente, en ajoutant notamment les types, pour qu'elle soit appelée C. Bien que C soit directement dérivé de B, Ritchie relève aussi des influences de PL/I, FORTRAN et ALGOL 68. En outre, Ritchie signale que l'équipe était convaincue du bien-fondé de l'idée d'écrire un système d'exploitation dans un langage de plus haut niveau que l'assembleur, un aspect pionnier de Multics, écrit en PL/I. Par la suite, Brian Kernighan aida à populariser le langage C. Il procéda aussi à quelques modifications de dernière minute. En 1978, Kernighan fut le principal auteur du livre décrivant le langage enfin stabilisé ; Ritchie s'était occupé des appendices et des exemples avec Unix. On appelle aussi ce livre « le K&R », et l'on parle de C traditionnel ou de C K&R lorsqu'on se réfère au langage tel qu'il existait à cette époque. Normalisation En 1983, l'Institut national américain de normalisation (ANSI) a formé un comité de normalisation (X3J11) du langage qui a abouti en 1989 à la norme dite ANSI C ou C89 (formellement ANSI X3.159-1989). En 1990, cette norme a également été adoptée par l'Organisation internationale de normalisation (C90, C ISO, formellement ISO/CEI 9899:1990). ANSI C est une évolution du C K&R qui reste extrêmement compatible. Elle reprend quelques idées de C++, notamment la notion de prototype et les qualificateurs de type. Entre 1994 et 1996, le groupe de travail de l'ISO (ISO/CEI JTC1/SC22/WG14) a publié deux correctifs et un amendement à C90 : ISO/CEI 9899/COR1:1994 Technical Corrigendum 1, ISO/CEI 9899/AMD1:1995 Intégrité de C et ISO/CEI 9899/COR1:1996 Technical Corrigendum 2. Ces changements assez modestes sont parfois appelés C89 avec amendement 1, ou C94 / C95. Trois fichiers d'entêtes ont été ajoutés, dont deux concernant les caractères larges et un autre définissant un certain nombre de macros en rapport avec la norme de caractères ISO 646. En 1999, une nouvelle évolution du langage est normalisée par l'ISO : C99 (formellement ISO/CEI 9899:1999). Les nouveautés portent notamment sur les tableaux de taille variable, les pointeurs restreints, les nombres complexes, les littéraux composés, les déclarations mélangées avec les instructions, les fonctions inline, le support avancé des nombres flottants, et la syntaxe de commentaire de C++. La bibliothèque standard du C a été enrichie de six fichiers d'en-tête depuis la précédente norme. En 2011, l'ISO ratifie une nouvelle version du standard : C11, formellement ISO/CEI 9899:2011. Cette évolution introduit notamment le support de la programmation multi-thread, les expressions à type générique, et un meilleur support d'Unicode. En 2018, l'ISO ratifie une nouvelle version : formellement ISO/IEC 9899:2018, connue aussi comme C18 ou C17. Cette évolution s'attache à préciser et corriger les points litigieux, et n'introduit aucune nouveauté fonctionnelle. Une prochaine version, connue sous les noms de code C23 et C2x, est en cours de développement. Caractéristiques générales C'est un langage de programmation procédural et généraliste. Il est qualifié de langage de bas niveau dans le sens où chaque instruction du langage est conçue pour être compilée en un nombre d'instructions machine assez prévisible en termes d'occupation mémoire et de charge de calcul. En outre, il propose un éventail de types entiers et flottants conçus pour pouvoir correspondre directement aux types de donnée supportés par le processeur. Enfin, il fait un usage intensif des calculs d'adresse mémoire avec la notion de pointeur. Hormis les types de base, C supporte les types énumérés, composés, et opaques. Il ne propose en revanche aucune opération qui traite directement des objets de plus haut niveau (fichier informatique, chaîne de caractères, liste, table de hachage...). Ces types plus évolués doivent être traités en manipulant des pointeurs et des types composés. De même, le langage ne propose pas en standard la gestion de la programmation orientée objet, ni de système de gestion d'exceptions. Il existe des fonctions standards pour gérer les entrées-sorties et les chaînes de caractères, mais contrairement à d'autres langages, aucun opérateur spécifique pour améliorer l'ergonomie. Ceci rend aisé le remplacement des fonctions standards par des fonctions spécifiquement conçues pour un programme donné. Ces caractéristiques en font un langage privilégié quand on cherche à maîtriser les ressources matérielles utilisées, le langage machine et les données binaires générées par les compilateurs étant relativement prévisibles. Ce langage est donc extrêmement utilisé dans des domaines comme la programmation embarquée sur microcontrôleurs, les calculs intensifs, l'écriture de systèmes d'exploitation et les modules où la rapidité de traitement est importante. Il constitue une bonne alternative au langage d'assemblage dans ces domaines, avec les avantages d'une syntaxe plus expressive et de la portabilité du code source. Le langage C a été inventé pour écrire le système d'exploitation Unix, et reste utilisé pour la programmation système. Ainsi le noyau de grands systèmes d'exploitation comme Windows et Linux sont développés en grande partie en C. En contrepartie, la mise au point de programmes en C, surtout s'ils utilisent des structures de données complexes, est plus difficile qu'avec des langages de plus haut niveau. En effet, dans un souci de performance, le langage C impose à l'utilisateur de programmer certains traitements (libération de la mémoire, vérification de la validité des indices sur les tableaux...) qui sont pris en charge automatiquement dans les langages de haut niveau. Dépouillé des commodités apportées par sa bibliothèque standard, C est un langage simple, et son compilateur l'est également. Cela se ressent au niveau du temps de développement d'un compilateur C pour une nouvelle architecture de processeur : Kernighan et Ritchie estimaient qu'il pouvait être développé en deux mois car Qualités et défauts C'est un des langages les plus utilisés car : il existe depuis longtemps, le début des années 1970 ; il est fondé sur un standard ouvert ; de nombreux informaticiens le connaissent ; il permet la minimisation de l'allocation mémoire nécessaire, son contrôle complet et la maximisation de la performance, notamment par l'utilisation de pointeurs ; il permet la construction de structures de données complexes et ad-hoc, au plus près des besoins ; des compilateurs et bibliothèques logicielles existent sur la plupart des architectures ; il a influencé de nombreux langages plus récents dont C++, Java, C# et PHP ; sa syntaxe en particulier est largement reprise ; il met en œuvre un nombre restreint de concepts, ce qui facilite sa maîtrise et l'écriture de compilateurs simples et rapides ; il ne spécifie pas rigidement le comportement du fichier exécutable produit, ce qui aide à tirer parti des capacités propres à chaque ordinateur ; il permet, par la compilation directe vers le langage machine (via l'assembleur), l'écriture de logiciels qui n'ont besoin d'aucun support à l'exécution (ni bibliothèque logicielle ni machine virtuelle), au comportement prévisible en temps d'exécution comme en consommation de mémoire vive, comme des noyaux de système d'exploitation et des logiciels embarqués. Ses principaux inconvénients sont : le peu de vérifications offertes par les compilateurs d'origine (K&R C), et l'absence de vérifications à l'exécution, ce qui fait que des erreurs qui auraient pu être automatiquement détectées lors du développement ne l’étaient qu’à l'exécution, donc au prix d’un plantage du logiciel ; sous UNIX, on pouvait utiliser les utilitaires lint et cflow pour éviter de tels mécomptes, des vérifications sont ajoutées avec le temps, mais elles restent partielles, son approche de la modularité restée au niveau de ce qui se faisait au début des années 1970, et largement dépassée depuis par d'autres langages : il ne facilite pas la programmation orientée objet, il ne permet pas de créer des espaces de noms, la gestion d'exceptions très sommaire ; le support très limité de la généricité, malgré l’introduction des expressions à type générique en C11 ; les subtilités de l'écriture de programmes portables, car le comportement exact des exécutables dépend de l'ordinateur cible ; le support minimaliste de l'allocation de mémoire et des chaînes de caractères, ce qui oblige les programmeurs à s'occuper de détails fastidieux et sources de bugs ; il n'y a notamment pas de ramasse-miettes standard ; les bugs graves qui peuvent être causés par un simple manque d'attention du développeur ; tel le dépassement de tampon qui constitue une faille de sécurité informatique exploitable par les logiciels malveillants ; certaines erreurs ne peuvent être détectées automatiquement qu'à l'aide d'outils supplémentaires et non standardisés, comme lint et Valgrind ; la faible productivité du langage par rapport aux langages plus récents. Aperçu de la syntaxe Le programme est proposé en exemple en 1978 dans de Brian Kernighan et Dennis Ritchie. Créer un programme affichant « » est depuis devenu l'exemple de référence pour présenter les bases d'un nouveau langage. Voici l'exemple original de la de 1978 : main() { printf("hello, world "); } main est le nom de la fonction principale, aussi appelée point d'entrée du programme. Les parenthèses () après main indiquent qu'il s'agit d'une fonction. Les accolades { et } entourent les instructions constituant le corps de la fonction. printf est une fonction d'écriture dans la sortie standard, qui produit l'affichage dans la console par défaut. Les caractères " délimitent une chaîne de caractères ; hello, world dans ce cas. Les caractères sont une séquence d'échappement représentant le saut de ligne. Un point-virgule ; termine l'instruction expression. Évolution des pratiques Le même programme, conforme à la norme ISO et suivant les bonnes pratiques contemporaines : #include <stdio.h> int main(void) { printf("hello, world "); return 0; } #include <stdio.h> inclut l'en-tête standard <stdio.h> contenant les déclarations des fonctions d'entrées-sorties de la bibliothèque standard du C, dont la fonction printf utilisée ici. int est le type renvoyé par la fonction main. Le type int est le type implicite en K&R C et en C89, et il était couramment omis du temps où l'exemple de Kernighan et Ritchie a été écrit. Il est obligatoire en C99. Le mot-clé void entre parenthèses signifie que la fonction n'a aucun paramètre. Il peut être omis sans ambiguïté lors de la définition d'une fonction. En revanche, s'il est omis lors de la déclaration de la fonction, cela signifie que la fonction peut recevoir n'importe quels paramètres. Cette particularité de la déclaration est considérée comme obsolète dans le standard en C 2011. On peut noter que dans le standard MISRA C 2004, qui impose des restrictions au C89 pour des usages nécessitant une plus grande sûreté, le mot-clé void est obligatoire à la déclaration comme à la définition d'une fonction sans arguments. L'instruction return 0; indique que la fonction main retourne la valeur 0. Cette valeur est de type int, et correspond au int devant le main. Brièveté de la syntaxe La syntaxe de C a été conçue pour être brève. Historiquement, elle a souvent été opposée à celle de Pascal, langage impératif également créé dans les années 1970. Voici un exemple avec une fonction factorielle : /* En C (norme ISO) */ int factorielle(int n) { if (n > 0) return n * factorielle(n - 1); else return 1; } { En Pascal } function factorielle(n: integer) : integer begin if n > 0 then factorielle := n * factorielle(n - 1) else factorielle := 1 end. Là où Pascal utilise des mots clés function, integer, begin, if, then, else et end, C n'utilise que int, if, else et return, les autres mots clés étant remplacés par des parenthèses et accolades. Langage d'expressions La brièveté de C ne repose pas que sur la syntaxe. Le grand nombre d'opérateurs disponibles, le fait que la plupart des instructions contiennent une expression, que les expressions produisent presque toujours une valeur, et que les instructions de test se contentent de comparer la valeur de l'expression testée avec zéro, concourent à la brièveté du code source. Voici l'exemple de fonction de copie de chaîne de caractères donné dans The C Programming Language, edition, : void strcpy(char *s, char *t) { while (*s++ = *t++) ; } La boucle while utilise un style d'écriture classique en C, qui a contribué à lui donner une réputation de langage peu lisible. L'expression *s++ = *t++ contient : deux déréférencements de pointeur ; deux incrémentations de pointeur ; une affectation ; et la valeur affectée est comparée avec zéro par le while. Cette boucle n'a pas de corps, car toutes les opérations sont effectuées dans l'expression de test du while. On considère qu'il faut maîtriser ce genre de notation pour maîtriser le C. Pour comparaison, une version n'utilisant pas les opérateurs raccourcis ni la comparaison implicite à zéro donnerait : void strcpy(char *s, char *t) { while (*t != '\0') { *s = *t; s = s + 1; t = t + 1; } *s = *t; } Des sources à l'exécutable Sources Un programme écrit en C est généralement réparti en plusieurs fichiers sources compilés séparément. Les fichiers sources C sont des fichiers texte, généralement dans le codage des caractères du système hôte. Ils peuvent être écrits avec un simple éditeur de texte. Il existe de nombreux éditeurs, voire des environnements de développement intégrés (IDE), qui ont des fonctions spécifiques pour supporter l'écriture de sources en C. L'usage est de donner les extensions de nom de fichier .c et .h aux fichiers source C. Les fichiers .h sont appelés fichiers d'en-tête, de l'anglais header. Ils sont conçus pour être inclus au début des fichiers source, et contiennent uniquement des déclarations. Lorsqu'un fichier .c ou .h utilise un identificateur déclaré dans un autre fichier .h, alors il inclut ce dernier. Le principe généralement appliqué consiste à écrire un fichier .h pour chaque fichier .c, et à déclarer dans le fichier .h tout ce qui est exporté par le fichier .c. La génération d'un exécutable à partir des fichiers sources se fait en plusieurs étapes, qui sont souvent automatisées à l'aide d'outils comme make, SCons, ou bien des outils spécifiques à un environnement de développement intégré. Les étapes menant des sources au fichier exécutable sont au nombre de quatre : précompilation, compilation, assemblage, édition de liens. Lorsqu'un projet est compilé, seuls les fichiers .c font partie de la liste des fichiers à compiler ; les fichiers .h sont inclus par les directives du préprocesseur contenues dans les fichiers source. Précompilation Le préprocesseur C exécute des directives contenues dans les fichiers sources. Il les reconnaît au fait qu'elles sont en début de ligne, et commencent toutes avec le caractère croisillon #. Parmi les directives les plus courantes, il y a : #include pour l'inclusion ; #define pour la définition de macro ; #if pour commencer la compilation conditionnelle ; #ifdef et #ifndef, équivalents à #if defined et #if ! defined; #endif pour clore la compilation conditionnelle. Outre l'exécution des directives, le préprocesseur remplace les commentaires par un espace blanc, et procède au remplacement des macros. Pour le reste, le code source est transmis tel quel au compilateur pour la phase suivante. Il faut toutefois que chaque #include dans le code source soit récursivement remplacé par le code source inclus. Ainsi, le compilateur reçoit un seul source du préprocesseur, qui constitue l'unité de compilation. Voici un exemple de fichier source copyarray.h faisant un usage classique des directives du préprocesseur : #ifndef COPYARRAY_H #define COPYARRAY_H #include <stddef.h> void copyArray(int* , int* , size_t); #endif Les directives #ifndef, #define et #endif garantissent que le code à l'intérieur n'est compilé qu'une seule fois même s'il est inclus plusieurs fois. La directive #include <stddef.h> inclut l'en-tête qui déclare le type size_t utilisé plus bas. Compilation La phase de compilation consiste généralement en la génération du code assembleur. C'est la phase la plus intensive en traitements. Elle est accomplie par le compilateur proprement dit. Pour chaque unité de compilation, on obtient un fichier en langage d'assemblage. Cette étape peut être divisée en sous-étapes : l'analyse lexicale, qui est la reconnaissance des mots clé du langage ; l'analyse syntaxique, qui analyse la structure du programme et sa conformité avec la norme ; l'optimisation de code ; l'écriture d'un code isomorphe à celui de l'assembleur (et parfois du code assembleur lui-même quand cela est demandé en option du compilateur). Par abus de langage, on appelle compilation toute la phase de génération d'un fichier exécutable à partir des fichiers sources. Mais c'est seulement une des étapes menant à la création d'un exécutable. Certains compilateurs C fonctionnent à ce niveau en deux phases, la première générant un fichier compilé dans un langage intermédiaire destiné à une machine virtuelle idéale (voir Bytecode ou P-Code) portable d'une plate-forme à l'autre, la seconde convertissant le langage intermédiaire en langage d'assemblage dépendant de la plate-forme cible. D'autres compilateurs C permettent de ne pas générer de langage d'assemblage, mais seulement le fichier compilé en langage intermédiaire, qui sera interprété ou compilé automatiquement en code natif à l'exécution sur la machine cible (par une machine virtuelle qui sera liée au programme final). Assemblage Cette étape consiste en la génération d'un fichier objet en langage machine pour chaque fichier de code assembleur. Les fichiers objet sont généralement d’extension .o sur Unix, et .obj avec les outils de développement pour MS-DOS, Microsoft Windows, VMS, CP/M... Cette phase est parfois regroupée avec la précédente par établissement d'un flux de données interne sans passer par des fichiers en langage intermédiaire ou langage d'assemblage. Dans ce cas, le compilateur génère directement un fichier objet. Pour les compilateurs qui génèrent du code intermédiaire, cette phase d'assemblage peut aussi être totalement supprimée : c'est une machine virtuelle qui interprétera ou compilera ce langage en code machine natif. La machine virtuelle peut être un composant du système d'exploitation ou une bibliothèque partagée. Édition des liens L'édition des liens est la dernière étape, et a pour but de réunir tous les éléments d'un programme. Les différents fichiers objet sont alors réunis, ainsi que les bibliothèques statiques, pour ne produire qu'un fichier exécutable. Le but de l'édition de liens est de sélectionner les éléments de code utiles présents dans un ensemble de codes compilés et de bibliothèques, et de résoudre les références mutuelles entre ces différents éléments afin de permettre à ceux-ci de se référencer directement à l'exécution du programme. L'édition des liens échoue si des éléments de code référencés manquent. Éléments du langage Éléments lexicaux Le jeu de caractères ASCII suffit pour écrire en C. Il est même possible, mais inusité, de se restreindre au jeu de caractères invariants de la norme ISO 646, en utilisant des séquences d'échappement appelées trigrammes. En général, les sources C sont écrits avec le jeu de caractères du système hôte. Il est toutefois possible que le jeu de caractères d'exécution ne soit pas celui du source. Le C est sensible à la casse. Les caractères blancs (espace, tabulation, fin de ligne) peuvent être librement utilisés pour la mise en page, car ils sont équivalents à un seul espace dans la plupart des cas. Mots clés Le C89 compte clés, dont cinq qui n'existaient pas en K&R C, et qui sont par ordre alphabétique : auto, break, case, char, const (C89), continue, default, do, double, else, enum (C89), extern, float, for, goto, if, int, long, register, return, short, signed (C89), sizeof, static, struct, switch, typedef, union, unsigned, void (C89), volatile (C89), while. Ce sont des termes réservés qui ne doivent pas être utilisés autrement. La révision C99 en ajoute cinq : _Bool, _Complex, _Imaginary, inline, restrict. Ces nouveaux mots-clés commencent par une majuscule préfixée d’un underscore afin de maximiser la compatibilité avec les codes existants. Des en-têtes de la bibliothèque standard fournissent les alias bool (<stdbool.h>), complex et imaginary (<complex.h>). La dernière révision, C11, introduit encore sept nouveaux mots-clés avec les mêmes conventions : _Alignas, _Alignof, _Atomic, _Generic, _Noreturn, _Static_assert, _Thread_local. Les en-têtes standards <stdalign.h>, <stdnoreturn.h>, <assert.h> et <threads.h> fournissent respectivement les alias alignas et alignof, noreturn, static_assert, et thread_local. Instructions du préprocesseur Le préprocesseur du langage C offre les directives suivantes : #include, #define, #pragma (C89), #if, #ifdef, #ifndef, #elif (C89), #else, #endif, #undef, #line, #error. Types Le langage C comprend de nombreux types de nombres entiers, occupant plus ou moins de bits. La taille des types n'est que partiellement standardisée : le standard fixe uniquement une taille minimale et une magnitude minimale. Les magnitudes minimales sont compatibles avec d'autres représentations binaires que le complément à deux, bien que cette représentation soit presque toujours utilisée en pratique. Cette souplesse permet au langage d'être efficacement adapté à des processeurs très variés, mais elle complique la portabilité des programmes écrits en C. Chaque type entier a une forme « signée » pouvant représenter des nombres négatifs et positifs, et une forme « non signée » ne pouvant représenter que des nombres naturels. Les formes signées et non signées doivent avoir la même taille. Le type le plus commun est int, il représente le mot machine. Contrairement à de nombreux autres langages, le type char est un type entier comme un autre, bien qu'il soit généralement utilisé pour représenter les caractères. Sa taille est par définition d'un byte. Les types énumérés se définissent avec le mot clé enum. Il existe des types de nombre à virgule flottante, de précision, donc de longueur en bits, variable ; en ordre croissant : C99 a ajouté float complex, double complex et long double complex, représentant les nombres complexes associés. Types élaborés : struct, union, * pour les pointeurs ; [... ] pour les tableaux ; (... ) pour les fonctions. Le type _Bool est standardisé par C99. Dans les versions antérieures du langage, il était courant de définir un synonyme : typedef enum boolean {false, true} bool; Le type void représente le vide, comme une liste de paramètres de fonction vide, ou une fonction ne retournant rien. Le type void* est le pointeur générique : tout pointeur de donnée peut être implicitement converti de et vers void*. C'est par exemple le type retourné par la fonction standard malloc, qui alloue de la mémoire. Ce type ne se prête pas aux opérations nécessitant de connaître la taille du type pointé (arithmétique de pointeurs, déréférencement). Structures C supporte les types composés avec la notion de structure. Pour définir une structure, il faut utiliser le mot-clé struct suivi du nom de la structure. Les membres doivent ensuite être déclarés entre accolades. Comme toute déclaration, un point-virgule termine le tout. /* Déclaration de la structure personne */ struct Personne { int age; char *nom; }; Pour accéder aux membres d'une structure, il faut utiliser l'opérateur .. int main() { struct Personne p; p.nom = "Albert"; p.age = 46; } Les fonctions peuvent recevoir des pointeurs vers des structures. Ils fonctionnent avec la même syntaxe que les pointeurs classiques. Néanmoins, l'opérateur -> doit être utilisé sur le pointeur pour accéder aux champs de la structure. Il est également possible de déréférencer le pointeur pour ne pas utiliser cet opérateur, et toujours utiliser l'opérateur .. void anniversaire(struct Personne * p) { p->age++; printf("Joyeux anniversaire %s !", (*p).nom); } int main() { struct Personne p; p.nom = "Albert"; p.age = 46; anniversaire(&p); } Commentaire Dans les versions de C antérieures à C99, les commentaires devaient commencer par une barre oblique et un astérisque (« /* ») et se terminer par un astérisque et une barre oblique. Presque tous les langages modernes ont repris cette syntaxe pour écrire des commentaires dans le code. Tout ce qui est compris entre ces symboles est du commentaire, saut de ligne compris : /* Ceci est un commentaire sur deux lignes ou plus */ La norme C99 a repris de C++ les commentaires de fin de ligne, introduits par deux barres obliques et se terminant avec la ligne : // Commentaire jusqu'à la fin de la ligne Structures de contrôle La syntaxe des différentes structures de contrôle existantes en C est largement reprise dans plusieurs autres langages, comme le C++ bien sûr, mais également Java, C#, PHP ou encore JavaScript. Les trois grands types de structures sont présents : les tests (également appelés branchements conditionnels) avec : if (expression) instruction if (expression) instruction else instruction switch (expression) instruction, avec case et default dans l'instruction les boucles avec : while (expression) instruction for (expression_optionnelle ; expression_optionnelle ; expression_optionnelle) instruction do instruction while (expression) les sauts (branchements inconditionnels) : break continue return expression_optionnelle goto étiquette Fonctions Les fonctions en C sont des blocs d'instructions, recevant un ou plusieurs arguments et pouvant retourner une valeur. Si une fonction ne retourne aucune valeur, le mot-clé void est utilisé. Une fonction peut également ne recevoir aucun argument. Le mot-clé void est conseillé dans ce cas. // Fonction ne retournant aucune valeur (appelée procédure) void afficher(int a) { printf("%d", a); } // Fonction retournant un entier int somme(int a, int b) { return a + b; } // Fonction sans aucun argument int saisir(void) { int a; scanf("%d", &a); return a; } Prototype Un prototype consiste à déclarer une fonction et ses paramètres sans les instructions qui la composent. Un prototype se termine par un point-virgule. // Prototype de saisir int saisir(void); // Fonction utilisant saisir int somme(void) { int a = saisir(), b = saisir(); return a + b; } // Définition de saisir int saisir(void) { int a; scanf("%d", &a); return a; } Généralement, tous les prototypes sont écrits dans des fichiers .h, et les fonctions sont définies dans un fichier .c. Comportements ambigus La norme du langage C laisse, délibérément, certaines opérations sans spécification précise. Cette propriété du C permet aux compilateurs d'utiliser directement des instructions spécifiques au processeur, d'effectuer des optimisations ou d'ignorer certaines opérations, pour compiler des programmes exécutables courts et efficaces. En contrepartie, c'est parfois la cause de bugs de portabilité des codes source écrits en C. Il existe trois catégories de tels comportements : défini par l'implémentation : Le comportement n'est pas spécifié dans la norme mais dépend de l'implémentation. Le choix effectué dans une implémentation doit être documenté dans celle-ci. Un programme utilisant ce type de comportement est correct, à défaut d'être garanti portable. non spécifié : Le choix n'est pas spécifié dans la norme, mais n'a cette fois pas à être documenté. Il n'a en particulier pas à être identique à chaque fois pour une même implémentation. Un programme utilisant ce type de comportement est correct également. non défini : Comme le nom l'indique, l'opération n'est pas définie. La norme n'impose aucune limitation à ce que le compilateur peut faire dans ce cas. Tout peut arriver. Le programme est incorrect. Comportements définis par l'implémentation En C, les comportements définis par l'implémentation sont ceux où l'implémentation doit choisir un comportement et s'y tenir. Ce choix peut être libre ou parmi une liste de possibilités données par la norme. Le choix doit être documenté par l'implémentation, afin que le programmeur puisse le connaître et l'utiliser. Un des exemples les plus importants de tel comportement est la taille des types de donnée entiers. La norme C spécifie la taille minimale des types de base, mais pas leur taille exacte. Ainsi, le type int par exemple, correspondant au mot machine, doit avoir une taille minimale de . Il peut avoir une taille de sur un processeur et une taille de sur un processeur . Un autre exemple est la représentation des entiers signés. Il peut s'agir du complément à deux, du complément à un ou d'un . La vaste majorité des systèmes modernes utilise le complément à deux, qui est par exemple le seul encore supporté par GCC. De vieux systèmes utilisent les autres formats, comme l'IBM 7090 qui utilise le format signe/valeur, le PDP-1 ou l'UNIVAC et ses descendants, dont certains encore utilisés actuellement tels le , qui utilisent le complément à un. Un autre exemple est le décalage à droite d'un entier signé négatif. Typiquement, l'implémentation peut choisir de décaler comme pour un entier non signé ou de propager le bit de poids fort représentant le signe. Comportements non spécifiés Les comportements non spécifiés sont similaires aux comportements définis par l'implémentation, mais le comportement adopté par l'implémentation n'a pas à être documenté. Il n'a même pas à être le même en toutes circonstances. Néanmoins, le programme reste correct, le programmeur ne peut juste pas compter sur une règle particulière. Par exemple, l'ordre d'évaluation des paramètres lors d'un appel de fonction n'est pas spécifié. Le compilateur peut même choisir d'évaluer dans un ordre différent les paramètres de deux appels à la même fonction, si ça peut aider son optimisation. Comportements indéfinis La norme C définit certains cas où des constructions syntaxiquement valides ont un comportement indéfini. Selon la norme, tout peut alors arriver : la compilation peut échouer, ou produire un exécutable dont l'exécution sera interrompue, ou qui produira des résultats faux, ou même qui donnera l'apparence de fonctionner sans erreur. Lorsqu'un programme contient un comportement indéfini, c'est le comportement de l'ensemble du programme qui devient indéfini, pas seulement le comportement de l'instruction contenant l'erreur. Ainsi, une instruction erronée peut corrompre des données qui seront traitées bien plus tard, reportant d'autant la manifestation de l'erreur. Et même sans être exécutée, une instruction erronée peut amener le compilateur à réaliser des optimisations sur la base d'hypothèses fausses, produisant un exécutable qui ne fait pas du tout ce qui est prévu. Exemples On peut signaler la classique division par zéro, ou l'affectation multiple d'une variable dans la même expression avec l'exemple : int i = 4; i = i++; /* Comportement indéfini. */ On pourrait ainsi penser que dans cet exemple i pourrait valoir 4 ou 5 suivant le choix du compilateur, mais il pourrait tout aussi bien valoir 42 ou l'affectation pourrait arrêter l'exécution, ou le compilateur peut refuser la compilation. Aucune garantie n'existe dès qu'un comportement indéfini existe. Pour ne citer que quelques exemples, le déréférencement d'un pointeur nul, tout accès à un tableau hors de ses limites, l'utilisation d'une variable non initialisée ou encore le débordement d'entiers signés ont tous des comportements indéfinis. Le compilateur peut utiliser le fait qu'une construction est indéfinie dans certains cas pour supposer que ce cas ne se produit jamais et optimiser plus agressivement le code. Si l'exemple ci-dessus peut paraître évident, certains exemples complexes peuvent être bien plus subtils et être source de bugs parfois graves. Par exemple, beaucoup de code contient des vérifications destinées à éviter l'exécution dans des cas hors bornes, qui peut ressembler à ceci : char buffer[BUFLEN]; char *buffer_end = buffer + BUFLEN; unsigned int len; /* ... */ if (buffer + len >= buffer_end || /* vérification de dépassement du buffer */ buffer + len < buffer) /* vérification de débordement si len très large */ return; /* Si pas de débordement, effectue les opérations prévues */ /* ... */ En apparence, ce code est prudent et effectue les vérifications de sécurité nécessaires pour ne pas déborder du buffer alloué. En pratique, les versions récentes de compilateurs tels que GCC, Clang ou Microsoft Visual C++ peuvent supprimer le second test, et rendre possibles des débordements. En effet, la norme précise que l'arithmétique de pointeur sur un objet ne peut donner un pointeur hors de cet objet. Le compilateur peut donc décider que le test est toujours faux et le supprimer. La vérification correcte est la suivante : char buffer[BUFLEN]; unsigned int len; /* ... */ if (len >= BUFLEN) /* vérification de dépassement du buffer */ return; /* Si pas de débordement, effectue les opérations prévues */ /* ... */ En 2008, quand les développeurs de GCC ont modifié le compilateur pour qu'il optimise certaines vérifications de débordement qui reposaient sur des comportements indéfinis, le CERT a émis un avertissement sur l'utilisation des versions récentes de GCC. Ces optimisations sont en fait présentes dans la plupart des compilateurs modernes, le CERT a révisé son avertissement dans ce sens. Certains outils existent pour détecter ces constructions problématiques, et les meilleurs compilateurs en décèlent certaines (il faut parfois activer des options particulières) et peuvent les signaler, mais aucun ne prétend à l'exhaustivité. Bibliothèques logicielles La bibliothèque standard La bibliothèque standard normalisée, disponible avec toutes les implémentations, présente la simplicité liée à un langage bas-niveau. Voici une liste de quelques en-têtes déclarant des types et fonctions de la bibliothèque standard : <assert.h> : pour un diagnostic de conception lors de l'exécution (assert) ; <ctype.h> : tests et classification des caractères (isalnum, tolower) ; <errno.h> : gestion minimale des erreurs (déclaration de la variable errno) ; <math.h> : fonctions mathématiques de base (sqrt, cos) ; nombreux ajouts en C99 ; <signal.h> : gestion des signaux (signal et raise) ; <stddef.h> : définitions générales (déclaration de la constante NULL) ; <stdio.h> : pour les entrées/sorties de base (printf, scanf) ; <stdlib.h> : fonctions générales (malloc, rand) ; <string.h> : manipulation des chaînes de caractères (strcmp, strlen) ; <time.h> : manipulation du temps (time, ctime). La bibliothèque standard normalisée n'offre aucun support de l'interface graphique, du réseau, des entrées/sorties sur port série ou parallèle, des systèmes temps réel, des processus, ou encore de la gestion avancée des erreurs (comme avec des exceptions structurées). Cela pourrait restreindre d'autant la portabilité pratique des programmes qui ont besoin de faire appel à certaines de ces fonctionnalités, sans l'existence de très nombreuses bibliothèques portables et palliant ce manque ; dans le monde UNIX, ce besoin a aussi fait émerger une autre norme, POSIX.1. Les bibliothèques externes Le langage C étant un des langages les plus utilisés en programmation, de nombreuses bibliothèques ont été créées pour être utilisées avec le C : glib, etc. Fréquemment, lors de l'invention d'un format de données, une bibliothèque ou un logiciel de référence en C existe pour manipuler le format. C'est le cas pour zlib, libjpeg, libpng, Expat, les décodeurs de référence MPEG, libsocket Exemples Voici quelques exemples présentant très succinctement quelques propriétés du C. Pour plus d'information, voir le WikiLivre Programmation C. Allocation mémoire La structure int_list représente un élément d'une liste chaînée de nombres entiers. Les deux fonctions qui suivent (insert_next et remove_next) servent à ajouter et supprimer un élément de la liste. /* La gestion de la mémoire n'est pas intégrée au langage mais assurée par des fonctions de la bibliothèque standard. */ #include <stdlib.h> struct int_list { struct int_list *next; /* pointeur sur l'élément suivant */ int value; /* valeur de l'élément */ }; /* * Ajouter un élément à la suite d'un autre. * node : élément après lequel ajouter le nouveau * value : valeur de l'élément à ajouter * Retourne : adresse de l'élément ajouté, ou NULL en cas d'erreur. */ struct int_list *insert_next(struct int_list *node, int value) { /* Allocation de la mémoire pour un nouvel élément. */ struct int_list *const new_next = malloc(sizeof *new_next); /* Si l'allocation a réussi, alors insérer new_next entre node et node->next. */ if (new_next) { new_next->next = node->next; node->next = new_next; new_next->value = value; } return new_next; } /* * Supprimer l'élément suivant un autre. * node : élément dont le suivant est supprimé * Attention : comportement indéterminé s'il n'y a pas d'élément suivant ! */ void remove_next(struct int_list *node) { struct int_list *const node_to_remove = node->next; /* Retire l'élément suivant de la liste. */ node->next = node->next->next; /* Libère la mémoire occupée par l'élément suivant. */ free(node_to_remove); } Dans cet exemple, les deux fonctions essentielles sont malloc et free. La première sert à allouer de la mémoire, le paramètre qu'elle reçoit est le nombre de bytes que l'on désire allouer et elle retourne l'adresse du premier byte qui a été alloué, sinon elle retourne NULL. free sert à libérer la mémoire qui a été allouée par malloc. Quelques programmes notoires écrits en C UNIX GNU Compiler Collection (GCC) Noyau Linux Noyau de Microsoft Windows Vim GNOME Notes et références Voir aussi Bibliographie The international standardization working group for the programming language C, ISO/CEI 9899:TC2 WG14/N1124, « Committee Draft », ISO/CEI 9899:TC3 WG14/N1256, « Committee Draft », ISO/IEC 9899:2017 WG14/N1570, « Committee Draft », ISO/IEC 9899:2017 WG14/N2176, , Articles connexes Bibliothèque standard du C Alignement de données Langage de programmation Norme ISO


source: wikipedia

text: Cette page recense les pays du monde, quel que soit leur statut : reconnus par l'ONU, par un ou plusieurs autres pays, ou même auto-proclamés. Pays listés De nombreuses publications donnent une liste des pays du monde, mais elles n'utilisent pas toutes les mêmes critères pour inclure ou non un pays. Un critère courant mais flou est la reconnaissance du pays par la communauté internationale, notamment sa reconnaissance par l'Organisation des Nations unies qui compte membres et reconnaît quatre autres États non membres (dont deux avec le statut de « observateur permanent »). Ces quatre États non membres sont le Vatican (observateur permanent depuis 1964), l'État de Palestine (observateur permanent depuis 2012), et les Îles Cook et Niue, deux territoires insulaires en libre association avec la Nouvelle-Zélande. Six pays sont reconnus par au moins un État membre de l'ONU sans être reconnus par l'ONU : le Kosovo, la République arabe sahraouie démocratique, Taïwan (république de Chine), la république d'Abkhazie, l'Ossétie du Sud-Alanie, la république turque de Chypre du Nord. En outre, la république moldave de Transnistrie et la république du Haut-Karabagh se reconnaissent mutuellement, et sont reconnues par l'Ossétie du Sud-Alanie et la république d'Abkhazie. Enfin, un territoire indépendant depuis 1990 n'est également reconnu par aucun pays, la république du Somaliland. Lorsque Taïwan est inclus dans une liste, c'est souvent accompagné d'un avertissement sur le caractère non officiel de la liste ou sur le fait que Taïwan n'est pas reconnu. En effet, le statut de Taïwan est particulier du fait que la république populaire de Chine exige la reconnaissance du principe d'une seule Chine de la part des pays qui veulent avoir des rapports diplomatiques avec elle. États dont la souveraineté est contestée N'apparaissent ici que des États répondant aux critères de la convention de Montevideo de 1933 sur les droits et les devoirs des États. États reconnus par l'ONU mais non reconnus par au moins un État La république d'Arménie, indépendante depuis 1991, n'est pas reconnue par la république islamique du Pakistan, État membre de l'ONU. La république populaire de Chine (RPC), proclamée en 1949, n'est pas reconnue par Taïwan, État non membre de l'ONU. Chypre, indépendante depuis 1960, n'est pas reconnue par un membre de l'ONU (république de Turquie) et un État non membre (république turque de Chypre du Nord), à la suite de la partition de l'île en 1974. L'État d'Israël, indépendant depuis 1948, n'est pas reconnu par 21 États membres de l'ONU (voir : carte) (voir Conflit israélo-arabe). L'Organisation de libération de la Palestine reconnaît l'existence de l'État d'Israël, tout en réclamant la souveraineté sur des territoires sous son contrôle. L’État de Palestine, non membre de l’ONU mais reconnu par l’ONU depuis 2012, n’est pas encore reconnu par plus d’une cinquantaine d’États membres de l’ONU : cf. la liste des pays reconnaissant l’État de Palestine. La république populaire démocratique de Corée, indépendante depuis 1948, n'est pas reconnue par plusieurs membres de l'ONU : les États-Unis, le Japon, la France, l'Estonie, ainsi que la république de Corée (Corée du Sud). La république de Corée, indépendante depuis 1948, n'est pas reconnue par la république populaire démocratique de Corée, membre de l'ONU. États non reconnus par l'ONU mais reconnus par au moins un membre de l'ONU Le Kosovo a proclamé unilatéralement son indépendance le , qui est reconnue par 103 États (+ Taïwan) au . Celle-ci est contestée entre autres par la Serbie, la Russie, la république populaire de Chine ainsi que cinq États membres de l'Union européenne. La République arabe sahraouie démocratique reconnue par 48 États en 2012, contrôle environ 20 % du Sahara occidental. Taïwan : Taïwan bénéficie d'une indépendance mais n'est pas reconnue par la Chine et la plupart des pays de la communauté internationale qui ont peu à peu reconnu la « politique d'une seule Chine » voulue par la république populaire de Chine. Elle entretient des relations diplomatiques avec 13 États. La république d'Abkhazie : reconnue par la Russie, le Nicaragua, le Venezuela et Nauru. L'Ossétie du Sud-Alanie : reconnue par la Russie, le Nicaragua, le Venezuela et Nauru. La république turque de Chypre du Nord : a fait sécession de la république de Chypre depuis le , mais n'est reconnue que par la Turquie qui y maintient une force militaire. États reconnus par aucun État membre de l'ONU mais reconnus par au moins un État reconnu par un État membre de l’ONU La république moldave du Dniestr (forme courte : Transnistrie), qui a fait sécession de la Moldavie en 1991 à la suite de l'effondrement de l'Union soviétique, est reconnue par trois États non-membres de l'ONU : république d'Abkhazie, Ossétie du Sud-Alanie et Haut-Karabagh. Le Haut-Karabagh, république sécessionniste de l'Azerbaïdjan, est reconnu par trois États non-membres de l'ONU : l'Abkhazie, l'Ossétie du Sud-Alanie et la Transnistrie. Autres États indépendants de fait Ces territoires sont indépendants mais ils ne sont reconnus indépendants ni par l’ONU, ni par aucun État membre de l’ONU, ni par aucun État reconnu par un État membre de l’ONU : la souveraineté sur les territoires contrôlées n’est reconnue que par eux-mêmes la plupart du temps ou par d’autres territoires dans la même configuration. Ils échappent largement au contrôle du pays qui exerce officiellement sa souveraineté et disposent d'une autonomie de fait avec leurs propres institutions et symboles. Diverses régions de la Somalie ne sont quasiment que sous le contrôle d’entités locales : qui souhaitent leur indépendance : comme le Somaliland ; qui se sont déclarées autonomes dans le but de réintégrer la république fédérale de Somalie quand un pouvoir central se sera réorganisé : comme l’Awdalland, le Khatumo, le Pount, le Galmudug, l’Himan-et-Heeb, l’Azanie (dans la région du Jubaland) ; qui souhaitent élargir leur influence le plus largement sans restriction territoriale : comme le groupe Al-Shabbaab qui contrôle de larges régions dans le sud de la Somalie. Une république de rebelles séparatistes prétendent former la république de Logone en République centrafricaine. Toponymie : noms de forme courte et longue La plupart des pays ont deux noms : un nom de « forme courte » et un de « forme longue ». La forme courte est le nom usuel, par exemple « Belgique ». Elle est utilisée dans la vie courante, l'enseignement et la cartographie. La forme longue donne généralement une indication sur la forme de gouvernement de l'État, par exemple « le royaume de Belgique ». Elle est utilisée dans les actes officiels des États : constitution, législation, traités, procès-verbaux, actes notariés etc. Elle est également utilisée dans les publications et discours formels. Il se peut que la forme longue repose uniquement sur des fondements historiques. C'est le cas de la Suisse qui conserve le nom officiel de « Confédération suisse » bien qu'elle ait abandonné le statut de confédération en 1848 pour devenir un État fédéral. Il arrive également qu'un nom de forme longue soit davantage usité que la forme courte dans la langue courante. Cela a notamment été le cas de la République tchèque, dont le nom sous forme courte, Tchéquie, est resté longtemps peu usité. Quelques pays n'ont qu'une seule forme de nom, soit courte comme le Canada, soit longue comme la République dominicaine. Liste des pays Liste principale Cette liste comprend les 197 États reconnus par l’Organisation des Nations unies : ses 193 États membres ; ses deux États observateurs permanents : le Vatican, représenté par le Saint-Siège, et l’État de Palestine ; deux États ni membres ni observateurs permanents mais membres à part entière de plusieurs agences spécialisées de l’ : les Îles Cook et Niue. Pour les abréviations utilisées dans la liste suivante, consulter la section correspondante. A B C D E F G H I J K L M N O P Q R S T U V Y Z Dépendances et territoires à souveraineté spéciale Les dépendances et territoires à souveraineté spéciale sont des dépendances, possessions, territoires autonomes, collectivités et territoires d'outre-mer non souverains, y compris les Îles Cook et Niue reconnus comme États non-membres par l'ONU. Certaines de ces dépendances, comme Gibraltar et la Nouvelle-Calédonie, sont sur la liste officielle des territoires à décoloniser selon l'ONU. Cette liste est elle-même contestée. Territoires contestés Cette section est fondée sur l'entrée Entities de la page Notes and Definitions du CIA World Factbook. Apparaissent ici les territoires sur lesquels la communauté internationale ne reconnaît la souveraineté d'aucun État indépendant (pour une liste de territoires contestés entre plusieurs pays, mais sur lesquels la souveraineté de l'un ou l'autre est généralement reconnue, voir la liste des territoires contestés ou occupés). L'Antarctique, régi internationalement par le traité de l'Antarctique. Sept États (France, Norvège, Australie, Nouvelle-Zélande, Royaume-Uni, Argentine et Chili) ont toutefois des prétentions territoriales, se recoupant dans le cas des trois derniers, sur différentes portions du territoire, le secteur de la Terre Marie Byrd étant le seul non revendiqué. Les îles Paracels et les îles Spratleys, revendiquées par la Chine, Taïwan et le Viêt Nam ; Le Sahara occidental, contrôlé à 80 % par le Maroc (qui le considère comme une de ses provinces) et à 20 % par la République arabe sahraouie démocratique (qui le considère comme son territoire national). Évolution du nombre d'États dans le monde Avant 1914 Le nombre d'États souverains en Europe, qui s'élevait à plus de trois cents en 1789, était encore d'une soixantaine en 1815, au lendemain du congrès de Vienne. Après l'unification de l’Italie et de l’Allemagne, ce nombre était tombé à 19 en 1871 (20 avec la Turquie, qui contrôlait encore la majeure partie de la péninsule des Balkans). Il passa à 22 en 1878, lorsque le congrès de Berlin reconnut l'indépendance de la Roumanie, de la Serbie et du Monténégro. Après l'accession à l'indépendance de la Norvège (1905), de la Bulgarie (1908) et de l’Albanie (1912), l'Europe comptait 25 États indépendants en 1914, non compris le Saint-Siège et le territoire neutre de Moresnet. En Amérique, le nombre d’États s’élevait à 11 en 1825, à l'issue des guerres d'indépendance. Il connut ensuite quelques fluctuations avant de se stabiliser à 19 en 1865. Après l’accession à l’indépendance de Cuba (1902) et du Panama (1903), il était passé à 21 en 1914, compte non tenu des deux dominions du Canada (1867) et de Terre-Neuve (1907). En Asie occidentale, la péninsule arabique était occupée par une multitude de tribus et de principautés, dont la plupart étaient plus ou moins vassales du Royaume-Uni ou de la Turquie. En Asie centrale, la Russie avait conquis les derniers khanats indépendants entre 1865 et 1876. L’empire britannique des Indes, qui englobait la Birmanie depuis 1886 et le Baloutchistan depuis 1887, exerçait de fait son emprise sur l’Afghanistan, le Népal et le Bhoutan. En Indochine, la France avait établi sa domination sur l'Annam (actuel Viêt Nam), le Cambodge et le Laos entre 1858 et 1893, tandis que les États malais étaient passés sous protectorat britannique entre 1874 et 1909. La « pacification » des Indes néerlandaises s’était achevée entre 1903 et 1908 avec l’annexion des derniers royaumes indépendants d’Aceh et de Bali. Enfin, après l’annexion de la Corée par le Japon en 1910, l’Asie ne comptait plus que cinq États officiellement indépendants : la Chine, le Japon, la Perse, le Siam et la Turquie. Plusieurs de ces pays étaient néanmoins sous protectorat de fait. En outre, la Mongolie le Tibet déclarèrent leur indépendance en 1911 et 1913, respectivement. Cette section ne fournit pas de nomenclature de tous les royaumes existant en Afrique avant la pénétration européenne et leur nombre n’est donc pas encore documenté ici même. En revanche, après l’établissement du protectorat franco-espagnol sur le Maroc en 1912, le continent africain ne comptait plus que deux États souverains : l’empire d'Éthiopie et le Liberia. Il convient de mentionner le cas particulier de l’État indépendant du Congo, propriété personnelle du roi des Belges de 1885 à 1908, et celui de l’Union sud-africaine, constituée dès 1910 en tant que dominion britannique. En Océanie, les derniers royaumes de quelque importance (Hawaii, Samoa, Tonga) avaient perdu leur indépendance entre 1889 et 1900. En revanche, l’Australie avait accédé au statut de dominion en 1901, ainsi que la Nouvelle-Zélande en 1907. De 1914 à 1945 En 1914, le nombre total d'États généralement reconnus comme indépendants s'élevait donc à 53, non compris les dominions (Australie, Canada, Nouvelle-Zélande, Terre-Neuve, Union sud-africaine), qui ne deviendront pleinement souverains qu'en 1931, et quelques pays au statut mal défini (Asir, Nejd, Yémen, Mongolie, Tibet) ou placés de fait sous protectorat britannique (Mascate et Oman, Afghanistan, Népal). Ces 53 États se répartissaient comme suit : 2 en Afrique : Éthiopie, Liberia ; 21 en Amérique : Argentine, Bolivie, Brésil, Chili, Colombie, Costa Rica, Cuba, Équateur, États-Unis, Guatemala, Haïti, Honduras, Mexique, Nicaragua, Panama, Paraguay, Pérou, République dominicaine, Salvador, Uruguay, Venezuela ; 5 en Asie : Chine, Japon, Perse, Siam, Turquie ; 25 en Europe : Albanie, Allemagne, Andorre, Autriche-Hongrie, Belgique, Bulgarie, Danemark, Espagne, France, Grèce, Italie, Liechtenstein, Luxembourg, Monaco, Monténégro, Norvège, Pays-Bas, Portugal, Roumanie, Royaume-Uni, Russie, Saint-Marin, Serbie, Suède, Suisse. À la fin de l'année 1932, le nombre d'États était passé à 76 (ou 77 si l'on inclut le Mandchoukouo, non reconnu par la majorité des États) : 4 en Afrique : Égypte, Éthiopie, Liberia, Union sud-africaine ; 23 en Amérique : Argentine, Bolivie, Brésil, Canada, Chili, Colombie, Costa Rica, Cuba, Équateur, États-Unis, Guatemala, Haïti, Honduras, Mexique, Nicaragua, Panama, Paraguay, Pérou, République dominicaine, Salvador, Terre-Neuve, Uruguay, Venezuela ; 12 ou 13 en Asie : Afghanistan, Arabie saoudite, Chine, Irak, Japon, Mandchoukouo, Mongolie, Népal, Perse, Siam, Tannou-Touva, Turquie, Yémen ; 35 en Europe : Albanie, Allemagne, Andorre, Autriche, Belgique, Bulgarie, Danemark, Dantzig, Espagne, Estonie, Finlande, France, Grèce, Hongrie, Irlande, Islande, Italie, Lettonie, Liechtenstein, Lituanie, Luxembourg, Monaco, Norvège, Pays-Bas, Pologne, Portugal, Roumanie, Royaume-Uni, Saint-Marin, Suède, Suisse, Tchécoslovaquie, URSS, Vatican, Yougoslavie ; 2 en Océanie : Australie, Nouvelle-Zélande. Entre 1920 et 1937, 63 États (y compris l'Inde britannique) avaient adhéré à la Société des Nations (SDN), qui fut officiellement dissoute en 1946 pour laisser la place à l'Organisation des Nations unies (ONU). Depuis 1945 À la fin de l'année 1945, le nombre d'États était retombé à 72, répartis comme suit : 4 en Afrique : Égypte, Éthiopie, Liberia, Union sud-africaine ; 22 en Amérique : Argentine, Bolivie, Brésil, Canada, Chili, Colombie, Costa Rica, Cuba, Équateur, États-Unis, Guatemala, Haïti, Honduras, Mexique, Nicaragua, Panama, Paraguay, Pérou, République dominicaine, Salvador, Uruguay, Venezuela ; 13 en Asie : Afghanistan, Arabie saoudite, Chine, Irak, Iran (Perse), Japon, Liban, Mongolie, Népal, Syrie, Thaïlande (Siam), Turquie, Yémen ; 31 en Europe : Albanie, Allemagne, Andorre, Autriche, Belgique, Bulgarie, Danemark, Espagne, Finlande, France, Grèce, Hongrie, Irlande, Islande, Italie, Liechtenstein, Luxembourg, Monaco, Norvège, Pays-Bas, Pologne, Portugal, Roumanie, Royaume-Uni, Saint-Marin, Suède, Suisse, Tchécoslovaquie, URSS, Vatican, Yougoslavie (l'Allemagne et l'Autriche étant occupées par les Alliés) ; 2 en Océanie : Australie, Nouvelle-Zélande. À la même date, le nombre d'États membres des Nations unies s'élevait à 51, y compris la Biélorussie, l'Ukraine, l'Inde et les Philippines qui n'avaient pourtant pas encore accédé juridiquement à l'indépendance. Par la suite, le nombre d'États indépendants n'a cessé d'augmenter, notamment sous l'effet de la décolonisation et de l'effondrement du bloc soviétique. Il est ainsi passé de 72 en 1945 à 197 en 2012 (date de la reconnaissance de l'État de Palestine comme « État non membre » de l'ONU) : 88 en 1955 (5 en Afrique, 22 en Amérique, 27 en Asie, 32 en Europe et 2 en Océanie) dont 76 membres de l'ONU ; 156 en 1975 (48 en Afrique, 29 en Amérique, 39 en Asie, 33 en Europe et 7 en Océanie) dont 144 membres de l'ONU ; 197 reconnus par l'ONU en 2012 (54 en Afrique, 35 en Amérique, 47 en Asie, 45 en Europe et 16 en Océanie) dont 193 membres de cette organisation, qui reconnaît également les Îles Cook, Niue, l'État de Palestine et le Vatican comme « États non membres ». Les Îles Cook et Niue sont des États en libre association avec la Nouvelle-Zélande. Le Vatican et l'État de Palestine ont quant à eux le statut d'États observateurs à l'ONU. Notes et références Notes Références Références toponymiques utilisées Les dénominations de la liste principale des pays proviennent des documents suivants : d’organismes de nations francophones : en France : (CELF) : la , seule liste publiée au Journal officiel de la République française ; (CNT) : la , et ; au Canada : (BTB) : le et ; (OQLF) : l’ ; (SQ) : l’ ; en Suisse : (SS) : l’ ; d’organismes internationaux : l’Organisation internationale du travail : (OIT) : et sur ilo.org ; l’Organisation des Nations unies : (ONU) : et ; l’Union européenne : (UE) : ; de dictionnaires et encyclopédies françaises : (L) : l’ ; (PR) : ; (U) : Encyclopædia Universalis, ; et pour quelques pays qui n'ont leurs noms constitutionnels repris dans aucun des documents précédents, la traduction littérale du nom a pu être reprise avec une note associée. : Uniquement lorsque les dénominations diffèrent, chaque dénomination (ou uniquement la dénomination qui fait exception) est suivie de l'abréviation de la source qui la donne (CNT, L, OIT, ONU, PR, SQ, SS, UE). Certains organismes utilisent plusieurs dénominations différentes pour la même entité, dans ce cas-là, l’abréviation suit chaque dénomination utilisée. Le Petit Robert des noms propres utilise généralement une minuscule sur les mots « république » ; de la même manière Larousse utilise la plupart du temps la minuscule pour « royaume ». Lorsque c'est la seule différence, elle est indiquée par un « m » suivant l’abréviation : « Lm » ou « PRm ». Certains organismes utilisent, dans leurs nomenclatures, une partie du nom est entre parenthèses ; lorsque c’est la seule différence, elle est indiquée par un « p » suivant l’abréviation (ONUp par exemple). Les articles devant le nom des entités ne sont pas donnés par l’Institut de la statistique du Québec ni par l’Office fédéral de la statistique de la Suisse. Autres références toponymiques , la liste des pays et territoires publiée par l'Union européenne pour les statistiques du commerce extérieur de la Communauté européenne et de ses États membres. , site de la division francophone du Groupe d'experts des Nations unies pour les noms géographiques (GENUNG/UNGEGN) Geobel 2011, Nomenclatures des pays, Service public fédéral belge économie, PME, classes moyennes et énergie. Geonames – Dénominations dans toutes les langues. Union postale universelle – Pays membres. Organisation internationale de normalisation. Annexes Articles connexes Monde (univers) Listes de pays Liste des pays par population Liste des dépendances et territoires à souveraineté spéciale Liste d'entités territoriales autonomes Liste des territoires non autonomes selon l'Organisation des Nations unies Liste de territoires contestés Liste des États non reconnus internationalement Liste des capitales du monde Liste des chefs de l'exécutif par État en 2011 Liste des dirigeants actuels des États Liste de gentilés Liste de périphrases désignant des pays Liste des États membres de l'Organisation des Nations unies Liste de micronations ISO 3166-1 Arrêté français du 4 novembre 1993 relatif à la terminologie des noms d'États et de capitales