Types fondamentaux

Les opérateurs de comparaison entre les types fondamentaux se notent : <, >, <=, >=, = et <>.

Les entiers

Le type entier se note Integer. La division entière s’effectue avec l’opérateur \, et le reste de la division entière s’obtient avec l’opérateur Mod.
1 20 \ 3 ’ 6 (le quotient de la division entiŁre de 20 par 3)
2 20 mod 3 ’ 2 (le reste de la division entiŁre de 20 par 3)
Remarque : Les débordements de capacité sur les opérations entières provoquent une erreur à l’exécution. Ainsi, le type Integer est limité à des valeurs entre -32678 et +32767. Pour des capacités plus grandes, on peut utiliser le type Long, permettant des valeurs entre + ou – 2 mil-liards.

Les réels

Il existe deux types réels, les réels en simple précision (Single), autorisant 7 chiffres significatifs en virgule flottante, et les réels en double précision (Double), autorisant 15 chiffres significatifs. La valeur absolue s’obtient par la fonction prédéfinie Abs. La partie entière d’un réel s’obtient par la fonction Int ou la fonction Fix : ces 2 fonctions ont un comportement identique pour les réels positifs (par exemple Int(3.14) correspond à 3) mais se différencient pour les réels négatifs (Int(›3.14) correspond à -4, tandis que Fix(›3.14) correspond à -3). On peut également arrondir un réel en un entier avec la fonction Round : Round(3.14) vaut 3, et Round(3.5) vaut 4.

Les booléens

Le type booléen est Boolean. Les deux valeurs que peuvent prendre des variables booléennes se notent True et False. Les opérateurs logiques se notent And pour Et, Or pour Ou et Not pour
Non.
Remarque : Les expressions booléennes sont toujours évaluées totalement, même si un résultat partiel permet de connaître le résultat total. Par exemple, True Or expression calculera toujours l’expression, même si on sait que le résultat sera forcément True quelle que soit la valeur de l’expression.

Les caractères

Le type caractère n’existe pas en tant que tel en VBA. Ce n’est qu’un cas particulier des chaînes de caractères (cf. paragraphe suivant). Les fonctions algorithmiques Chr et Ord se notent respectivement Chr(i) et Asc(c).
1 c = « A » ’ la valeur de c est « A »
2 i = Asc(c) ’ la valeur de i est 65, code ASCII de « A »

Les chaînes de caractères

Une chaîne se déclare avec le mot-clé String. Une chaîne peut contenir jusqu’à 64 milliers de caractères. Il n’est pas utile de spécifier de taille maximale dans la déclaration d’une variable chaîne.
1 Dim chaine As String
2 chaine = « bonjour »

Constantes

Les constantes sont définies en utilisant le mot-clé Const à la place de Dim, en faisant suivre le type de la variable par sa valeur derrière le symbole = :
1 Cons PI As Single = 3.1415 ’ Valeur de PI
2 Const MAJORITE As Integer = 18 ’ Age correspondant à la majoritØ
3 Const TVA As Single = 19.6 ’ Taux de TVA en %
4 Const CAPACITE as Integer = 160 ’ Nombre maximum d’Øtudiants dans une promotion
5 Const INTITULE As String = « Algorithmique et programmation » ’ par exemple
6 Expressions

Instructions d’entrée/sorties

Opération d’entrée

En standard, le VBA utilise l’instruction InputBox qui permet d’effectuer une saisie dans une boîte-message fugitive. Dans le cadre de ce module d’algorithmique, nous utiliserons l’instruc-tion Saisir qui permet de saisir au clavier la valeur d’une variable et de garder trace dans la feuille de calcul courante de ce qui a été saisi :
1 Saisir Variable1
Attention : Il ne faut pas utiliser de parenthèses autour de la variable, contrairement à l’instruc-tion algorithmique Lire(Variable1). Une variante de l’instruction de saisie permet de proposer
à l’utilisateur une valeur par défaut qui sera affectée à la variable s’il se contente de valider la saisie sans entrer de valeur particulière :
1 Saisir Duree, 5 ’ la valeur 5 est affichØe en prØsØlection dans la boîte›message :
2 ’ si l’usager valide directement par la touche ’Retour›chariot’, la valeur 5 sera a

Opération de sortie

