GTAOnline.net

San Andreas Multiplayer (sa:mp) => Scripting SA-MP [Pawn center] => Tutoriels et références SA:MP => Discussion démarrée par: S!m le 30 Décembre 2008, 20:45:56

Titre: Les différents opérateurs [niveau: tous]
Posté par: S!m le 30 Décembre 2008, 20:45:56
Salut à tous,

alors je vais expliqué rapidement ce que j'ai compris aux différents opérateurs présents en pawn,
si vous vous y connaissez bien, je vous prie de bien ajouter vos connaissances...



L'opérateur '!':

Le point d'exclamation (appelé NOT) permet d'inverser les bits d'une variable:

!true = false
on peut en déduire que
!false = true

Donc, dans une variable on obtient ceci:

EXEMPLE:
!010111000011101011
qui est équivalent à:
101000111100010100
(tous les 1 deviennent des 0 et vice versa)
ainsi, utilisé dans un if(....) il permet de vérifier si une expression est fausse et non vrai ( if(!...) )



Les strings compressés :

Le point d'exclamation peut également servir à la création de "packed string", soit des string compressés,
Il est évident que ceci permet de sauver une grande quantité de mémoire, par contre la plupart des fonction en pawn ne supportent pas les string compressés.
Ainsi, il est plutôt rares qu'ils soient utilisés.
vous pouvez créer des string compressés à la base dès leur création:
Code: (pawn) [Sélectionner]
new string[12] = "Salut à tous";//12 cell 48 bytes
new string[12 char] = !"Salut à tous";//3 cell 12 bytes
Comme on peut le voir d'après les commentaires (code original de Y_Less), le string compressé est 4 fois plus petit.
Il existe également deux fonctions dans le string.inc qui permettent de compresser/décompresser des string, il s'agit de strpack et strunpack

strpack(dest[],const source[],maxlenght)
 - dest: Le string de destination (sous la forme var[nb char]
 - source: le string d'où provient les données
 - maxlenght: la longueur maximale de la chaîne à copier (paramètre optionnel)

strunpack(dest[],const source[],maxlenght)
 - dest: Le string de destination (string décompressé)
 - source: le string d'où proviennent les données compressées
 - maxlenght: la longueur maximale de la chaîne de caractère à décompresser



Le caractère '=' :

Seul, le signe = change la valeur de la variable de gauche pour la valeur de celle de droite(dans le sens <<------), souvent employé comme ceci:
Code: (pawn) [Sélectionner]
time = GetTickCount();Il en va ainsi pour toutes les variables,
par contre il faut l'employé avec une certaine précaution, seules les variables(j'entend ainsi également les valeurs retournés par les fonctions) de même type peuvent être impliqués dans les '='

EXEMPLE:
Code: (pawn) [Sélectionner]
new Float:x,nb,string[128],string2[64],Float:y,maVar;

//les expressions suivantes sont fausses:
x=nb;//type de variable différent
string = string2//longueur de string différent
maVar = y;//type différent
y=string;//type différent

//Les expressions suivantes sont vraies:
x=maVar;//deux entiers
x=y;//deux float
format(string,sizeof(string),"%s",string2);//ici on change les caractère de string pour devenir ceux de string2, du moins en partie (car string plus long que string2)
nb = string[34];//comme l'on prend seulement le 34e caractère, il s'agit d'un nombre entier tout comme nb, donc aucun problème ici
maVar=floatround(y);//on arrondi le nombre à virgule, donc on obtient un entier



Le caractère '==' :

Il s'agit d'un opérateur logique d'égalité, employé pour les conditions, la valeur retournée est true si l'expression de droite à la même valeur que l'expression de gauche, false dans le cas contraire.
Note : On ne peut comparé deux string de cette façon, la façon de faire est dans l'exemple suivant
L'utilisation de cet opérateur se fait comme suit:
Code: (pawn) [Sélectionner]
new int1 = 3;
new int2 = 45;
new int3 = 3;
if(int1 == 3)//on compare avec une valeur constante
{
//le code suivant sera exécuté
}
if(int2 == 34)
{
//le code suivant ne sera pas exécuté (int2 n'égale pas 45)
}
if(int1 == int3)//on compare les variables entre eux
{
//le code suivant sera exécuté
}
if(int2 == int3)
{
//le code suivant ne sera pas exécuté
}
if(GetPlayerVehicleID == int2)//ici on compare la valeur retourné par la fonction et la variable
{
//le code suivant sera peut-être exécuté, dépendant de la valeur retournée par la fonction
}
new Float:float1 = 34.3453;
new Float:float2 = 456.5461;
new Float:float3 = 34.3453;
new Float:x,Float:y,Float:z;
GetPlayerPos(23,x,y,z);//on récupère la position du joueur numéro 23
if(float1 == float3)//on compare les deux variable
{
//ce code sera exécuté
}
if(float2 == 345.231)//compare une variable à virgule avec un nombre à virgule constant
{
//ce code ne sera pas exécuté
}
if(float2 == y)/on compare le y du GetPlayerPos avec la float2
{
//ce code peut être exécuté selon la position du joueur 23
}



