Adresses mémoires

Évolution du langage / Historique :

Caractéristiques :

• 
  Langage structuré, conçu pour traiter les tâches d'un programme en les mettant dans des blocs.
  
• 
  Il produit des programmes efficaces : il possède les mêmes possibilités de contrôle de la machine que l'assembleur et il génére un code compact et rapide..
  
• 
  Déclaratif : normalement, tout objet C doit être déclaré avant d'être utilisé. S'il ne l'est pas, il est considéré comme étant du type entier.
  
• 
  Format libre : la mise en page des divers composants d'un programme est totalement libre.
  

• 
  Modulaire : une application pourra être découpée en modules qui pourront être compilés séparément.
  

• 
  Souple et permissivité : peu de vérifications et d'interdits, hormis la syntaxe. Il est important de remarquer que la tentation est grande d'utiliser cette caractéristique pour écrire le plus souvent des atrocités.
  
• 
  Transportable : les entrées/sorties sont réunies dans une librairie externe au langage.
  

• 
  il existe depuis le début des années 1970, il est basé sur un standard ouvert, de nombreux informaticiens le connaissent, des compilateurs et bibliothèques logicielles existent sur la plupart des architectures ;
  
• 
  il a influencé de nombreux langages plus récents dont C++, Java 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 l'écriture de logiciels qui n'ont besoin d'aucun support à l'exécution (ni bibliothèque logicielle ni machine virtuelle), au comportement prédictible 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.
  

• 
  la première version du langage (K&R C) offre particulièrement peu de vérifications lors de la compilation, et il n'offre aucune vérification pendant l'exécution, ce qui fait que des erreurs qui pourraient être automatiquement détectées lors du développement ne le sont que plus tard, souvent au prix d'un plantage du logiciel ;
  
• 
  il ne facilite pas le développement de concepts informatiques plus modernes comme la programmation orientée objet ou la gestion d'exceptions qui exigent effort de rigueur supplémentaire de la part du développeur.
  
• 
  il est difficile d'écrire des programmes portables car le comportement exact des exécutables dépend de l'ordinateur cible ;
  
• 
  le support de l'allocation de mémoire et des chaînes de caractères est minimaliste, 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 ;
  
• 
  des bugs communs comme le débordement de tampon constituent une faille de sécurité informatique et peuvent être exploités par des logiciels malveillants si le développeur ne fais pas attention.
  
• 
  plusieurs genres d'erreurs ne peuvent être détectés automatiquement qu'à l'aide d'outils supplémentaires et non standardisés, comme lint puis splint.
  

Structure d'un programme C

• 
  Directives du préprocesseur : elles permettent d'effectuer des manipulations sur le texte du programme source avant la compilation :
  
  • 
    inclusion de fichiers,
    
  • 
    substitutions,
    
  • 
    macros,
    
  • 
    compilation conditionnelle.
    

• 
  Déclarations/définitions :
  
  • 
    Déclaration : la déclaration d'un objet C donne simplement ses caractéristiques au compilateur et ne génère aucun code.
    
  • 
    Définition : la définition d'un objet C déclare cet objet et crée effectivement cet objet.
    
• 
  Fonctions : Ce sont des sous-programmes dont les instructions vont définir un traitement sur des variables.
  
• 
  Des commentaires : éliminés par le préprocesseur, ce sont des textes compris entre /* et */.
  

Structure d'une fonction

• 
  Elle peut retourner une valeur à la fonction appelante.
  
• 
  Le programme principal est une fonction dont le nom doit impérativement être main.
  
• 
  Les fonctions ne peuvent pas être imbriquées.
  

• 
   : pour un diagnostic de conception lors de l'exécution (assert)
  
• 
   : tests et classification des caractères (isalnum, tolower)
  
• 
   : gestion minimale des erreurs (déclaration de la variable errno)
  
• 
   : fonctions mathématiques de base (sqrt, cos) ; nombreux ajouts en C99
  
• 
   : gestion des signaux (signal et raise)
  
• 
   : définitions générales (déclaration de la constante NULL)
  
• 
   : pour les entrées/sorties de base (printf, scanf)
  
• 
   : fonctions générales (malloc, rand)
  
• 
   : manipulation des chaînes de caractères (strcmp, strlen)
  
• 
   : manipulation du temps (time, ctime)
  

Règles d'écriture des programmes C

• 
  ne jamais placer plusieurs instructions sur une même ligne
  
