TD d'informatique No. 1 :
Quelques programmes simples

Patrick Gros -- Patrick.Gros@irisa.fr
Didier Le Botlan -- didier.le_botlan@inria.fr

Lundi 13 novembre 2000

1   Rappels de java

1. ceux de type simple : boolean, char, int, double, short, float...
2. ceux de type complexe : String, les tableaux, les types définis par l'utilisateur.

Les objets de type simple.

• Il suffit de les déclarer pour pouvoir les utiliser.
• Lors d'un passage d'argument à une fonction, la valeur est recopiée : l'argument formel d'une fonction est donc similaire à une variable locale dont la valeur d'initialisation est fournie par l'instruction qui appelle cette fonction. Changer cette valeur ne modifie rien au niveau de l'instruction qui a appelé la fonction. Par exemple :

  class toto {
    static void fonction(int a) {
      System.out.println(a) ;
      a = a + 2 ;
      System.out.println(a) ;
    }
    public static void main(String[] arg) {
      int a = 2 ;
      System.out.println(a) ;
      fonction(a) ;
      System.out.println(a) ;
    }
  }    
  

  Ce programme écrira dans l'ordre 2 2 4 2 sur l'écran.

Les objets de type complexe.

• La simple déclaration ne réserve assez de mémoire que pour stocker une adresse mémoire.
• Pour allouer de la place pour l'objet lui-même, il faut utiliser l'opérateur new, suivi du type de ce que l'on veut allouer. Le résultat de l'opérateur est une adresse en mémoire (l'adresse de la place allouée), adresse que l'on peut stocker dans une variable du type.
• Ces deux opérations peuvent s'effectuer en une instruction. Exemple :

     int[] tableau1 ;
     tableau1 = new int[10] ;
     int[] tableau2 = new int[20] ;
     

• Les opérations sur ces objets telles l'affectation ou les comparaisons sont effectuées sur les adresses mémoire, pas sur les objets eux-mêmes.
  
  
• Lors du passage d'un tel objet en argument de fonction, c'est l'adresse mémoire qui est recopiée, pas l'objet. On peut modifier un objet dans une fonction et récupérer la modification après le retour de la fonction, mais une modification de l'adresse ne sera pas récupérable.
  
  
• Un cas particulier important est celui de l'adresse indéfinie null. Cette adresse indique... aucune adresse. Si elle est passée en paramètre, elle est recopiée. Si elle est modifiée dans la structure locale, cette modification ne peut être récupérée par le code appelant. Exemple :

     ...
     int[] tableau = null ;
     init(tableau) ;
     System.out.println(tableau[1]) ;    <--- ERREUR !
     ...
  
     public static void init(int [] t) {
       t = new int[10] ;
       for (int i = 0 ; i < 10 ; ++i)
         t[i] = 2 ;
     }
     

  Comment faire ?

     ...
     int[] tableau = null ;
     tableau = init() ;
     System.out.println(tableau[1]) ;    <--- OK !
     ...
     public static int[] init() {
       int[] t = new int[10] ;
       for (int i = 0 ; i < 10 ; ++i)
         t[i] = 2 ;
       return t ;
     }
     

  Et si on veut que la fonction prenne en argument un tableau éventuellement vide et renvoie un tableau éventuellement modifié ?

     ...
     int[] tableau = null ;
     tableau = init(tableau) ;
     System.out.println(tableau[1]) ;    <--- OK !
     ...
     public static int[] init(int[] t) {
       if (t == null)
         t = new int[10] ;
       if (t.length < 10) {
         int[] u = new int[10] ;
         for (int i = 0 ; i < t.length ; ++i)
           u[i] = t[i] ;
         t = u ;
       }
       for (int i = 0 ; i < 10 ; ++i)
         t[i] = 2 ;
       return t ;
     }
     

Pour aller plus loin

2   Pour commencer en douceur

3   Permutation aléatoire d'un tableau

Primo :

Écrivez un programme avec les fonctions suivantes :

1. Initialiser_Tableau qui initialise un tableau de taille n par les entiers de 0 à n ;
2. Afficher_Tableau qui affiche un tableau ;

et le programme principal qui fasse la chose suivante :

• recupère un entier n passé en argument de la fonction par l'utilisateur ;
• créer un tableau de taille n ;
• afficher le tableau.

Secundo :

Écrivez une fonction qui permute aléatoirement les éléments d'un tableau. La tester en modifiant le programme principal.

4   Recherche de palindrome

1. Écrire un programme qui récupère une chaîne en argument et qui dise si cette chaîne est un palindrome ou pas. Un palindrome est une phrase ou un mot qui est le même à l'endroit et à l'envers.
   
   
2. Écrire un autre programme qui fasse la même chose, mais en ignorant les séparateurs.

• Tu l'as trop écrasé, César, ce port salut.
• Engage le jeu que je le gagne.
• http://graner.net/nicolas/salocin/ten.renarg//:ptth

This document was translated from L^AT_EX by H^EV^EA.