L'opérateur logique '&':

Si vous ne savez pas ce qu'est un bit, je vous suggère de sauter cette partie.
Seul '&' permet la comparaison de bits (il s'agit en quelque sorte d'un ET),
si le bit que l'on vérifie est à 1, la valeur retournée est vraie,
par exemple si l'on veut extraire le 4e bit d'une variable quelconque:
Code: (pawn) [Sélectionner]
new variable = 857;
if(variable & 16)..//si la variable à le 4e bit à 1...

Il est possible de créer une fonction afin de déterminer si un nombre est pair ou impair grâce à cet opérateur:
Code: (pawn) [Sélectionner]
stock IsImpair(Number)
{
  return number & 1;
}

Encore, il est possible d'améliorer cette fonction à l'aide de DEFINE (voir plus bas)

Code: (pawn) [Sélectionner]
#define IsImpair(%0) %0 & 1



L'opérateur logique '&&':

Le symbole && il constitue l'opérateur de logique "ET", il permet d'ajouter une condition à un if , d'une certaine façon

EXEMPLE:
Code: (pawn) [Sélectionner]
if(IsPlayerConnected(playerid) && IsPlayerInAnyVehicle(playerid))....//ce code ne s'exécutera que si le joueur est connecté ET dans un véhicule



Les opérateurs '<', '>', '<='et '>=' :

Ils permettent de vérifier quelle valeur de celle de gauche ou de droite est la plus grande.
Ils peuvent également être accompagnés de l'opérateur '=' afin d'accepter également la possibilité d'une égalité..
Bref,
Code: (pawn) [Sélectionner]
new local1 = 2,
local2 = 3,
local3 = 2;
if(local1 < local2)...//le code sera exécuté car local1 est plus petit que local2
if(local1 < local3)...//ne sera pas exécuté car local1 n'est pas plus petit que local2
if(local1 <= local3)....//sera exécuté car local1 est égale à local3
if(local2 > local3)....//sera exécuté car local2 est plus grand que local3



Les opérateurs '<<'et '>>' :

Ces opérateurs permettent de faire des opération bits à bits, << permet de décaler des bits vers la gauche (division par deux) tandis que '>>' décale plutôt les bits vers la droite, une multiplication par 2
NB : Dans les décalages de bits, les bits qui "sortent" par la gauche ou la droite sont perdus. Ainsi (13>>2)<<2 ne donnera pas 13 mais 12

Code: (pawn) [Sélectionner]
if ((a << 30) >>> 31)



L'opérateur '|' :

Seul '|' est un OU bit à bit

EXEMPLE:
Code: (pawn) [Sélectionner]
0|0 = 0
1|0 = 1
0|1 = 1
1|1 = 1



L'opérateur '||' :

Il correspond à l'opérateur logique "ou" dans toute condition
Dès qu'une des valeurs est vraie, l'expression retourne vrai (voir exemple)
EXEMPLE:
Code: (pawn) [Sélectionner]
if(IsPlayerInAnyVehicle(playerid) || GetPlayerState(playerid) != PLAYER_STATE_ONFOOT)....//le joueur est dans un véhicule ou encore il n'est pas à pied



Le mot clé 'if' :

Il permet de faire un test de logique, les parenthèses le suivant continent une expression qui retourne une valeur, si cette expression est vraie, le code suivant le if (entre les {} la plupart du temps) sera exécuté, dans le cas contraire il sera sauté
EXEMPLE:
Code: (pawn) [Sélectionner]
if(GetPlayerState(playerid) == PLAYER_STATE_DRIVER)//si le joueur conduit un véhicule
{
 AddVehicleComponent(GetPlayerVehicleID(playerid),1010);//on lui donne de la nitro
}



Le mot clé 'else' :

Il doit être utilisé de concert avec le mot clé if et le code le suivant sera appelé si et seulement si le if est faux et le code suivant le if n'est pas exécuté.

EXEMPLE:
Code: (pawn) [Sélectionner]
if(30 == 10)//expression évidemment fausse
{
 AddVehicleComponent(GetPlayerVehicleID(playerid),1010);//on donne de la nitro
}
else
{
 SendClientMessage(playerid,COLOR_RED,"Tu ne peut avoir de la nitro, car tu a été méchant ^^");
}

Le else et le if peuvent être combiné afin d'obtenir de multiples possibilités selon la valeur de différents paramètres, ce qui donne le mot clé else if

