________ _______ ________ ________
| | | \ | | | |
| __ | | __ | | __ | | _____|
| |__| | | |__| _| | | | | | | ___
| _____| | __ \ | |__| | | |_|_ |
| | | | | | | | | |
|__| |__| |__| |________| |________|
programmation : algorithmique, langage objet
IFPA Bordeaux 09/2002
Sommaire
Introduction
CHAPITRE 1 - Algorithmique
1.1. Definition
1.2. Syntaxe generale
1.3. Structures conditionnelles
1.4. Types complexes (tableaux - fichies)
1.5. Communications entre actions
1.6. Types structures
CHAPITRE 2 - C++, langage objet
2.1. Introduction au language objet
CHAPITRE 3 - Visual basic, langage objet
3.1. Notions elementaires
Introduction
Ce document a été écrit dans le but de condenser les informations utiles sur la programmation afin d'être un guide ultime. Il a été écrit avec un editeur de texte, pour etre imprimable sous forme de fiches miniatures. Ce document suppose que vous avez déjà quelques notions de programmation.
Basic: Ce langage est assez facile à utiliser, mais il génère des applications limitées en taille, assez peu performantes et lentes.
Pascal: Ce langage est bien structure, d'une difficulté moyenne, il donne des applications rapides.
C, C++: Ce langage laisse une grande liberté au programmeur, il est assez difficile à utiliser, il donne des applications performantes et rapides.
Visual Basic: Facile à utiliser, ce langage génère des exécutables assez lents. (même avec une amélioration de vitesse sur la dernière version).
Delphi: Ce langage offre beaucoup de possibilités, les exécutables sont très rapides. Il est utilisé par les professionnels. Delphi 5, 7 2006 pour Windows XP, XE3 pour Windows 8 et 10. Sa déclinaison Kylix 3 destinée à Linux a été abandoné par Borland.
C++ Builder: Semblable à Delphi, la syntaxe diffère, mais les possibilités sont voisines.
Lazarus Lazarus est le RAD/EDI qui s'approche le plus possible de Delphi. Free Pascal Compilateur sous licence GPL fonctionnant sous Linux, Windows, OS2 Mac OSX, BSD, iOS, Android, etc. Il est conçu pour interpréter et compiler le Pascal Objet de Delphi. A la différence de Java dont le slogan est: « write once run anywhere » celui de Lazarus et Free Pascal est: write once compile anywhere »
CHAPITRE 1 - Algorithmique
Definition:
Ensemble de règles operatoires dont l' enchainement permet de resoudre un probleme au moyen d'un nombre fini d'operations. Les deux reigles pricipales d'un algorithme, sont:
- Un algorithme doit s'executer en un temps fini.
- Un algorithme manipule des informations simples ou complexes (structurees).
Syntaxe generale:
1) forme d'un programme d'algorithme
Action: <nom du programme> ex: Action: progexemple
Specif: <description du prog> Specif: pour comprendre
Constantes Constante
nom_cte : valeur CLX : 2
Variables Variables
nom_variable : type i : entier
Debut Debut
...... (lignes de code) i <- CLX + 2
Fin Fin
2) operateurs, et operations
operateurs de condition: ...... <, >, >=, <=, =, <> operateurs logique/booleen: ... et, ou, non operations: ................... +, -, *, /, mod symboles de priorite: ......... () ex: lire(a,b) Entree: lire(liste de variables) ecrire(a+b) Sortie: ecrire(liste de variables)
Structures conditionnelles:
Chaque action est compose d'une commande, ou de plusieurs commandes dans une structure debut fin.
structure si structure selon que
~~ ~~~~~~~~~
si <condition vrai> Selon que
alors <action1> <condidition1> : <action1>
sinon <action2> <condidition2> : <action2>
Fin Selon
si <condition vrai>
alors <action>
structure repeter structure tan que
~~~~~~~ ~~~~~~~
repeter <action> tan que <condition vrai>
jusqu'a <condition> faire <action>
structure pour
~~~~
pour <variable> de <debut> a <fin> par pas de <index>
faire <action>
Types complexes (tableaux - fichies):
1) tableau
Variables Tab ___________________ _ _
Tab : Tableau [1 ... 20] d'entiers | 10 | 20 | 30 | 40 |
i : entier |____|____|____|____|_ _
Debut i 1 2 3 4
Pour i de 1 a 20 par pas de 1 Tab ___________________ _ _
Faire lire(Tab[i]) | 11 | 21 | 31 | 41 |
Pour i de 1 a 20 par pas de 1 |____|____|____|____|_ _
Faire Tab[i] <- Tab[i]+1 i 1 2 3 4
Fin
2) tableau a 2 dimensions
Tab [1...5] [1...7] represente un tableau de 'l' chaines de 'c' caracteres
l c
Pour i de 1 a 5 par pas de 1
Faire Debut
Pour j de 1 a 7 par pas de 1
Faire ecrire(Tab[i][j])
Fin
3) fichiers sequentiel
modes: lecture, creation, ajout Variables
etats: FdF, Succes, Echec fic: fichier sequentiel d'entiers
nb : entier
<varfic> : fichier sequentiel de <type> Debut
ouvrirfichier(<varfic>, <mode>) ouvrirfichier(fic, lecture)
lirefichier(<varfic>, <vartype>) lirefichier(fic, nb)
etatfichier(<varfic>) fermeturefichier(fic)
ecrirefichier(<varfic>, <vartype>) ouvrirfichier(fic, ajout)
fermeturefichier(<varfic>) ecrirefichier(fic, nb)
fermeturefichier(fic)
Fin
Communications entre actions:
On doit decouper les actions en action plus petites, pour la comprehension, la maintenabilite, et pour reutiliser des actions dans d'autres actions.
La Fonction retourne obligatoirement une valeur de sortie. L'Action accepte des parametres ou arguments mais ne retourne rien.
Une action manipule:
- des donnees externes, (lire ecran, lire fichier)
- des resultat externes (ecrire ecran, ecrire fichier)
- des donnees de travail locales propre a l'action
- des parametres d'entree (E) fournis par l'action appelante
- des parametres de sortie (S) renvoyees a l'action appelante
- des parametres d'entree/sortie (E/S) rucu de l'appelante, puis renvoyees
Action <nom_action> (E nompar1, nompar2 : type 1,
nompar3 : type2
S nompar4 : type
E/S nompar5 : type )
Fonction <nom_fonction> (E nompar : type) : type
Variable
pour_retourner : type
Debut
...
Retourner(pour_retourner)
Fin
Action appelante Action appelee
Action cube(E x, Fonction carre (E var) : entier
S y) Debut
Variables retourner(var*var)
a : entier Fin
Debut
a <- carre(x) Une action ou une fonction peut se rappele elle
y <- a*x meme si une condition de sortie a ete prevu.
Fin
Types structures:
types enumere: type entite compose de constantes symboliques Action main Action main Specif exemple enumere Specif exemple entite Type Tfeu = (Rouge, Orange, Vert) Type Tdate = entite (Jour: 1...31, Variable Mois: 1...12, feucircul : Tfeu annee: entier) Debut Variable feucircul <- Rouge datnais.Jour si feucircul = Rouge et .. Debut alors feucircul <- Vert datnais.Jour <- 10 Fin Fin
Structure de structures ...
Type personnage1 = entite (nom: tableau [1...20] de caracteres,
naissance: Tdate)
Variable
jacque : personnage1
Debut
lire(jacque.naissance.Jour)
Fin
CHAPITRE 2 - C++, langage objet
2.1. Introduction au language objet:
Pourquoi la p.o.o (Programmation Oriente Objet)?
Pour la modularite: modules independant les uns des autres. Pour la maintenabilite et la reutilisabilite. L'objectif est de reutiliser le maximum d'objets existant.
attribut: ensemble de variables qui constituent les donnees de la classe. methode: ensemble des fonctions qui constituent les traitements de la classe classe: une classe est un type d'objet qui regroupe attributs et methodes. objet: un objet est l'integration d'une classe. instance: variable qui a été déclarée du type d'une classe. encapsulation: regroupement des donnees dans un objet pour masquer les attributs interphace: vue externe de l'objet (prototype des differentes methodes) accesseurs: methodes qui renvoient ou qui modifie la valeur d'un attribut.
ex: objet voiture
donnees: vitesse, couleur, marque, annee, ...
traitement: se deplacer, prendre de l'essence, s'user, ...
voiture r5,r21,mustang;
r5,r21 et mustang sont des instances de l'obet voiture.
cette methode permet d'eviter que des variables soient modifiees n' importe ou, et intempestivement.
ex: r5.annee=1976; // pas bon
r5.setannee(1976); // bon: principe d'encapsulation
Si l' attribut annee change de nom dans la classe, on aura pas a modier tout le programme. L'encapsulation n'est pas obligatoire en c++, c'est au programmeur de faire attention.
Entrees/Sorties:
cin objet entree standard dans la librairies
ex: int n;
float f;
cin >> n >> f ; // scanf("%d%f",&n,&f);
cout << n << " " << f << endl ; // printf("%d %f\n",n,f);
La compilation se fait par g++. Les extensions sont .cpp .cc .c++ .h
Passage de parametres par reference:
transmission par valeur: echange (int, int ) // proto ici on travaille avec des recopies des arguments de la fct appelante.
transmission par reference: echange (int &, int &); // proto ici on travaille directement avec les arguments de la fonction appelante.
ex: void echange (int &, int &); void echange (int &a, int &b) {
main () { int temp;
int a, b; temp = a;
cin >> a >> b; a = b;
echange (a,b); b = temp;
} }
Une reference est un alias, un synomyme d'une autre variable. Il est donc impossible de faire int &n = 3;
int n, q=6; // p <=> n fct(3);
int &p = n; // p fait reference a n fct(const int &x) {}
p=q; // pointeur constant sur n
Portee d'une variable:
En c, la portee d'une variable n'est que dans le bloc ou elle est declaree. En c++, il est possible de declarer une variable n'importe ou.
Pour définir une variable globale dans plusieurs fichiers il faut la définir en extern dans le fichier d'en tête (Header), et la déclarer dans un des fichiers utilisateur. Cela permet de la rendre visible par tous les fichiers qui inclue .
Arguments par default:
On met d'abord les parametres obligatoires puis les parametres par defaut. S'il n' y a que des parametres par defaut, la fonction devrat etre appelee sans parentheses. On appele la meme fonction de plusieurs manieres differentes.
void fct (int, int=0, int=0); void fct (int m, int n, int o) {
main () { cout << m << ' ' << n << " " << o;
int a=10, b=5, c=30; }
fct (a); // => 10 0 0
fct (a,b); // => 10 5 0
}
Surdefinition des fonctions:
Le compilateur fait la difference entre fonctions, par le nom, le nombre d'arguments, les types des arguments. Le type retourne n'est pas pris en compte.
ex: int fct (float);
int fct (int);
int fct (double);
int fct (); // fct; fct();
S'il existe une fonction surdefinite sans parametres, l'appel de cette fonction peut se faire de 2 maniere distinctes; avec ou sans parentheses. Dans ce cas, il ne doit pas y avoir une fonction avec que des parametres par defaut, car la distinction n'est pas possible.
Utilisation des classes:
Les classes existantes se situe dans un seul fichier ".h" . Il faut inclure la classe sans le ".h", creer une instance de la classe, puis utiliser les methodes existantes.
ex: #include <string> operateurs disponibles avec <string>
string chaine1; pour les chaines de caracteres
chaine1="Bonjour" = affectation <,> comparaison
chaine1.find("jour"); // 3 + concatenation
chaine1.find('u'); // 5
chaine1.find('o',3); // 4
chaine1.begin(); // 'B'
chaine1.size();
Traduction des notions de classes et objets:
Une classe est une structure evoluee, qui permet de regrouper non seulement des donnees, mais aussi des fonctions (methodes). L'acce aux champs, et aux methodes se fait avec l'operateur "."
ex: fichier: "point.h"
class point {
private: // propriete invisible par l'utilisateur
int x;
int y;
public: // visible par l'utilisateur
void initialise(int, int);
void deplace(int, int);
void affiche();
};
void point::initialise(int abs, int ord) {
x=abs; y=ord; } // ex point a; a.initialise(5,2);
void point::deplace(int dx, int dy) {
x=x+dx; y=y+dy; } // ex point a; a.affiche();
void point::affiche() {
cout << "abscisse :" << x << "ordonnee :" << y; }
Chaque proprietes et chaque methodes doit etre soit en private, soit en public. Les sous fonctions des methodes principales doivent etre definis en private.
Constructeur et destructeur:
constructeur: methode lancee automatiquement a la creation d'une instance destructeur: methode lancee automatiquement a la destruction d'une instance
Le constructeur a le meme nom que la classe. Le destructeur egalement mais avec un ~ devant le nom. Ces fonctions ne retournent pas de valeur, et doivent etre public. Le destructeur n'a pas de parametres.
ex: class point { point::point(int abs=0, int ord=0) {
private : x=abs; y=ord;
int x,y; }
public : point::~point() {
point(int, int); cout << "appel du destructeur";
point(); }
~point(); point::point() { x=0; y=0; }
void deplace(int, int);
}; main () { point a(1,2),b,c(1); }
Allocation dynamique de memoire:
Le C++ a introduit 2 operateurs new et delete qui remplacent malloc et free.
int *p;
p = new int; // p=(int*)malloc(sizeof(int));
delete p; // Il ne faut pas oublier de detruire l'objet.
p = new int[5]; // p=(int*)malloc(sizeof(int)*5);
delete [] p;
meme avec new, le constructeur est appele.
Attributs statiques:
Lors de chaque création d'une instance, les attributs, et les pointeurs sur les méthodes sont recopiées en mémoire. Ainsi chacune des instance contient ses propres attributs. Le fait de déclarer un attribut 'statique' peut permettre à toutes les instances de partager la meme donnée.
ex: class point { int point::nb_instances=0;
private: point::point(int a, int b) {
int x,y; x=a; y=b;
static int nb_instances; nb_instances++;
public: cout << "inst: " <<nb_instances;
point(int, int); }
void affiche(); point::~point() {
~point(); nb_instances--;
}; }
Transmissions d'objets:
point p1(2,3), p2(5,2);
recopie: int point::fct(point p) { cout << p.x; } p1.fct(p2); adresse: int point::fct(point *p) { cout << p->x; } p1.fct(&p2); reference: int point::fct(point &p) { cout << p.x; } p1.fct(p2);
On peut retourner un objet: int point::fct() { point p; return (p); } p2 = p1.fct();
Constructeur par recopie:
Le compilateur c++ integre un mecanisme de recopie par defaut, si la classe n'a pas defini de constructeur par recopie.
point a(2,3);
point b=a;
Si la classe contient des pointeurs, le compilateur va affecter les memes adresse des attributs pointeurs de a aux attributs pointeurs de b. On aura des pointeurs differents pointant sur la meme zone!
constructeur par recopie:
ex: class tab { tab::tab(int nb_elem) {
private: nb=nb_elem;
int nb; adr=new int[nb];
int *adr; for(int i=0; i<5; i++) adr[i]=i;
public: }
tab(int nb); tab::tab(const tab & t) {
~tab() { delete [] tab; }; t.nb = nb;
tab(const tab &) t.adr = new int[nb];
}; for(int i=0; i<5; i++)
t.adr[i]=adr[i];
main() { }
tab t1(5);
tab t2 = t1;
}
Heritage:
L'heritage permet de definir une nouvelle classe a partir d'une classe de base. On parle alors de sous classe, ou de classe derivee. Cela permet de hierarchiser et de creer des modeles entre les classes.
Les acces aux membres de la classe de base, par la classe derivee, depand du
statut des membres dans la classe de base:
______________ ________________________ _____________________
Statut dans la Acces aux membres de la Acces aux membres de
classe de base classe de base par un la classe de base par
utilisateur de la classe une classe derivee
______________ ________________________ _____________________
public oui oui
private non non
protected non oui
L'heritage entre les 2 classes est implemente par la declaration de la classe derivee: class classe_derivee : public classe_de_base
class pointcol : public point { pointcol::colore(int col) {
private: couleur = col;
int couleur; }
public: pointcol::affiche() {
void colore(int); point::affiche();
void affiche(); cout << couleur;
}; }
Il est possible de forcer une instance main() { de la sous-classe a appeler la methode pointcol p1(2,6); de la classe de base p1.point::affiche(); } Le lancement des constructeurs se fait du sommet vers le bas de la pyramide d'heritage. Et les destructeur du bas vers le haut. Si un constructeur d'une sous classe necessite de nouveaux parametres, il faut faire un appel explicite:
ex: class pointcol : public point { class point {
public: public:
pointcol(int, int, int); point(int int);
int couleur; };
}
pointcol::pointcol(int a,int b,int c) : point(a, b) {
couleur = c;
}
Il en est de meme pour le constructeur par recopie:
pointcol::pointcol(pointcol & p) : point(p) {
couleur = p.couleur;
}
Sur definition d'operateurs:
Il est possible de redefinir les operateurs =, +, -, *, /, == pour une classe. Le prototype de la fonction s'ecrit: nom_classe operator + (nom_classe)
ex: class point {
int x,y;
public:
point(int abs=0, int ord=0) {x=abs; y=ord;}
point operator + (point);
void operator = (const & point);
int operator == (const & point);
}
point point::operator + (point a) {
point p;
p.x = x + a.x; p.y = y+a.y;
return p;
}
void point::operator = (const & point) {
this.x = x;
this.y = y;
}
int point::operator == (const & point) {
if((this.x == x) && (this.y == y)) return 1;
else return 0;
}
Gestion des Exceptions
struct Exception {}; //Il est possible de choisir n'importe
//quel type pour l'exception.
try {
throw Exception();
}
catch (Exception){
throw; // propage au niveau superieur
}
Si throw est exécuté dans un bloc try (depuis une fonction), les clauses catch associées à ce bloc sont examinées pour voir si l'une d'elles peut gérer l'exception. Si une clause catch est détectée, l'exception est gérée. Si aucune clause catch n'est détectée, la recherche se propage dans les bloc try-catch de niveau supérieur. Si aucun gestionnaire n'est trouvé, le programme appelle la fonction terminate() définie dans la bibliothèque du C++ standard. Cette fonction appelle abort() qui indique "Abnormal program termination".
CHAPITRE 3 - Visual basic, langage objet
3.1. Notions elementaires
Ce chapitre regroupe toutes les notions de base du Basic, de son compilateur, et de l'environnement de programmation.
Variables
Visual Basic n'est pas sensible au majuscules et aux minuscules.
- declaration : Dim a As String, Dim i As integer
- affectation : a = "tete a toto", i = 15+17*3
- lecture : MsgBox(a);
- operations : iv= 7 < (16/2), iv=2*5
- operandes : + - / * < > <= >= <> = And Or Xor Not
- commentaires : Rem ' Commentaire
1.2. Types de donnees simples
Declaration implicite: La variable est declaree au moment de son utilisation.
Nom$ 'ajout d'un suffixe correspondant au type DefStr a-c, z ' les variable commencant par a,b,c, ou z seront du type String DefInt i-l
Declaration explicite: La variable est declaree avant son utilisation.
Dim : Reinitialise la variable Static : conserve la precedente valeur Private : variable privee
Definifion de constantes Creation d'un type utilisateur:
(facilite la maintenance): Public Type udtEmployes
Const USER1 = 0; Matricule As String * 5
Const NOIR = &H0& Nom As String * 20
Age As Integer
End Type
Creation d'une variable:
Dim vntnm As Variant ' --- Type de donnee quelconque ---
' --- Type de donnee logique ---
Dim blnnm As Boolean ' 'True' & 'False'
' --- Type de donnee Entiere ---
Dim bytnm As Byte ' 0 a 255
Dim intnm As Integer ' % -32,768 a 32,767
Dim lngnm As Long ' & -2,147,483,648 a 2,147,483,647
Dim sngnm As Single ' ! +/-3,402823E38 a +/-1,401298E-45
Dim dblnm As Double ' # +/-1,79769313486232E308 a +/-4,94065645841247E-324
Dim curnm As Currency ' @ -922337203685477,5808 a 922337203685477,5807
' --- Type de donnee texte ---
Dim strnm As String ' Ocupe 1 caractere, alphabet ASCII
' --- Type de donnee date ---
Dim dtmnm As Date ' du 01/01/100 au 31/12/9999
Type de donnees tableau et enregistrement
Il est possible de creer des tableaux de variable dans chacuns de ces types.
Dim sngFrais (12) As Single ' 12 elements de 0 a 11
Dim sngFrais (1 To 12) as single ' 12 elements de 1 a 12
Dim sngTrain(10, 1 To 15) as single ' 0 a 9 tableaux de 1 a 15 elements
' Si Option Base 1
Dim sngFrais (12) ' 12 elements de 1 a 12
Ces tableaux peuvent etre bornee ou non. Il est possible de definir la longueur d'un tableau par "ReDim".
Dim Tableau() ' tableau dynamique
ReDim Tableau (15 To 50) ' reinitialise
ReDim Preserve Tableau (15 To 50) ' conserve les valeur
1.6. Structures de controle
' structure if then else ' structure case ' with
If i >= 10 Then Select Case i With Lblnom
ElseIf // Case 0 instruction .Caption = 'Nom'
Else // facultatif Case 1 To 10 inst End With
End if; End Select;
' structure for ' structure while 'structure Do Loop
For i=5 To 10 Step 1 While i*2<22 Do
Exit For i = i + 1 i = i + 1
Next Wend Loop [while|until] i > 12
For Each Control In Controls
Control.BackColor = vbBlue
Next
Tant qu'une boucle n'est pas fini, le programme prendra toutes les ressources. Lancer la procédure "DoEvents" dans la boucle permet au système de reprendre la main à chaque tour, et ainsi mettre à jour l'interface.
Les sous programmes
|
Il existe 4 types de sous programmes:
Il existe 3 niveaux de sous programme:
|
passage de parametres:
Dans le passage par valeur, il s'agit d'une recopie de la variable, mais dans le passage par reference c'est la meme variable parente qui est utilisee. Elle est realisee par le mot ByRef lors de la declaration de la fonction. Sur un paramettre Optional il est possible de definir une valeur par defaut.
ByVal passage par valeur ByRef passage par reference Optional parametre optionnel (derniers parametres de type Variant) ParamArray tableau de parametre (derniers parametres sans ByVal,ByRef,Optional)
Il est possible de passer les parametre dans n'importe quel ordre a partir du moment ou on nomme ses parametres ex: Surface(largeur:=15, longueur:=15)
Function MaFonction(ByRef text, Optional ByVal left As Variant = 0) As String
If IsMissing(left) Then left = 0
MaFonction = Left(text, left)
End Function
L'appel d'un sous programme d'un autre module se fait par module.ssprog arg1, ..
Traduction des notions de classes et objets
Une classe est une structure evoluee, qui permet de regrouper non seulement des donnees, mais aussi des fonctions (methodes). L'acce aux champs, et aux methodes se fait avec l'operateur ".". Un objet est une representation dynamique de la classe. Tous les objets d'une meme classe auront les memes possibilites.
Heritage et Polymorphisme:
L'heritage permet de definir une nouvelle classe a partir d'une classe de base. On parle alors de sous classe, ou de classe derivee. Cela permet de hierarchiser et de creer des modeles entre les classes.
Les acces aux membres de la classe de base, par la classe derivee, depand du statut des membres dans la classe de base:
______________ ________________________ _____________________
Statut dans la Acces aux membres de la Acces aux membres de
classe de base classe de base par un la classe de base par
utilisateur de la classe une classe derivee
______________ ________________________ _____________________
public oui oui
private non non
L'heritage entre les 2 classes est implemente par la declaration de la classe Implements ClasseParente - a mettre au debut de la sous classe.
Dessin.cls Carre.cls
Public Couleur As Long Implements Dessin
Public Sub Tracer (ByVal X As Long,_ Private Sub Dessin_Tracer(By Val X ...
Byval Y As Long)
End Sub EndSub
Le lancement des constructeurs (Sub Initialize) se fait du sommet vers le bas de la pyramide d'heritage. Et les destructeur (Sub Terminate) du bas vers le haut. Pour ajouter une propriete a la classe on utilise Property Let ou Property Get
devise.cls prog
Dim strDevise As String Private withevents Madevise _
Dim Taux As Single As Devise ' instanciation
Private Sub cmdButton1_click
Private Sub Class_Initialize() Set Madevise = NewDevise
strDevise = "euro" Set Madevise = Nothing
Taux = 1 EndSub
End Sub Private Sub Madevise_DeviseChange()
Public event DeviseChange() Dim TauxDev As Single
Public Property Let NomDevise(Nom As String) TauxDev = input("taux","saisie")
strDevise = Nom Madevise.taux = tauxdev
RaiseEvent DeviseChange() EndSub
End Property
Private Sub Class_Terminate()
MsgBox "Devise" & strDevise & " effacee"
EndSub
Une Classe peut etre instanciee de plusieurs manieres:
- Private: utilisable uniquement dans le composant lui meme.
- PublicNotCreatable: possibilite d'utiliser les objets crees par le composant
- SingleUse: permet de creer des nouvelle instances du composant par la classe
- GlobalSingleUse: permet d'utiliser les methodes comme de simple fonctions
- MultiUse: permet de creer une infinite de nouvelle instances du composant
- GlobalMultiUse: permet d'utiliser les methodes comme de simple fonctions
1.11. Collections
Une collection permet de regrouper un ensemble d'elements connexes. (collections Forms, Controls, ...)
For Each Control In Form1.Controls Form1.Controls("Txt15").BackColor
If TypeOf Control Is TextBox Then Form1.Controls!Txt15.BackColor
Control.BackColor = vbGreen Form1.Controls(1).BackColor
end If
Next
Creation d'une nouvelle collection:
Private Employes As New Collection
Count 'Nombre de membres d'une collection
Add 'Ajoute un membre a la collection
Item 'Fait reference a un membre d'une collection
Remove 'Supprime un membre d'une collection
1.12. exceptions
On Error Resume 0 'L'execution reprend a partir de l'instruction en erreur
On Error Resume Next 'L'execution reprend apres l'instruction en erreur
On Error Resume lbl 'L'execution reprend a l'etiquette lbl
On Error GoTo lbl 'L'execution reprend a l'etiquette lbl puis s'arrete
Sub MaProcedure ()
On Error GoTo Erreur
Exit Sub
Erreur:
Select Case Err ...
End Sub
Vous pouvez évidemment créer vos propres exceptions pour prévenir des erreurs par exemple dans l'utilisation des composants que vous distribuez.
Error
règles de nommage des variables
Les variables sont préfixés suivant leur portée et leur type.
Les variables déclarées dans un module m_ Les variables publiques g_ Les variables de module de classe c_ Les variables déclarées comme paramètre sont précédées d'aucun préfixe. Ecrire les mots en entier pour être plus explicite. Pour les entiers, variables I, J ou N.
___________________________________________________________________________ | Animated button ani | ListView lvw | | Combo box cbo | MCI mci | | drop-down list box cbo | MDI child form mdi | | Check box chk | Menu mnu | | Command button cmd | MAPI message mpm | | Communications com | MS Flex grid msg | | Control ctl | MS Tab mst | | Data-bound grid dbg | OLE ole | | Directory list box dir | Picture pic | | Common dialog dlg | 3D Panel pnl | | Drive list box drv | ProgressBar prg | | File list box fil | Report rpt | | Frame fra | Shape shp | | Form frm | Slider sld | | Grid grd | Spin spn | | Horizontal scroll bar hsb | StatusBar sta | | ImageList ils | TabStrip tab | | Image img | Toolbar tlb | | Key status key | Timer tmr | | Label lbl | TreeView trw | | Line lin | Text box txt | | List box lst | Vertical scroll bar vsb | |_____________________________________|_____________________________________| | Container con | Parameter prm | | Database db | QueryDef qry | | DBEngine dbe | Recordset rec | | Document doc | Relation rel | | Field fld | TableDef tdf | | Index idx | Workspace wsp | |_____________________________________|_____________________________________|
ex: m_strMaChaine, cmdMaCommande, objMonObjet
26 millisecondes