Les opérateurs

Ce programme présente la déclaration et l'usage des méthodes pour des types.

Le fichier source est ${UPS_HOME}/upssdk/demo/${UPS_LANGUAGE}/operateur.upl.

Mode compilé

Commande de compilation


upscmp Source=operateur.upl

Commande d'exécution


operateur

Mode interprété


upssng Source=operateur.upl

Fichier source


Source Composant "Exemple d'emploi des opérateurs" Version 4.0.0;



Type TypeA

/********/


   A : Entier;

   B : Caractere;

   Constructeur();

   Operateur =(C : Nul Ou TypeA);

   Operateur ==(C : Nul Ou TypeA) Retourner Nul Ou Booleen;

   Operateur !=(C : Nul Ou TypeA) Retourner Nul Ou Booleen;

   Operateur +(C : Entier) Retourner TypeA;

   Operateur -(C : Entier) Retourner TypeA;

   Operateur ++(P : Booleen) Retourner TypeA;

   Operateur --(P : Booleen) Retourner TypeA;

   Operateur [](I : Nul Ou Entier) Retourner Caractere;

   Operateur ()() Retourner Caractere;

   Operateur Comme(C : Caractere) Retourner Nul Ou Booleen;

Fin Type



Operateur TypeA.=(C : Nul Ou TypeA)

/*********************************/

Debut

A=C.A;

B=C.B;

Fin Operateur



Operateur TypeA.==(C : Nul Ou TypeA) Retourner Nul Ou Booleen

/***********************************************************/

Debut

Retourner A==C.A;

Fin Operateur



Operateur TypeA.!=(C : Nul Ou TypeA) Retourner Nul Ou Booleen

/***********************************************************/

Debut

Retourner A!=C.A;

Fin Operateur



Operateur TypeA.+(C : Nul Ou Entier) Retourner TypeA

/**************************************************/

Variable

   R : TypeA;

Debut

R.A=A+C;

R.B=B;

Retourner R;

Fin Operateur



Operateur TypeA.-(C : Nul Ou Entier) Retourner TypeA

/**************************************************/

Variable

   R : TypeA;

Debut

R.A=A-C;

R.B=B;

Retourner R;

Fin Operateur



Operateur TypeA.++(P : Booleen) Retourner TypeA

/*********************************************/

Variable

   R:TypeA;

Debut

Si P Alors

   R.A=++A;

Sinon

   R.A=A++;

Fin Si

R.B=B;

Retourner R;

Fin Operateur



Operateur TypeA.--(P : Booleen) Retourner TypeA

/*********************************************/

Variable

   R : TypeA;

Debut

Si P Alors

   R.A=--A;

Sinon

   R.A=A--;

Fin Si

R.B=B;

Retourner R;

Fin Operateur



Operateur TypeA.[](I : Nul Ou Entier) Retourner Caractere

/*******************************************************/

Debut

Retourner B.Milieu(I,1);

Fin Operateur



Operateur TypeA.()() Retourner Caractere

/**************************************/

Debut

Retourner B;

Fin Operateur



Operateur TypeA.Comme(C : Caractere) Retourner Nul Ou Booleen

/***********************************************************/

Debut

Retourner B Comme C;

Fin Operateur



Principal

/*******/

Variable

/******/

   VA : TypeA;

   VB : TypeA;



Debut

VA.A=1;

VA.B="coucou";

VB=VA+2;

VB=VA-1;

VB+=2;

VB-=1;

Ecran.Ecrire(VB.A);

Ecran.Ecrire(VB.B);

Si VA==VB Alors

   Ecran.Ecrire("VA==VB");

Fin Si

Si VA!=VB Alors

   Ecran.Ecrire("VA!=VB");


Fin Si

Ecran.Ecrire("\n");



VB=VA++;

Ecran.Ecrire(VB.A);

Ecran.Ecrire(VB.B);

VB=++VA;

Ecran.Ecrire(VB.A);

Ecran.Ecrire(VB.B);

VB=VA--;

Ecran.Ecrire(VB.A);

Ecran.Ecrire(VB.B);

VB=--VA;

Ecran.Ecrire(VB.A);

Ecran.Ecrire(VB.B);

Ecran.Ecrire(VA[1]);

Ecran.Ecrire(VA());

Ecran.Ecrire("\n");



Si "ABCD" Comme "A*" Alors

   Ecran.Ecrire("ABCD Comme A*");

Sinon

   Ecran.Ecrire("Non ABCD Comme A*");

Fin Si

Si "ABCD" Comme "A?CD" Alors

   Ecran.Ecrire("ABCD Comme A?CD");

Sinon

   Ecran.Ecrire("Non ABCD Comme A?CD");

Fin Si

Si "ABCD" Comme "AB[ZCY]D" Alors

   Ecran.Ecrire("ABCD Comme AB[ZCY]D");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB[ZCY]D");

Fin Si

Si "ABCD" Comme "AB[A-D]D" Alors

   Ecran.Ecrire("ABCD Comme AB[A-D]D");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB[A-D]D");

Fin Si
Si "ABCD" Comme "AB[ZXY]D" Alors

   Ecran.Ecrire("ABCD Comme AB[ZXY]D");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB[ZXY]D");

Fin Si

Si "ABCD" Comme "AB![ZCY]D" Alors

   Ecran.Ecrire("ABCD Comme AB![ZCY]D");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB![ZCY]D");

Fin Si

Si "ABCD" Comme "AB![A-D]D" Alors

   Ecran.Ecrire("ABCD Comme AB![A-D]D");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB![A-D]D");

Fin Si

Si "ABCD" Comme "AB![ZXY]D" Alors

   Ecran.Ecrire("ABCD Comme AB![ZXY]D");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB![ZXY]D");

Fin Si

Si VA Comme "cou*" Alors

   Ecran.Ecrire("VA Comme cou*");

Sinon

   Ecran.Ecrire("Non VA Comme cou*");

Fin Si

Si "ABCD" Comme "AB*|XY*" Alors

   Ecran.Ecrire("ABCD Comme AB*|XY*");

Sinon

   Ecran.Ecrire("Non ABCD Comme AB*|XY*");

Fin Si

Si "ABCD" Comme "XY*|AB*" Alors

   Ecran.Ecrire("ABCD Comme XY*|AB*");

Sinon

   Ecran.Ecrire("Non ABCD Comme XY*|AB*");

Fin Si

Fin Principal

Résultat de l'exécution

1 coucou VA==VB 1 coucou 3 coucou 3 coucou 1 coucou o coucou ABCD Comme A* ABCD Comme A?CD ABCD Comme AB[ZCY]D ABCD Comme AB[A-D]D Non ABCD Comme AB[ZXY]D Non ABCD Comme AB![ZCY]D Non ABCD Comme AB![A-D]D ABCD Comme AB![ZXY]D VA Comme cou* ABCD Comme AB*|XY* ABCD Comme XY*|AB*