Jean-Jacques BOURDIN

Université Paris 8
Dépt. Programmation et Informatique Fondamentale,
2, rue de la Liberté
93526 Saint-Denis Cedex
FRANCE

Programmation Impérative
 Imperative Programming

September 2024

Easy

Overview

Ch I) Let‘s try!

Ch II) Easy C

    II.A) Variables, Expressions, Types, Instructions
    II.B) Operators
    II.C) Control Flow
    II.D) Data Structures
    II.E) Compilation

Ch III) C Addresses

Ch IV) C more than that

    II.A) Variables, Expressions, Types, Instructions

  1. Variables

    A variable is a tuple of three elements: <name, type, address>
    One needs to declare the variables ASAP in the function. Then they can be set by the operator = (pronounce "receive").
    Une variable est un triplet : (nom, type, espace mémoire).
    La taille de l‘espace mémoire est définie par le type voir ci-dessous. On peut modifier le contenu de l'espace mémoire par l‘opération d'affectation = Qu‘on doit prononcer "reçoit".

    2. /* les autres fonctions ne sont pas encore citées */
int main () {
  int max; /* sert plusieurs fois */
  max = 10;
  printf("%d \t=> \t %d\n",max, serie(max));
  max = 50;
  printf("%d \t=> \t %d\n",max, serie(max));
  max = 100;
  printf("%d \t=> \t %d\n",max, serie(max));
  max = 500;
  printf("%d \t=> \t %d\n",max, serie(max));
  max = 1000;
  printf("%d \t=> \t %d\n",max, serie(max));
}

    One can access to the adress of a variable with the operator &.
    On peut connaître l'adresse d'une variable avec l'opérateur &.
    If one knows an adress, one can access to the value present at this adress the operator *.
    Si vous connaissez une adreee, pour voir ce qui s'y trouve, il suffit d'utiliser l'opérateur *.
    #include <stdio.h>
void voir (int a, int b) {
    printf("a est en %p ", &a);
    printf("et a cette adresse on trouve %d\n", *(&a));
    printf("b est en %p ", &b);
    printf("et a cette adresse on trouve %d\n", *(&b));
}
int main () {
    voir (5,9);
    return 0;
}
    gives 
    Blanc14.local: a.out
a est en 0x16fc674fc et a cette adresse on trouve 5
b est en 0x16fc674f8 et a cette adresse on trouve 9
    Note that the first address (for b) is lower than the second one (a) by a difference of 4, that is the size of an integer on my computer.
    Vous pouvez remarquer que la première adresse, celle de b, est plus petite que celle de a, par une différence de 4, qui correspond à la taille d'un entier sur ma machine.

     

  2. Expressions

    Hereafter you'll find examples of expressions:
    On parlera d'expression pour décrire un ensemble de formules que l'on peut évaluer à base d'opérateurs "bien construits" et exécutables. Exemples : 
    3 + 5 * 6
(3 + 5) * 6
6 * 9 / 5

    And examples of non-expressions:
    Par contre 
    3 + 
3 +  * 6
6  9  5

    N‘en sont pas.

     

  3. Types
    1. Principle :
      Everything must be declared and associated with a type of objects. Each type is associated with a number of functionnalities and a size that is the number of bytes it needs in the memory.
      Principe :  Tout objet doit être déclaré avec un type qui signifie ce qu'il est. Chaque type est associé à un certain nombre de fonctionnalités et à une taille reservée en machine.
       type   taille  genre 
       void   0   vide
       char   ≥1   caractère
       short   ≥2   entier " court "
       long (ou int)    ≥4   entier "long"
       float   ≥4   nombre à virgule
       double   ≥8   nombre à virgule, plus précis
       long long int   ≥8   entier "très long "
       long double   ≥16   nombre à virgule précis
      Examples
      Quelques exemples d'utilisation.
      3/2 donne 1
( 3 * 2.0 ) / 5 donne 1.2

    2. Casting
      Explicit or implicit casting?
      Cast demandé ou cast implicite ?
      Exemple : 
      float inverse (int n) {
  if (n == 0.0) {
    return 0.0;
  }
  else {
    return (1.0 / (float) n);
  }
}
int serie (int n) {
  if (n == 0) {
    return 0;
  }
  else {
    return inverse(n) + serie (n-1);
  }
}
int main () {
  printf("%d \t=> \t %d\n",10, serie(10));
  printf("%d \t=> \t %d\n",50, serie(50));
  printf("%d \t=> \t %d\n",100, serie(100));
  printf("%d \t=> \t %d\n",1000, serie(1000));
}
/* ------------------  Essai -----------------
otake: a.out
10      =>       1
50      =>       1
100     =>       1
500     =>       1
1000    =>       1
---------------------------------------------*/

      Strange isn’t it?
      Il s’agit donc d’une série terriblement convergente (elle est constante) de valeur 1.
      Corrigez-la.

      Donnez la sous forme récursive terminale.

    3. Statement

      A statement is a ";", or an expression followed by an instruction (therefore with a ";" at the end).
      Une instruction est soit ";", soit une expression suivie d’une instruction (donc aussi de ";")
      A statement may also be presented as a { followed by a } and containing only valable statements. It is called a block
      Une instruction peut aussi être présentée comme un ensemble d’instructions entourées par des accolades. On parle alors de bloc.

 

    II.B) Operators/ Opérateurs

  1. Arity/Arité
    Division (/) needs two parameters. It said to have an arity of 2.
    La multiplication (*) est normalement un opérateur qui nécessite deux arguments, on dira qu'il est d'arité 2.
  2. Associativity/Associativité
    Is 7 or 1 the result of 7 / 2 / 2 ?
    Est-ce que 7/ 2 / 2 vaut 7 ou 1 ?
  3. Returned value/Valeur renvoyée
    Every operator returns a value.
    Tout opérateur renvoie une valeur.
  4. Priority/Priorité des opérateurs en C
      Operator   Associativity   Arity
       ()  []
      ->  .     		  GD   -
      !  ~  ++  -- + -   DG   1
      * & (type) sizeof   DG   1
      * / %   GD   2
      +  -   GD   2
      <<  >>   GD   2
      < <= > >=   GD   2
      == !=   GD   2
      &   GD   2
      ^   GD   2
      |   GD   2
      &&   GD   2
      ||   GD   2
      ? :   DG   3
      = += -= *= /= %=
     <<= >>= &= ^= |=     		  DG   2
      ,   GD   2


Dernière mise à jour le 6/9/2024 15h00