|
|
|
|
|
|
|
|
- Présentation
- Manipuler les membres d'un objet
- Présentation
- Appeler un membre appartenant à un objet différent de l'objet en cours
- Appeler un membre de l'objet en cours
- Appeler un membre d'une classe ancêtre qui a été redéfinie
- Appeler un membre de classe générale
- Remarque
- Manipuler les méthodes d'un objet
- Présentation
- Appeler une méthode appartenant à un objet différent de l'objet en cours
- Appeler une méthode de l'objet en cours
- Appeler une méthode d'une classe ancêtre qui a été redéfinie
- Appeler une méthode de classe générale
- Exemple
- Remarque
- Affectation des objets
- Règles d'affectation
- Détails et exemples
- Instances de classes et tableaux
Pour accéder à une classe, il faut déclarer l'objet comme étant de la classe à manipuler, on parle d' instanciation d'un objet. Une instance est un objet qui appartient à une classe donnée. Remarque : Pour récupérer l'instance de l'objet en cours dans les méthodes de la classe, utilisez le mot-clé objet ou le mot-clé this. Cette page d'aide présente :
Manipuler les membres d'un objet Présentation Un membre d'un objet est une donnée associée à l'objet. Un objet possède nécessairement tous les membres décrits dans la classe. Un membre est également appelé propriété de l'objet. Les membres d'un objet correspondent à tous les membres définis pour la classe d'origine de l'objet. Rappel : un membre est déclaré dans la classe. Appeler un membre appartenant à un objet différent de l'objet en cours Pour appeler un membre appartenant à un objet différent de l'objet en cours, la syntaxe à utiliser est : <Nom Objet> . <Nom Membre> <Nom Objet> : <Nom Membre> Le membre est recherché parmi les membres de la classe de l'objet. Si le membre n'est pas trouvé, il est recherché parmi les membres des classes ancêtres de la classe de l'objet. Appeler un membre de l'objet en cours Pour appeler un membre de l'objet en cours, deux syntaxes sont disponibles : - Syntaxe simplifiée, disponible uniquement si vous activez l'option "Classes : préfixes ":" et "::" d'accès aux membres et aux méthodes facultatifs" (cette option est activée par défaut sur les nouveaux projets) :
- Syntaxe complète (toujours disponible) :
Appeler un membre d'une classe ancêtre qui a été redéfinie Pour appeler un membre appartenant à une classe ancêtre qui a été redéfinie, la syntaxe à utiliser est : <Nom Objet> . <Nom de la classe> . <Nom Membre> <Nom Objet> : <Nom de la classe> :: <Nom Membre> Appeler un membre de classe générale Pour appeler un membre appartenant à une classe générale, la syntaxe à utiliser est : <Nom de la classe> . <Nom Membre> <Nom de la classe> :: <Nom Membre> Remarque Il est possible d'enchaîner les accès aux membres. Par exemple : // Enchaînements de membres
MonObjet.Membre1[1]:Membre2:Membre3 Manipuler les méthodes d'un objet Présentation Les méthodes d'un objet sont des fonctionnalités associées à l'objet. Un objet possède nécessairement toutes les méthodes décrites dans la classe. Ces méthodes peuvent être appelées de différentes façons selon le lieu de l'appel. Appeler une méthode appartenant à un objet différent de l'objet en cours Pour appeler une méthode appartenant à un objet différent de l'objet en cours, la syntaxe à utiliser est : <Nom Objet> . <Nom Méthode> ([<Paramètres>]) <Nom Objet> : <Nom Méthode> ([<Paramètres>]) La méthode est recherchée parmi les méthodes de la classe de l'objet. Si la méthode n'est pas trouvée, elle est recherchée parmi les méthodes des classes ancêtres de la classe de l'objet. Appeler une méthode de l'objet en cours Pour appeler une méthode appartenant à l'objet en cours, la syntaxe à utiliser est : . <Nom Méthode> ([<Paramètres>]) Remarque : Par compatibilité avec les versions précédentes, il est possible d'utiliser la syntaxe ":<Nom méthode>([<Paramètres>])". Pour utiliser cette syntaxe, décochez l'option "Classes : préfixes ":" et "::" d'accès aux membres et aux méthodes facultatifs". Appeler une méthode d'une classe ancêtre qui a été redéfinie Pour appeler une méthode d'une classe ancêtre qui a été redéfinie, la syntaxe à utiliser est : <Nom Objet> . <Nom Classe> . <Nom Méthode> ([<Paramètres>]) <Nom Objet> : <Nom Classe> :: <Nom Méthode> ([<Paramètres>]) Appeler une méthode de classe générale Pour appeler une méthode d'une classe générale, la syntaxe à utiliser est : <Nom Classe> . <Nom Méthode> ([<Paramètres>]) <Nom Classe> :: <Nom Méthode> ([<Paramètres>]) Exemple FichierS est un CFichier
FichierD est un CFichier
ch1,ch2 sont des chaînes
// Appel de la méthode de sélection d'un fichier
FichierS.SélectionFichier()
FichierD.SélectionFichier()
// Appel de la méthode de vérification de l'espace disponible
SI FichierS.EspaceRestant(FichierD.Repertoire[[1]]) ALORS
ch1 = FichierS:Repertoire + "\" + FichierS:Nom + "." + FichierS:Extension
ch2 = FichierD:Repertoire + "\" + FichierD:Nom + "." + FichierD:Extension
fCopieFichier(ch1, ch2)
SINON
Erreur("Espace insuffisant")
FIN Remarque Il est possible d'enchaîner les appels de méthodes. Par exemple : // Enchaînements d'accès .NET
ObjetNET.Méthode1().Membre2[n].Méthode3()
// Méthode qui alloue et renvoie une classe enchaînée avec un appel
ObjetClasse.AlloueOpérateur().EffectueOpération() Règles d'affectation Les règles d'affectation entre des objets et entre des objets dynamiques sont les suivantes : - Opérateur = : Copie ou prise de référence
| | | | Opérateur = | | Objet | Objet dynamique | | Objet | Copie | Copie | | Objet dynamique | Prise de référence | Prise de référence |
- Opérateur <= : Copie
| | | | Opérateur <= | | Objet | Objet dynamique | | Objet | Copie | Copie | | Objet dynamique | Copie | Copie |
Note : Pour les membres déclarés comme "XXX dynamique", l'opérateur <= fait une copie de la référence, on a donc le même objet après l'affectation. - Opérateur <- : Prise de référence
| | | | Opérateur <- | | Objet | Objet dynamique | | Objet | Prise de référence | Prise de référence | | Objet dynamique | Prise de référence | Prise de référence |
Détails et exemples - Affectation entre deux objets :
O1, O2 sont des Classe
// Opérateur = fait une copie de membre
O1 = O2
// Opérateur - L'opérateur = et l'opérateur <= permettent de faire une copie de membres. Dans ce cas, tous les membres sont recopiés dans l'instance O1.
- Cas particulier des tableaux : Seuls les tableaux locaux sont recopiés. Les tableaux non locaux utilisent tous la même instance. Cette remarque ne concerne pas les tableaux associatifs.
- L'opérateur <- permet de prendre une référence sur l'objet passé en opérande.
- Affectation entre deux objets dynamiques :
pO1 est une Classe dynamique
pO2 est une Classe dynamique
// Opérateur = fait une prise de référence
pO1 = pO2
// Opérateur - L'opérateur = et l'opérateur <- permettent de faire une prise de référence. Dans ce cas, la variable dynamique pO1 utilise l'objet pO2.
- L'opérateur <= permet de faire une copie de membres. Dans ce cas, tous les membres sont recopiés dans l'instance pO1.
- Pour permettre la copie avec l'opérateur <= , les variables dynamiques p01 et p02 doivent être allouées, et déclarées de même type.
- Affectation entre deux objets (dynamique et non dynamique) :
O1 est une Classe
pO1 est une Classe dynamique
// Opérateur = permettant de faire une prise de référence
// La variable dynamique pO1 utilise l'objet O1
pO1 = O1
// Opérateur = permettant de faire une copie de membres
// Tous les membres sont recopiés dans l'instance O1
O1 = pO1 - Selon l'ordre des opérandes, l'opérateur = permet de réaliser une copie de membres ou de faire une prise de référence.
- Pour simplifier ces syntaxes, il est conseillé d'utiliser les opérateurs <= et <- :
- l'opérateur <= permet de faire dans tous les cas une copie de membres. Pour les membres déclarés comme "XXX dynamique", l'opérateur <= fait une copie de la référence, on a donc le même objet après l'affectation.
- l'opérateur <- permet de faire dans tous les cas une prise de référence.
O1 est une Classe
pO1 est une Classe dynamique
// Opérateur <- : prise de référence
// La variable dynamique pO1 pointe sur l'objet O1
p01 <- O1
// Opérateur <= : copie des membres
// Tous les membres sont recopiés dans l'instance pO1
pO1 <= O1
Instances de classes et tableaux Lors de copies d'instances de classes, tous les membres de la classe sont recopiés dans la nouvelle instance, sauf les tableaux. Ainsi, si la valeur d'un membre de type tableau est modifiée, cette valeur est modifiée dans toutes les instances. Pour obtenir des tableaux indépendants dans toutes les instances de classes, il est nécessaire de déclarer un tableau local de la manière suivante : ClasseSystème est une Classe
tTableauDéfaut est un tableau local de 1 entier
FIN Les tableaux associatifs, les piles et les files ne peuvent pas être déclarés en local. Lors des copies d'instances, les tableaux associatifs, files et piles sont automatiquement recopiés.
Documentation également disponible pour…
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|