EXEMPLE:
Code: (pawn) [Sélectionner]
if(GetPlayerState(playerid) == PLAYER_STATE_DRIVER)//si le joueur conduit un véhicule
{
 AddVehicleComponent(GetPlayerVehicleID(playerid),1010);//on lui donne de la nitro
}
else if(IsOn == 2)
{
 SendClientMessage(playerid,COLOR_RED,"Tu ne peut avoir de la nitro, car tu a été méchant ^^");
}
else if(IsOn == 3)
{
 SendClientMessage(playerid,COLOR_RED,"Tu ne peut avoir de la nitro, car tu n'as pas mangé ton gateau ^^");
}
else if(IsOn == 4)
{
 SendClientMessage(playerid,COLOR_RED,"Tu ne peut avoir de la nitro, car tu n'as pas nourrit le chien ^^");
}
else
{
 SendClientMessage(playerid,COLOR_RED,"Tu ne peut avoir de la nitro, car tu n,est pas en véhicule!");
}



Les FORWARD :

le forward permet d'indiquer au compiler qu'une fonction existe avant qu'il ne la rencontre.
Si vous obtenez le warning "function used before definition, forcing reparse",
Placez un forward de votre fonction au haut de votre script où déplacez votre fonction afin de la placer avant son usage.
Notez bien que les fonction public ont obligatoirement besoin d'un forward



Les NEW :

l'expression new indique au compiler que le mot suivant est une variable, cette variable peut être un texte, un nombre à virgule, un simple entier ou encore une valeur booléenne (vrai ou faux)
Par contre, afin de ne pas créer un simple entier, il faut placer un "tag" devant le nom de la variable (voir exemple)
EXEMPLES:
Code: (pawn) [Sélectionner]
new entier;//un entier
new Float:NbVirgules;//un nombre a virgule (float en anglais pour floating point (point flottant, bref qui bouge^^))
new MyText[128];//un string, array, peut contenir du texte comme la suivante
new MyText2[] = "salut à tous!!!";//lorsque l'on place déjà un texte dans une variable, aucun besoin d'assigner une taille à la variable
new bool:MyBool;//on crée une variable booléenne (vrai ou faux)
new MyArray[32] = {-1,0,2,3,5,6,74,45...};//un array, contient différentes valeurs ayant toutes une signification quelconque;

Dans la même catégorie l'on retrouve également les static qui sont en quelque sorte comme les new,
mais à l'exception qu'ils ne sont accessible que dans la section du script les contenant,
par exemple un static dans un include ne peut être utilisé dans le script, alors qu'un new le pourrait

Une notion importante en lien avec les NEW est bien entendu l'intialisation, c'est à dire l'assignement d'une valeur à la variable lors de sa création.
Il est possible d'assigner la valeur que l'on désire (en restant dans le bon type de variable) à la variable créée
EXEMPLE:
Code: (pawn) [Sélectionner]
new playerid = 9;
new entier = playerid;
playerid = 13;
new entier2 = playerid;
entier = entier2;



Les '++' :

Cet expression permet d'ajouter 1 à une valeur, généralement placé après une variable afin d'en augmenter la valeur de 1.
Il est à noter que ceci modifie la valeur de la variable en question.

EXEMPLES:
Code: (pawn) [Sélectionner]
new entier = 6;//un entier
printf("%d",entier);//écrit 6
entier++;
printf("%d",entier);//écrit 7 (6+1)



Les '--' :

Cet expression permet d'enlever 1 à une valeur, généralement placé après une variable afin d'en réduire la valeur de 1.
Il est à noter que ceci modifie la valeur de la variable en question.

EXEMPLES:
Code: (pawn) [Sélectionner]
new entier = 6;//un entier
printf("%d",entier);//écrit 6
entier--;
printf("%d",entier);//écrit 5 (6-1)



Les '+=' :

Cet expression permet d'ajouter une valeur à une valeur,
placé après une variable afin d'en augmenter la valeur du nombre suivant cet opérateur. (voir exemple)
Il est à noter que ceci modifie la valeur de la variable en question.

EXEMPLES:
Code: (pawn) [Sélectionner]
new entier = 6;//un entier
printf("%d",entier);//écrit 6
entier+= 10;
printf("%d",entier);//écrit 16 (6+10)



Les '-=' :

Cet expression permet d'enlever une valeur à une valeur,
généralement placé après une variable afin d'en réduire la valeur du nombre suivant cet opérateur (-=).(voir exemple)
Il est à noter que ceci modifie la valeur de la variable en question.

EXEMPLES:
Code: (pawn) [Sélectionner]
new entier = 58;//un entier
printf("%d",entier);//écrit 58
entier-=25;
printf("%d",entier);//écrit 33 (58-25)



Les '*=' :

Cet expression permet de multiplier la valeur de gauche par la valeur de droite.
Il est à noter que ceci modifie la valeur de la variable en question.

EXEMPLES:
Code: (pawn) [Sélectionner]
new entier = 6;//un entier
printf("%d",entier);//écrit 6
entier*=5;
printf("%d",entier);//écrit 30 (6*5)



Les STOCK :