En standard, le VBA utilise l’instruction MsgBox qui permet d’afficher des informations dans une boîte-message fugitive. Dans le cadre de ce module d’algorithmique, nous utiliserons l’ins-truction Afficher qui permet d’afficher les informations dans la feuille de calcul courante.
1 Afficher « La durØe vaut  » & Duree
Noter l’utilisation de l’opérateur de concaténation & pour composer un message unique rassem-blant plusieurs informations mises bout à bout (ici, une chaîne littérale et le contenu d’une va-riable).
Attention : Tout comme pour l’instruction de saisie, il ne faut pas utiliser de parenthèses autour
des informations à afficher, contrairement à l’instruction algorithmique Ecrire(« La durØe vaut », Duree).
Il est également possible d’utiliser la forme suivante utilisant la virgule comme séparateur :
1 Afficher « La durØe vaut « , Duree
Dans ce cas, la valeur de la variable Duree sera placée dans la colonne suivante de la feuille de calcul. Cette forme sera utile si on veut afficher des informations tabulées. Noter que, si le premier élément « La durØe vaut  » ne rentre pas dans la première colonne, la partie qui dépasse sera tronquée à l’affichage et n’apparaîtra donc pas. L’instruction Afficher «  » utilisée avec un chaîne vide (symbole  » redoublé, et non pas 4 fois la quote simple) permet de sauter une ligne.
Exercice 1 : Cube d’un réel
Écrire un programme qui affiche le cube d’un nombre réel saisi au clavier.
Solution :
1 R0 : Afficher le cube d’un nombre rØel
2
3 Tests :
4 0›>0
5 1›>1
6 2›>8
7 ›2 ›> ›8
8 1.1 ›> 1,331
9
10 R1 : Raffinage De « Afficher le cube d’un nombre rØel »
11 | Saisir un nombre rØel x: out RØel
12 | Afficher le cube de x x: in RØel
13
14 R2 : Raffinage De « Afficher le cube de x »
15 | Écrire(x * x * x)

Affectation

L’affectation se note avec un signe =.
Attention : Il ne faut pas confondre l’affectation et le test d’égalité, même s’ils utilisent le même
opérateur =. Le contexte permet de les différencier sans ambiguïté : un test d’égalité apparaît dans une condition placée derrière If, While ou Until (cf. chapitre suivant sur les structures de contrôle).
1 i = 10 ’ affectation
2 If i=10 Then ’ test d’ØgalitØ
Exercice 2 : Permuter deux caractères
Écrire un programme qui permute la valeur de deux variables c1 et c2 de type caractère. Solution : Le principe est d’utiliser une variable intermédiaire (tout comme on utilise un réci-pient intermédiaire si l’on veut échanger le contenu de deux bouteilles).
1 Attribute VB_Name = « exo02_permuter »
2 ’*********************************************************************
3 ’* Auteur : Claude Monteil <monteil@ensat.fr>
4 ’* Version : 1.0
5 ’* Objectif : permuter deux caracteres
6 ’*********************************************************************
7
8 Sub permuter_caracteres()
9 Dim c1 As String, c2 As String ’ les deux caracteres a permuter
10 Dim tmp As String ’ variable intermediaire
11
12 EffacerEcran « Permitation de caractŁres »
13 ’1.initialiser c1 et c2
14 c1 = « A »
15 c2 = « Z »
16 Afficher « Avant : c1 =  » & c1 &  » et c2 =  » & c2
17 ’2.permuter c1 et c2
18 tmp = c1
19 c1 = c2
20 c2 = tmp
21 ’3.afficher pour verifier
22 Afficher « AprŁs : c1 =  » & c1 &  » et c2 =  » & c2
23 End Sub
Exercice 3 : Cube d’un réel (avec une variable)
Reprenons l’exercice 1.

Utiliser une variable intermédiaire pour le résoudre

Solution : On reprend le même R0 et les mêmes tests. En fait, seule la manière de résoudre le problème change.
1 R1 : Raffinage De « Afficher le cube d’un nombre rØel »
2 | Saisir un nombre rØel x: out RØel
3 | Calculer le cube de x x: in RØel ; cube: out RØel
4 | Afficher le cube
5
6 R2 : Raffinage De « Afficher le cube de x »
7 | cube <› x * x * x

1 Pourquoi définir notre langage algorithmique ? 
2 Structure d’un algorithme 
2.1 Exemple d’algorithme : calculer le périmètre d’un cercle
2.2 Structure de l’algorithme
2.3 Identificateurs
2.4 Commentaires
3 Variables 
3.1 Qu’est ce qu’une variable ?
3.2 Définition d’une variable
4 Types fondamentaux 
4.1 Les entiers
4.2 Les réels
4.3 Les booléens
4.4 Les caractères
4.5 Les chaînes de caractères
5 Constantes
6 Expressions
7 Instructions d’entrée/sorties 
7.1 Opération d’entrée
7.2 Opération de sortie
8 Affectation
9 Structures de contrôle 
9.1 Enchaînement séquentiel
9.2 Instructions conditionnelles
9.2.1 Conditionnelle Si … Alors … FinSi
9.2.2 Conditionnelle Si … Alors … Sinon … FinSi
9.2.3 La clause SinonSi
9.2.4 Conditionnelle Selon
9.3 Instructions de répétitions
9.3.1 Répétition TantQue
9.3.2 Répétition Répéter … JusquÀ
9.3.3 Répétition Pour
9.3.4 Quelle répétition choisir ?