Aller au menu - Aller au contenu

Icône Les données simples

Par Avatar Yno
Mise à jour : 09/07/2010
Difficulté : Facile Facile
170 visites depuis 7 jours, dont 24 sur ce chapitre classé 446/786
La première chose à apprendre sur Vala est la façon dont il gère les données. Tous les programmes informatiques manipulent des données : des nombres, du texte, des tableaux d'autres données (pensez à un carnet d'adresses par exemple), et ainsi de suite. Pour manipuler ces données dans un code, il sera également nécessaire de présenter les variables, qui servent à stocker des valeurs inconnues avant l'exécution, comme le sont les données d'un utilisateur.

Dans ce chapitre, nous présenterons donc comment Vala gère les données les plus simples. D'autres types plus complexes seront étudiés par la suite.
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Représentation des données en programmation

Lorsque vous écrivez un programme, celui-ci doit être conçu pour manipuler des données que vous ne connaissez pas encore (et que vous ne connaîtrez peut-être jamais précisément). Pensez par exemple à un logiciel de traitement de texte, qui doit manipuler des documents qui ne sont pas connus par l'auteur du programme. Pendant l'écriture du code, le programmeur doit néanmoins pouvoir désigner les textes qui seront écrits avec son logiciel. Par exemple, il doit pouvoir écrire une instruction correspondant à la sauvegarde du texte.

Le langage de programmation doit donc être capable de manipuler des données de façon abstraite, et de proposer un jeu d'opérations dessus : additionner des nombres, mesurer la longueur des chaînes de caractères (rappelez-vous que c'est ainsi qu'on désigne le texte, nous verrons pourquoi), modifier des fichiers, et ainsi de suite. Mais attention : il doit aussi être cohérent vis-à-vis de ce jeu d'opérations. Cela n'aurait pas de sens de mesurer la longueur d'un nombre ou d'additionner des fichiers, et à proprement parler on ne mesure jamais un fichier, mais bien son contenu.

Une donnée, c'est donc à la fois une valeur, et un type, qui représente sa nature. Un type, c'est un ensemble de valeurs possibles. Par exemple, on appelle "nombres entiers" l'ensemble des... nombres entiers. Les valeurs possibles sont alors 0, 1, 2... mais aussi -1, -2... et vous connaissez la suite. Ceci correspond à un type en Vala, appelé int. Ce nom ne vous est pas inconnu, si ? Nous l'avons en fait déjà rencontré dans le chapitre précédent.