un stock sert à déclaré une fonction ou une variable qui peut ne pas être utilisée, ce type d'initialisation est très utile dans les includes.
L'avantage du stock sur le #pragma unused ... est que la fonction/variable déclaré en stock ne sera pas compilée si inutilisée, contrairement au #pragma qui ne fait qu'éliminer l'avertissement
ainsi si je déclare la variable mais ne m'en sert pas, il n'y a aucun problème:
Code: (pawn) [Sélectionner]
new stock myNumber = 5;
new ILike = 15;
printf("%d",ILike);
Dans ce code myNumber ne sera pas compiler car il n'est pas utilisé
Par contre, dans le code suivant, elle le sera:
Code: (pawn) [Sélectionner]
new stock myNumber = 5;
printf("%d",myNumber);



Les LOOPS :

En tout premier lieu, vous devez savoir qu'il existe trois différents type de loops que l'on rencontre fréquemment sur les codes en PAWN pour SA-MP:


Les DO-WHILE :

Cette boucle suit la structure suivante:
Code: (pawn) [Sélectionner]
do
{
 ......//votre code
}
while(//une condition);
ainsi le code passera en premier par le do{....} et ce code sera exécuté, par la suite, si la condition est vraie, on refait le do{....} ainsi de suite jusqu'à ce que la condition ne soit plus vraie.


Les WHILE :

Cette boucle suit la structure suivante:
Code: (pawn) [Sélectionner]
while(//une condition)
{
.....
}
Ainsi, le code test en premier lieu la condition et si elle s'avère vraie, le code contenu entre les {} sera exécuté, un fois cela fait, on retourne au début et si la condition est vraie, on recommence le code, sinon, on passe par dessus et continue la suite du code...
Ce genre de boucle est souvent utilisé avec la déclaration préalable d'une variable qui sera modifié dans le while d'une façon où d'une autre...
Par exemple, pour arrêter un timer, il serait possible, je dit bien possible de faire le code suivant:
Code: (pawn) [Sélectionner]
new IsOk;
while(IsOk == 0)
{
 IsOk = KillTimer(timerquelconque);
}
bien entendu, le résultat de cette loop est quelque peut étrange (je ne suis pas sûr d'où vient la plupart des problèmes de timers qui ne se stoppent pas, mais s'il s'agit de la fonction qui ne fonctionne pas correctement, ceci devrait corrigé le problème.
P.S. il est cité dans le wiki que plusieurs fonction ne retournent aucune valeurs spécifique, or dans la plupart des cas une valeur est retourné, vrai si la fonction à réussi, faux dans le cas contraire

Les FOR :

Cette boucle suit la structure suivante:
Code: (pawn) [Sélectionner]
for(new i = 0; i<VALEUR; i++)
{
 .....
}
Donc, à voir la structure de cette loop, on voit aisément qu'une variable doit être déclaré, on pose ensuite une condition, et une variation de cette variable à chaque fois que le code est exécuté.
La loop précédante serait aussi équivalente à:
Code: (pawn) [Sélectionner]
new i;
while(i<VALEUR)
{
 ......
 i++;
}

Il est également possible d'ajouter certaines déclaration dans cette loop, par exemple une nouvelle variable et l'appel à une fonction afin d'obtenir une valeur:
Code: (pawn) [Sélectionner]
for(new i = 0,j = getMaxPlayers(); i<j; i++)
{
 ...
}



Les SWITCH :

En tout premier lieu, qu'es-ce qu'un switch?
Un switch est un opérateur logique un peu dans le genre du if/else if/... et sert à principalement à remplacer une longue série de if/else if
Il s'écrit de la façon suivante:
Code: (pawn) [Sélectionner]
switch(variable ou expression)
{
 case /*les/la valeur(s) pour lesquelles la même action sera exécutés/*:
 {
 ....
 }
 case/*d'autre(s) valeur(s) pour lesquelles on exécutera le même code*/:
 {
 ....
 }
 default:
 {
 //tous les cas qui ne sont pas énumérés plus haut
 }
}

Le principal avantage d'un switch, est la possibilité de regroupé différentes valeurs ensemble afin de simplifier l'écriture du code.
D'un autre côté, son principal défaut est l'impossibilité de placer comme valeur désirée une variable, il faut absolument y placer une constante, ici je parle des valeurs dans les case, la valeur dans le switch() peut bien évidemment être une variable.

Les CASE :

Cette expression est utilisé de concert avec les switch, il s'agit de l'expression qui indique au programme que les valeurs le suivant et devant les ':' sont les valeurs à rechercher
(EXEMPLE: voir code ci-dessus)

Les DEFAULT :

Cette expression est utilisé de concert avec les switch,
il peut être pris en compte comme un case, à la différence qu'il doit être à la fin et suivit d'aucune valeur.
Il s'agit du code qui sera appelé si aucune des autres valeurs n'a été appelée, de son nom, la valeur par défaut.
(EXEMPLE: voir code ci-dessus)



Les Directives de compilation:


Les '#define' :

Ces expressions peuvent avoir trois différentes utilités:

Éviter de compilé certaines partie de code que l'on ne désire pas, on en retrouve un exemple parfait dans le new.pwn que l'on retrouve dans le dossier pawno
EXEMPLE:
Code: (pawn) [Sélectionner]
#define USE_LANGUE_SYS

#if defined USE_LANG_SYS
 SendMsg(playerid........);
#else
 SendClientMessage(playerid.....);
#endif
Les autres expressions contenues dans cet exemples seront cités plus loin

Les define peuvent servir à définir des valeurs reprise à plein d'endroit, afin de pouvoir en changer la valeur aisément.
Il suffit que de penser à l'expression MAX_PLAYERS définie par a_samp.inc
EXEMPLE:
Code: (pawn) [Sélectionner]
#define NOMBRE_DE_KICK_AVANT_BAN 3

public OnPlayerDisconnect(playerid,reason)
{
 if(KickCount[playerid] == NOMBRE_DE_KICK_AVANT_BAN)Ban(playerid);
}

Et nous arrivons à l'utilité la moins utilisé: la création de simples fonctions.
Les defines peuvent prendres certains paramètres variables, il faut alors les représenter par %(nombre)
EXEMPLE:
Code: (pawn) [Sélectionner]
#define dcmd(%1,%2,%3) if ((strcmp((%3)[1], #%1, true, (%2)) == 0) && ((((%3)[(%2) + 1] == 0) && (dcmd_%1(playerid, "")))||(((%3)[(%2) + 1] == 32) && (dcmd_%1(playerid, (%3)[(%2) + 2]))))) return 1

Les '#if' :

sert à faire un test directement par le compiler, ainsi si certaines expressions sont vraies, défini, on peut ajouter ou non une partie de code
EXEMPLE:
Code: (pawn) [Sélectionner]
#define USE_POWER


#if defined USE_POWER
#include .....inc
#else
#error Could not load include
#endif

Les '#else' :

Si le premier test avec un #if était faut, ce qui suit sera pris en compte
(voir exemple au dessus)

Les '#endif' :

sert à fermer un #if , exactement comme un '}' avec un if normal
(voir exemple au dessus)

Pour une liste complète, mais en anglais:http://forum.sa-mp.co.uk/index.php/topic,248.0.html#post_directives (http://forum.sa-mp.co.uk/index.php/topic,248.0.html#post_directives)


REMERCIEMENTS:

Un énorme merci à Syg pour toutes ses précisions, ajouts et corrections
Merci à [viruz]rider_77 pour ses suggestions d'ajouts
Merci à Bayshore pour sa suggestion

Pour conclure,
j'espère bien vous avoir appris au moins 2 ou 3 trucs dans ce petit tuto,
merci de votre attention  ;)

++Sim++
Titre: Re : Les différents opérateurs
Posté par: » Lukubi™ le 31 Décembre 2008, 13:30:43
C'est très bien expliquer, je pense que sa va en aider plus d'un.

GG à toi Sim.

++

MisterT
Titre: Re : Les différents opérateurs
Posté par: Nikko™ le 31 Décembre 2008, 15:56:14
Super "Tuto" si je peux me permettre ^^

GG sim ;) cest tres bien expliquer.

++
nikko
Titre: Re : Les différents opérateurs
Posté par: spykerc8 le 31 Décembre 2008, 15:57:37
En effet.

D'ailleurs si tu veux en faire d'autres, tu peux :)