• 
  utiliser des identificateurs significatifs
  
• 
  grâce à l'indentation des lignes, on fera ressortir la structure syntaxique du programme.
  

• 
  on laissera une ligne blanche entre la dernière ligne des déclarations et la première ligne des instructions.
  
• 
  une accolade fermante est seule sur une ligne (à l'exception de l'accolade fermante du bloc de la structure do ... while) et fait référence, par sa position horizontale, au début du bloc qu'elle ferme.
  
• 
  aérer les lignes de programme en entourant par exemple les opérateurs avec des espaces.
  
• 
  il est nécessaire de commenter les listings. Eviter les commentaires triviaux.
  

Affichages et saisies :

La fonction printf :

• 
  Syntaxe :
  
• 
  
  
• 
  #include
  
• 
  
  
• 
  #int printf (const char *format [, arg [, arg]...]);
  
• 
  
  
• 
  Description :
  

1. 
   Des caractères à afficher,
   
2. 
   Des spécifications de format.
   

La fonction puts :

• 
  Syntaxe :
  
• 
  #include
  
• 
  
  
• 
  int puts(const char *s);
  
• 
  
  
• 
  Description :
  

• 
  Valeur retournée :
  
  • 
    En cas de succès : une valeur non négative
    
  • 
    En cas d'erreur : la constante EOF (-1) et positionne errno pour indiquer l'erreur.
    
• 
  Exemple :
  
• 
  #include
  
• 
  
  
• 
  main () {
  
• 
  char msg = "Merci d'avoir lu complètement cette page\n";
  
• 
  
  
• 
  puts (msg);
  
• 
  return 0;
  
• 
  }
  

La fonction scanf :

• 
  Syntaxe :
  
• 
  #include
  
• 
  
  
• 
  int scanf (const char *format [, arg. [, arg]...]);
  
• 
  
  
• 
  Description :
  

• 
  Valeur retournée :
  

La fonction Gets :

• 
  Syntaxe :
  
• 
  #inclue
  
• 
  
  
• 
  char *gets(char *s);
  
• 
  
  
• 
  Description :
  

• 
  Valeur retournée :
  

• 
  En cas d'erreur : le pointeur NULL et positionne errno pour indiquer l'erreur.
  
• 
  en cas de succès : le pointeur s.
  

L'instruction if

• 
  Syntaxe :
  
• 
  if (expression)
  
• 
  instruction1
  
• 
  [else
  
• 
  instruction2]
  
• 
  Description :
  

• 
  Diagramme syntaxique du if :
  

L'instruction while :

• 
  Syntaxe :
  
• 
  while (expression)
  
• 
  instruction ou bloc d'instructions
  
• 
  
  
• 
  Description :
  

• 
  Diagramme syntaxique :
  

L'instruction do ... while :

• 
  Syntaxe :
  
• 
  do
  
• 
  instruction ou bloc d'instructions
  
• 
  while (expression != 0);
  
• 
  
  
• 
  Description :
  

• 
  Diagramme syntaxique :
  

L'instruction for :

• 
  Syntaxe :
  
• 
  for ([expression1] ; [expression2] ; [expression3])
  
• 
  instruction ou bloc d'instructions
  
• 
  
  
• 
  Description : instruction est répétée tant que la valeur d’expression2 est non nulle.
  

• 
  Diagramme syntaxique :
  

L'instruction Switch :

• 
  Syntaxe :
  
• 
  Switch (expression) {
  
• 
  case e1 : instruction1 ...
  
• 
  case e2 : instruction2 ...
  
• 
  ...
  
• 
  case e3 : instruction3 ...
  
• 
  default : instruction_default ...
  
• 
  }
  
• 
  
  
• 
  Description :
  

• 
  Diagramme syntaxique :
  

Les pointeurs :

Définition d'une variable pointeur

• 
  La spécificité du langage C vient de son traitement des pointeurs. Leur utilisation est donc très importante.
  
• 
  Un pointeur est une variable qui contient l'adresse d'une autre variable de n'importe quel type. Sa taille dépend de l'implémentation et est, en général, de la taille d'un { int.
  
• 
  La syntaxe générale d'une définition ou déclaration de variable pointeur est de la forme :
  
• 
  classe modificateur type *identificateur ;
  

• 
  Exemple :
  
• 
  char *pt1;
  

• 
  Un pointeur sur un type void pointe sur une zone sans type.