Toutes les données que nous manipulerons auront donc un type, qui devra être connu par le compilateur (valac) au moment de la compilation. On dit que Vala est un langage statique, ou à typage statique, car il vérifie que toutes les opérations écrites dans le code ont un sens au moment de la compilation (ce qui n'est pas le cas de tous les langages de programmation).

Comme nous ne connaissons pas ces données quand nous écrivons notre code, le seul moyen que nous avons de les désigner et de programmer des opérations à leur sujet est de les appeler par un nom de notre choix. On dit qu'on utilise des variables : ce sont des étiquettes qui servent à faire comprendre au compilateur de quelles données nous parlons. C'est ensuite lors de l'exécution que ces variables seront remplacées par des véritables valeurs.
Retour en haut

Déclaration et utilisation des variables

Si vous avez fait du C, ou d'un langage dont la syntaxe ressemble à celle du C, vous ne devriez pas être surpris par la façon dont on utilise des variables en Vala (du moins pas dans un premier temps). Il faut tout d'abord déclarer cette variable en précisant au compilateur son nom ainsi que son type, selon la syntaxe type nom;, ou éventuellement type nom1,nom2; pour déclarer deux variables d'un même type, et ainsi de suite.

Un certain nombre de types sont possibles. Les principaux types simples sont :

  • int pour des entiers de taille raisonnable.
  • long pour des entiers un peu plus grands (mais pas infinis non plus).
  • float pour des nombres "à virgule flottante" à simple précision, appelés "flottants" tout court en informatique.
  • double pour des nombres décimaux à double précision.
  • bool pour les valeurs "vrai" ou "faux", qui ont un rôle tout particulier en programmation comme nous le verrons au chapitre suivant.
  • unichar pour des caractères (lettres, chiffres, symboles...).


Le type à utiliser est très souvent lié à ce que l'on souhaite faire de la variable. Avec l'habitude, vous ne vous poserez pas trop de questions à ce sujet. Il n'y a en fait que lorsque l'on souhaite utiliser de très grands entiers ou des nombres décimaux très précis que ces types ne suffisent plus, et que l'on est amené à se poser des questions très intéressantes, mais également assez complexes. Généralement, c'est une bonne occasion d'aller poser une question dans le forum :) .

Vala impose des restrictions sur le nom d'une variable : celui-ci doit être composé de lettres non-accentuées, majuscules ou minuscules, ou encore d'underscores _. On peut également utiliser des chiffres, mais pas en première position. Il n'est pas possible de reprendre un nom réservé par le langage, comme le mot clef public par exemple.

Une fois que votre variable est déclarée, il faut encore lui affecter une valeur. Cela se fait à l'aide du symbole d'égalité =, qui stocke la valeur de droite dans la variable de gauche (et jamais le contraire : vous ne pouvez pas échanger les deux). Naturellement, la valeur de droite peut être donnée par une autre variable. Considérez les exemples suivant :

Code : Vala
1
2
3
4
5
6
int a,b,c; /* On déclare trois entiers d'un coup */
a = 3; /* a vaut désormais 3 */
c = b = 4; /* et c et b valent 4 */
c = a;  /* c vaut désormais 3 également, mais b est inchangé */
5 = a; /* Interdit ! */
int d = b; /* On peut déclarer et initialiser des variables en même temps */

Retour en haut

Affichage de valeurs

Pour afficher un nombre, quelle que soit sa nature, il faut passer par la méthode printf de l'objet stdout. C'est une méthode particulière, qui prend en argument une chaîne dite de format, qui contiendra des passages de la forme "%d" ou "%f". Ce sont des codes particuliers, qui seront remplacés par les valeurs à afficher. Le premier signifie "entier", le second "flottant". Naturellement, il faut ensuite passer à printf les valeurs à afficher, comme dans le programme suivant (qui utilise une variable à titre d'exemple) :

Code : Vala
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Main
{
  public static int main (string[] args)
  {
    int a = 3; 
  
    stdout.printf("a vaut %d, et on affiche également %f", a, 1.1);
    
    return 0;
  }
}


Un tel programme affichera a vaut 3, et on affiche également 1.1.
Retour en haut

Opérations usuelles, conversions

Plusieurs sortes de nombres…


Dans le programme précédent, vous pouvez essayer de changer le type de a en flottant, et de mettre une valeur non-entière (comme 3.1 par exemple). Si vous essayez de compiler votre code, vous aurez une erreur affichée en rouge dans la fenêtre du bas : main.vala:5.11-5.17: error: Assignment: Cannot convert from `double' to `float'. C'est un problème particulier, lié à la précision des nombres décimaux. Par défaut, Vala les considère comme des nombres à double précision, donc du type double.

Mais ici, vous tentez de stocker cette valeur dans un float. Il y a donc une perte d'informations potentielle, et Vala juge bon de vous prévenir. Pour que votre programme compile, vous devez confirmer que c'est bien un flottant que vous voulez. Pour cela, deux solutions :

Code : Vala
1
2
float a = (float) 3.1;  /* On rajoute un (float) entre le nombre et le = */
float a = 3.1f;


Et ainsi votre programme compilera.

Passons aux opérations. Les nombres supportent toutes les opérations usuelles, telles que l'addition (+), la soustraction (-), la multiplication (*) et la division (/). Naturellement, si on additionne, soustrait ou multiplie deux entiers, on récupère un entier. En Vala, c'est également vrai pour la division : 46/3 sera, sans indication particulière, évalué comme l'entier 15 (pourtant, si vous faites le calcul à la main...). Vous pouvez vous en convaincre en exécutant le programme suivant :

Code : Vala
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class Main
{
  public static int main (string[] args)
  {
    int a = 3; 
    int b = 46;
  
    stdout.printf("%f", b/a);
    
    return 0;
  }
}


Même avec l'instruction de formatage "%f" , Vala convertit votre entier en flottant, mais seulement après la division (donc quand le reste a déjà été perdu). Vous devez lui préciser que vous souhaitez le résultat décimal en réalisant ce que l'on appelle un transtypage (cast en Anglais). En fait, cela revient exactement au même que ce que nous avons fait juste au dessus : il faut encore une fois préciser que c'est un flottant que vous attendez. Mais cette fois-ci, la seule possibilité est de le faire à l'aide du mot float. Le programme devient alors

Code : Vala
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class Main
{
  public static int main (string[] args)
  {
    int a = 3; 
    int b = 46;
  
    stdout.printf("%f", (float) b/a);
    
    return 0;
  }
}


Ainsi, c'est bien un décimal qui sera calculé.

Autres conversions



Parfois, d'autres conversions de types sont souhaitables, par exemple passer d'une chaîne à un nombre, ou vice-versa. Dans ce cas, on utilise des méthodes proposées par les objets à convertir : par exemple, pour convertir un entier a en chaîne, on écrira a.to_str(). Naturellement, ceci ne modifie pas la variable a : il est interdit pour une variable de changer de type !

Cela renvoie en fait une nouvelle valeur, que l'on peut stocker dans une variable ou utiliser directement. Les chaînes de caractères supportent quant à elles les méthodes to_int et to_double pour réaliser vos conversions. Par exemple on peut écrire :

Code : Vala
1
2
3
string a = "43";

stdout.printf("a = %d", a.to_int() - 1);


Nous reverrons ces conversions plus tard.
Retour en haut

Lire des données au clavier

Il est évidemment plus pratique de ne pas devoir recompiler tout un programme pour l'utiliser avec de nouvelles valeurs. Dans cette section, nous allons donc apprendre à lire des valeurs au clavier pour les stocker dans des variables. C'est là que nous allons découvrir le véritable intérêt des variables : leur valeur est inconnue à la compilation, mais on peut néanmoins écrire des instructions pour les manipuler.

La lecture se fait à l'aide de la méthode scanf de l'objet stdin. Comme printf, elle prend en premier argument une chaîne de format qui sera utilisée pour déterminer les valeurs à lire. Il faut également lui fournir à la suite les variables qu'elle doit modifier. Cependant, nous ne pouvons pas écrire par exemple

Code : Vala
1
stdin.scanf("%d", a);


car cela reviendrait à passer à scanf la valeur de a, alors que ce que nous voulons, c'est justement que scanf assigne à a une nouvelle valeur. Pour cela il faut en quelque sorte faire sortir la variable a, à l'aide d'un nouveau mot-clef : le mot out. Par exemple :

Code : Vala
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class Main
{
  public static int main (string[] args)
  {
    int a;
    float b;
    
    stdout.printf("Entrez deux valeurs\n"); /* On revient à la ligne avec \n */
    stdin.scanf("%d %f", out a, out b);
    stdout.printf("On a lu %d et %f", a, b);
    
    return 0;
  }
}


Dans ce cas, la saisie des valeurs se fait en les séparant par une espace. On obtient une session comme la suivante :

Code : Console
Entrez deux valeurs
12 43.12
On a lu 12 et 43.119999





Notez le problème de précision de la deuxième valeur : les ordinateurs ont souvent du mal à représenter les nombres décimaux, pour des raisons qui dépassent le cadre de ce tutoriel. Il faudra faire avec, heureusement nous verrons comment afficher les nombres avec des arrondis, de sorte que l'utilisateur ne s'aperçoive de rien !




Si nous n'avions pas utilisé le mot-clef out
 par exemple pour a, valac nous aurait signalé une erreur, de la forme error: use of possibly unassigned local variable `a'. En fait, le mot clef out est également là pour signaler que nous attendons bien de scanf qu'il initialise notre variable. C'est une sécurité supplémentaire.



Il faut bien sûr veiller, comme dans le cas de printf, à ce que la chaîne de format coïncide avec les types des variables utilisées. De plus, si l'utilisateur rentre n'importe quoi, nous n'avons pas de moyen de le vérifier. Pour l'instant...



                

                
Retour en haut

            


Vous avez maintenant une certaine idée de la façon dont un programme informatique comprend les données, et ce qu'il est capable d'en faire. Conversions, arrondis... c'est pas rigolo tous les jours, mais il y a fort à parier que vous ne rencontrerez jamais de problèmes avec les types dont Vala dispose.



    

        
            
            
        
    


    

        
            

                

                    
                    
                    
                

            

        
            Chapitre précédent
        
            Sommaire
        
            Chapitre suivant
        
    







    
Retour en haut



    
Partager

    


    


    

    
Retour en haut

    
            

                5 commentaires pour "Les données simples"
                

                    Note moyenne :
                        3.63
                    / 4
                    (35 votes)
                    
                

            

        
        

            
              

                Pseudo
                Commentaire
              

            
            
              
                

                  
                    
                      Hors ligne 
                    
                      bluestorm
                    
                  
                  
                    #
                    
                         Posté le 25/06/2010 à 10:57:14
                    
                    
                


                
                    

                
                
                    

dont ask to ask
Avatar

            Groupe : Anciens
        	
	

		Flux RSS 
	




	
	close







    





                		
                
                    
                    Citation
Il faut donc faire sortir cette variable de son contexte local, à l'aide d'un nouveau mot-clef : le mot out.




Je trouve ce passage peu compréhensible. "contexte local" ? "variable" ou "valeur" ?



Ça me semble être une fonctionnalité importante de Vala, et qui en plus ne sera pas à priori connue des lecteurs (qui ne font en général pas de Ada avant). Il me semble donc important de bien l'expliquer et la détailler dans son ensemble, plutôt qu'à coup de cuillère en passant.



J'ai eu du mal à trouver une documentation potable sur le sujet, mais celle-ci est bien. Ils parlent de "direction du paramètre" et je pense que c'est une bonne métaphore.



Je ne dis pas qu'il faut traiter en détail cette construction ici. Je pense qu'il serait préférable d'éviter d'en parler au début, et la présenter en entier dans une partie dédié, pour bien montrer qu'il faut réserver du cerveau pour cette partie.

Si vous avez quand même besoin d'utiliser scanf avant, pourquoi pas, mais il faut trouver une explication "temporaire" plus compréhensible.
                    
                        
big tuto algorithmique | tuto récursivité [PHP] | tuto typage | textes divers




 Ours & Hippy

 — le blog

                        
 

                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      anonyme
                    
                  
                  
                    #
                    
                         Posté le 25/06/2010 à 14:15:17
                    
                    
                


                
                    

                
                
                    




    





                		
                
                    
                    On trouvera donc une explication temporaire plus compréhensible.
                    
                
                

              
                

                  
                    
                      Hors ligne 
                    
                      antoyo
                    
                  
                  
                    #
                    
                         Posté le 11/07/2010 à 05:24:26
                    
                    
                


                
                    

                
                
                    

GNU/Linux forever!
Avatar



     Études : Cégep de rimouski






                		
                
                    
                    Salut,

chez moi, ce code ne fonctionne pas :

Code : Vala
1
string chaine = a.to_str()





Je dois faire ceci :

Code : Vala
1
string chaine = a.to_string()





Il donne d'ailleurs to_string()
 dans la doc'.
                    
                        
Mon extension pour Chrome/Chromium :

SaveAllPasswords : vous permet d’enregistrer vos mots de passe sur tous les sites Web (même ceux qui ne veulent pas :D ).

                        
 

                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      Daedalus11
                    
                  
                  
                    #
                    
                         Posté le 12/07/2010 à 11:25:28
                    
                    
                


                
                    

                
                
                    

Gambas!
Avatar

    

    Avis : Très bon
        
    



    





                		
                
                    
                    Je suis d'accord avec Bluestorm sur l'utilisation du mot-clé out.

C'est très peu explicite et il faut du moins fournir un paragraphe explicatif (si tu ne veux pas faire du détail tout de suite.) 



Citation : Cours
car cela reviendrait à passer à scanf la valeur de a, alors que ce que nous voulons, c'est justement que scanf  assigne à a une nouvelle valeur.




C'est compréhensible/déductible pour certains programmeurs en herbe mais pas pour tous. 

Etendre l'explication. C'est vague. 




    
	
  • Soit l'utilisation de stdin.scanf est à exlure temporairement.
    • 
	
  • Soit conserver sa visibilité dans ce tutoriel mais ne pas rester dans le flou des nouveaux concepts abordés. 
    • 


                    
                        
Image utilisateurQui a dit qu'une crevette était Basic ? 



                        
 

                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      positron
                    
                  
                  
                    #
                    
                         Posté le 26/06/2011 à 22:49:38
                    
                    
                


                
                    

                
                
                    

Avatar



    





                		
                
                    
                    En quoi vala est-il différent du C mis à part le code objet possible et la libération mémoire ?

Quand on regarde un programme vala on dirait un programme C.

Pourquoi étudier vala quand on peut étudier C++ ?
                    
                		
                

              
            
        

        
            
Voir tous les commentaires