Pinned :D
Titre: Re : Les différents opérateurs
Posté par: R@f le 31 Décembre 2008, 17:51:26
Excellent tuto, GG à toi ;)

++
R@f
Titre: Re : Les différents opérateurs
Posté par: [viruz]rider_77 le 31 Décembre 2008, 18:20:40
Bon tuto :D
Je connais pas le pawn, mais doit bien avoir des boucles DO, WHILE et FOR :D
Pour la condition SWITCH, je sais pas si elle existe.

Donc si un de ces 4 éléments existent en Pawn, quelqu'un peut les rajouter :)
Titre: Re : Re : Les différents opérateurs
Posté par: S!m le 31 Décembre 2008, 18:55:40
Bon tuto :D
Je connais pas le pawn, mais doit bien avoir des boucles DO, WHILE et FOR :D
Pour la condition SWITCH, je sais pas si elle existe.

Donc si un de ces 4 éléments existent en Pawn, quelqu'un peut les rajouter :)

très bien je les ajoutes le plus rapidement possible

EDIT: fait et j'ai ajouté un peu de formatage pour rendre plus lisible...

++Sim++
Titre: Re : Les différents opérateurs
Posté par: Bayshore le 03 Janvier 2009, 18:27:23
Pas mal le tuto pour les débutants. ;)

