Il y a trois "façons" d'utiliser le signe '&' en PAWN.
La première c'est en le doublant (&&) et ceci correspond au ET logique utilisé dans les tests (ceci a déjà été dit et est connu de tous).
La deuxième utilisation ce fait dans une expression et correspond à un ET bit a bit.
Exemple :
Calculons 52&23
52 = 00110100 (en binaire)
23 = 00010111 (en binaire)
Avec les régles de base 0&0=0, 0&1=0, 1&0=0 et 1&1=1 ou trouve
00110100
00010111
--------------
00010100 = 20 donc 53&23=20.
Vous allez donc me demander à quoi ça sert.
Et bien l'exemple ci-dessus n'a aucune utilité en soi.
Par contre, en définissant des constantes n'ayant qu'un seul bit positionné à 1 (00000001, 00000010, ...) on peut s'en servir comme d'un masque.
Prenons un exemple concret :
Dans SAMP nous trouvons les defines suivants :
#define KEY_CROUCH (2)
#define KEY_FIRE (4)
2=00000010 (b) et 4 = 00000100(b)
Lorsque que l'on récupère les touches pressées par l'utilisateur, on obtient un nombre (donc 16 bits en PAWN mais on se contenera de 8 bits pour simplifier)
Chaque bit de ce nombre correspond à une touche et si la touche est enfoncée, le bit correspondant est à 1.
Comme l'utilisateur peut appuyer sur plusieurs touches en même temps, ce nombre peut contenir plusieurs bit à 1.
Si l'utilisateur appuie sur KEY_CROUCH (accroupi), la valeur du nombre sera 00000010 (=2).
Si il appuie sur KEY_FIRE (tirer), sa valeur sera 4.
Par contre, si il appuie en même temps sur ces deux touche, la valeur du nombre sera 6 (4+2).
Si on veut tester les touches, il va falloir tester toutes les valeurs possibles de ce nombre.
Vu qu'il y a au moins 10 touches, il y aura au moins 2^10 (=1024) valeurs possibles.
Et c'est là qu'intervient l'opérateur &.
Il permet "d'extraire" d'un nombre un bit qui nous interresse.
Si notre nombre vaut 6 (=00000110 en binaire)
Quand on fait 6&KEY_CROUCH on obtient un nombre différent de 0 (on obtient 4 en fait)
Par contre si on fait 6&KEY_JUMP (KEY_JUMP=32=00100000) on obtient 0 car l'utilisateur n'a pas utilisé la touche JUMP.
Exemple de code utilisant cet opérateur :
GetPlayerKeys (playerid, keys, updown, leftright);
if (keys & KEY_ACTION)
{
/* Le joueur à appuyé sur le touche ACTION */
}
La troisième utilisation du signe & est le passage par référence des paramètres des fonctions (c'est la question d'Alexandre).
Il existe deux façon de passer les paramètres à une fonction en PAWN :
- La passage par valeur
- Le passage par référence
Dans le passage par valeur, la valeur du paramètre est copié temporairement sur la pile et la fonction l'utilise. La fonction n'a pas accès à la variable qui contient la valeur.
Ainsi si on considère la fonction suivante :
MaFonction (a)
{
a=3;
}
NB : Il se peut que le compilo emmete un warning
Et un appel à cette fonction :
new UneValeur=7;
Mafonction (UneValeur);
Après l'appel de la fonction, la valeur de UneValeur n'est pas changée.
Dans le passage par référence, on passe une référence à la variable qui sert de paramètre.
Ainsi si on considère la fonction suivante :
MaFonction (&a)
{
a=3;
}
Et un appel à cette fonction :
new UneValeur=7;
Mafonction (UneValeur);
Après l'appel de la fonction, la valeur de UneValeur est 3.
Attention, les appels suivants sont interdit (erreur de compil) :
MaFonction (&49);
MaFonction (&MAX_PLAYERS);
car 49 et MAX_PLAYERS sont des constantes et non des variables
++
Syg