Sinon l'opérateur ! peut aussi être utiliser pour packer des chaînes de caractères, afin qu'elles prennent moins de places en mémoires.
http://forum.sa-mp.com/index.php?topic=78026.msg507347#post_packed (http://forum.sa-mp.com/index.php?topic=78026.msg507347#post_packed)

Ce serait bien aussi de le traduire entièrement l'article pour ici, je le ferais si j'ai du temps...
Titre: Re : Les différents opérateurs
Posté par: S!m le 04 Janvier 2009, 16:08:40
Salut,

je ne crois pas que ce soit vraiment utile pour les scripteurs en général, toutefois, quand j'aurai du temps libre et une envie de l'ajouter, je le ferai,

merci de la suggestion

++Sim++
Titre: Re : Les différents opérateurs
Posté par: Syg le 06 Janvier 2009, 16:01:58
Très bon tuto.

Quelque petites précisions et remarques :

1) L'opérateur '!' est appelé NOT. Il faudrait aussi dire que !false=true et réciproquement.
2) Il serait bien de séparer les opérateurs '=' (opérateur d'affectation) et '==' (opérateur de comparaison) car ce sont deux opérateur différents.
3) Idem pour '&' (ET bit à bit) et '&&' (ET logique).
4) Avec '<' et '>', on peut ajouter les opérateurs '<=' et '>=' (dont un est d'ailleurs cité dans ton exemple).
5) Les opérateurs '<<' et '>>' n'ont rien à voir avec '<' et '>', il serait bien de les mettre à part.
6) L'opérateur '<<' est l'opérateur de décalage de bits vers la gauche (le décalage d'un bit vers la gauche équivaut à une multiplication par 2).
7) L'opérateur '>>' existe aussi et est l'opérateur de décalage de bits vers la droite (le décalage d'un bit vers la droite équivaut à une division par 2).
NB : Dans les décalages de bits, les bits qui "sortent" par la gauche ou la droite sont perdus. Ainsi (13>>2)<<2 ne donnera pas 13 mais 12
8 ) L'opérateur '|' n'est pas un opérateur d'addition, c'est un OU bit à bit (0|0=0, 0|1=1, 1|0=1 et 1|1=1)
9) Séparer '|' et '||'
10) if, else, while, ... ne sont pas des opérateurs mais des mots clés.
11) Il manque les opérateurs '++' (pré/post incrémentation), '--' (pré/post décrémentation), '+=', '-=', '*=', ...
12) Tous les termes commençant par # sont appelés "directives de compilation" (utilisées exclusivement par le compilateur).
13) Il vaut mieux initialiser la variable d'une boucle for : for (new i=0;.... NB : Par défaut PAWN initialise les variables à 0.
14) La ligne suivante est fausse :
for(new i,j; j = getMaxPlayers(); i<j; i++)Il ne peut y avoir que 2 ; dans un for.
La ligne correcte est
for(new i,j = getMaxPlayers(); i<j; i++)
++
Syg
Titre: Re : Les différents opérateurs
Posté par: S!m le 06 Janvier 2009, 16:09:44
Merci beaucoup Syg, je corrige le plus tôt possible :D :D
Titre: Re : Les différents opérateurs
Posté par: Kuroba le 06 Janvier 2009, 16:34:42
Joli Tuto, gg x)
Titre: Re : Les différents opérateurs
Posté par: S!m le 23 Janvier 2009, 03:33:25
Bonjour à tous, ou plutôt bonne nuit,

je viens vous annoncer une grande modification du premier post, les erreurs signalés par Syg ont été corrigées ainsi que la plus grande partie du post.

Une petite partie sur les string compressés à également été ajoutée

++Sim++
Titre: Re : Les différents opérateurs
Posté par: R@f le 23 Janvier 2009, 15:29:18
Excellent Sim, faudrait en faire un document pdf pour que les personnes souhaitant l'imprimer puissent l'avoir à coté de soi quand ils codent :) (Je peux le faire si tu veux ;) )

++
R@f
Titre: Re : Les différents opérateurs
Posté par: spykerc8 le 23 Janvier 2009, 16:48:49
Il y a une fonction imprimer sur le forum, elle sert à ca..
Titre: Re : Les différents opérateurs
Posté par: R@f le 23 Janvier 2009, 17:32:13
Oui mais ça imprime le fil de discutions en entier, moi je trouve aussi que le PDF est pratique quand on a pas accès à internet ^^

++
R@f
Titre: Re : Les différents opérateurs
Posté par: Syg le 26 Janvier 2009, 15:24:10
Sinon, copier le contenu du post, le coller dans Word (qui garde plus ou moins la mise en forme) et le tour en joué.

++
Syg
Titre: Re : Les différents opérateurs
Posté par: S!m le 27 Janvier 2009, 02:18:37
Salut,

j'ai tester et en copiant sur word, ça garde une mise en forme acceptable mais il fait 17 pages ;D

on pourra pas dire que c'est court XD

++Sim++
Titre: Re : Les différents opérateurs
Posté par: Bayshore le 08 Février 2009, 01:16:06
Avec un pdf ce sera plus ou moins pareil...

Sinon je crois que l'on peut aussi faire var /= 3; pour diviser par 3.

Aussi il y a ^= (et certainement d'autres), mais je ne suis pas sûr de savoir à quoi il sert...
Titre: Re : Les différents opérateurs
Posté par: Syg le 09 Février 2009, 16:33:47
Tout à fait bayshore, /= fonctionne bien comme les autres opérateurs.
var/=3; équivaut à var = var/3;

Pour ^=, c'est la même chose.
var^=3; équivaut à var = var^3;

L'opérateur ^ est un ou exclusif bit à bit qui n'est pas cité par Sim mais dont l'utilité en PAWN/SA-MP est discutable.
Exemple :
6^3=5

Si on décompose en base 2 :
6 -> 110
3 -> 011
5 -> 101

Le règles de calculs avec le ou exclusif sont les suivantes :
0^0=0
1^1=0
0^1=1
1^0=1

Comme autres opérateurs, on peut aussi citer l'opérateur % (modulo) :
var%=3; qui équivaut à var = var%3;

++
Syg



Titre: Re : Les différents opérateurs
Posté par: S!m le 10 Février 2009, 00:09:53
Salut,

le modulo, je l'ai connu quelque peut après la dernière version de ce simili tuto,
par contre j'ignorais totalement la signification de ^
merci Syg et bayshore, j'ajoute aussi tôt que possible :D

++Sim++
Titre: Re : Les différents opérateurs
Posté par: [viruz]rider_77 le 10 Février 2009, 01:01:57
alors je vais expliqué rapidement ce que j'ai compris aux différents opérateurs présents en pawn,
Les opérateurs sont sensiblement les même dans la plupart des languages de programmation  :king



Voici une autre contribution à ton tuto de ma part :

Faudrait pas oublier:

-=
+= (je sais pu s'il est déjà dans le tuto)
*=
!=

-=
Les codes suivant font le même travail:
Code: (c) [Sélectionner]
new Var = 10;
Var = Var - 3;

Code: (c) [Sélectionner]
new Var = 10;
Var -= 3;

En gros, -= signifie que l'opération sera : La valeur de la variable - le chiffre qui suit "-=".
Ainsi, la variable en question vaudra la valeur de la variable - le chiffre qui suit.

+=
Les codes suivant font le même boulot:
Code: (c) [Sélectionner]
new Var = 10;
Var = Var + 3;

Code: (c) [Sélectionner]
new Var = 10;
Var += 3;

En gros, += signifie que l'opération sera : La valeur de la variable + le chiffre qui suit "+=".
Ainsi, la variable en question vaudra la valeur de la variable + le chiffre qui suit.

*=
Les codes suivant font le même boulot:
Code: (c) [Sélectionner]
new Var = 10;
Var = Var * 3;

Code: (c) [Sélectionner]
new Var = 10;
Var *= 3;

En gros, *= signifie que l'opération sera : La valeur de la variable * le chiffre qui suit "*=".
Ainsi, la variable en question vaudra la valeur de la variable * le chiffre qui suit.

!=
Voici un exemple d'utilisation:
Code: (c) [Sélectionner]
new Var = 10;
if(Var != 10)
{
      //Instructions...
}
else
{
      //Instructions...
}

Le symbole != veut tout simplement dire différent de ....
Ainsi dans l'exemple ci-dessous, si Var est différente de 10 (!= 10) on entre dans les accolades...
Sinon on va voir dans le else :D

Titre: Re : Les différents opérateurs
Posté par: Syg le 10 Février 2009, 08:58:44
Tous les opérateurs que tu cites Rider sont déjà dans le tuto de Sim.
Et effectivement, tous ces opérateurs sont exactement les mêmes qu'en C/C++

++
Syg
Titre: Re : Re : Les différents opérateurs
Posté par: Bayshore le 14 Février 2009, 15:02:08
OK merci pour l'info sur le ^.

L'opérateur ^ est un ou exclusif bit à bit qui n'est pas cité par Sim mais dont l'utilité en PAWN/SA-MP est discutable.

Je l'avais vu dans la fonction Encript() de PEN1 (celle qui donne la fameuse faille)...

Code: (pawn) [Sélectionner]
public Encript(string[])
{
for(new x=0; x < strlen(string); x++)
  {
  string[x] += (3^x) * (x % 15);
  if(string[x] > (0xff))
  {
  string[x] -= 256;
  }
  }
return 1;
}
Titre: Re : Re : Les différents opérateurs
Posté par: [viruz]rider_77 le 14 Février 2009, 15:29:30
Tous les opérateurs que tu cites Rider sont déjà dans le tuto de Sim.
Et effectivement, tous ces opérateurs sont exactement les mêmes qu'en C/C++

++
Syg
J'avais pas vu :P
Titre: Re : Les différents opérateurs
Posté par: vincentdu90 le 31 Août 2010, 10:32:06
Je sais que ce tuto date de plus d'un an mais si j'ai bien compris l'utilité de l'opérateur "!"

Ceci :

if (strlen(Variable) == 0)
{
/* Action */
}

Equivaut à cela :

if (!strlen(Variable))
{
/* Action */
}

 ??
Titre: Re : Les différents opérateurs
Posté par: Syg le 31 Août 2010, 10:40:21
Oui, c'est équivalent mais pour une meilleure lisibilité, il vaut mieux utiliser la première notation (avec le ==).

D'ailleurs, en terme de rapidité, la première forme est plus rapide car dans la deuxième, il faut faire une négation bit à bit avant de pourvoir faire la comparaison. Même si sur un seul test la différence n'est pas quantifiable.

++
Syg
Titre: Re : Les différents opérateurs
Posté par: vincentdu90 le 31 Août 2010, 10:42:23
Ok , merci de l'info Syg  ;)
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: Xartrick le 27 Novembre 2011, 01:41:33
L'opérateur logique '^'

Appelé XOR, cet opérateur est un OU exclusif bit-à-bit.
Peut servir à vérifier si seulement une seule des conditions est vrai.


if ((IsPlayerConnected(playerid)) ^ (IsPlayerAdmin(playerid)))
0 ^ 0 = 0
1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1



L'opérateur '%'

Appelé modulo, cet opérateur sert à récupérer le reste d'une division.
Peut servir à savoir si un nombre est divisible par un autre.
Lorsque que (x % y) = 0, x est divisible par y.


9 % 3 = 0
25 % 5 = 0
10 % 6 = 4
40 % 3 = 1
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: mehdi-jumper le 27 Novembre 2011, 11:53:39
Et evidemment pas d'avertissement pour avoir uper un vieux sujet...
(http://www.gtaonline.fr/forums/Themes/orange-lt119v2/images/warnwarn.gif) Mais toi pour un HS tu t'en manges un ;)
Lui n'a fait que compléter un tuto.
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: Lacuisse le 27 Novembre 2011, 12:06:01
Je suis désolé mais entre toi et Xartrick le choix est vite fait  :)

++

PS: il remonte un vieux topic pour ajouter du contenu.
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: vincentdu90 le 27 Novembre 2011, 14:06:22
Bonjour ,

    J'aurai une petite question à propos des opérateurs du genre " += ; -=" . En fait je ne comprends pas dans quel(s) cas on peut utiliser ces opérateurs .
Merci d'avance de votre aide .
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: spiirou le 27 Novembre 2011, 14:10:54
C'est tout simplement un raccourci :

// Ces deux instruction ammenent au meme resultat
var1 = var1 + var2;
var1 += var2;

Exemple concret :

OnPlayerDeath(..)
{
     score[playerid] -= 2; // -2 pour le tuer
     score[killerid] += 5; // +5 pour le tueur
}

Spiirou
++
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: Syg le 28 Novembre 2011, 11:56:09
En 2009 (plus haut dans ce topic), je disais que l'utilité de l'opérateur ^ était discutable.

Et quand je vois ce que Xartrick en fait, ça ne conforte dans mon idée :)

if ((IsPlayerConnected(playerid)) ^ (IsPlayerAdmin(playerid)))
Le problème ici, c'est que si le joueur est admin, il est forcément connecté .... donc le test ne sera jamais vérifié. Au final, ce test ne traitera que les joueurs connectés et non admin. Ce uiq se traduit par un test beaucoup plus simple :
if (!IsPlayerAdmin(playerid))
J'ai cherché un exemple concret d'utilisation de l'opérateur dans un test où l'on voudrait une des deux conditions mais pas les deux en même temps et je n'en ai pas trouvé (ce qui ne veux pas dire qu'il n'y en a pas).

Sinon, le ou exclusif est surtout utilisé dans les fonctions de cryptage car il est réversible et permet très simplement de crypter et décrypter :
A^B=C et C^B=A
Dans ce cas, B pourra être appelé "clef de cryptage".

++
Syg
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: Xartrick le 28 Novembre 2011, 17:21:05
Je n'ai pas trouvé d'exemple pertinent, donc j'ai mit un exemple qui m'est tombé sous la main.
Sinon, effectivement, on peut se servir pour chiffrer et déchiffrer une chaîne de caractères par exemple.

Je viens d'envoyer un code utilisant ce principe ici (http://www.gtaonline.fr/forums/index.php/topic,2149.msg253054.html#msg253054).
Titre: Re : Les différents opérateurs [niveau: tous]
Posté par: vincentdu90 le 30 Novembre 2011, 18:10:55
Merci à vous spiirou et Gzsume j'y vois un peu plus clair .