Comment ajouter une nouvelle valeur dans un tableau en Pawn Language

Les tableaux sont des structures fondamentales en programmation : ils permettent de regrouper plusieurs valeurs du même type et d'y accéder par un indice. En Pawn, comme en C, les tableaux sont largement utilisés pour organiser des séries de valeurs et interagir avec des fonctions, la mémoire et les appels par adresse.

Comprendre le fonctionnement d'un tableau en mémoire

Les tableaux sont des ensembles de variables du même type stockées côte à côte en mémoire. Voici le schéma d'un tableau de 4 cases en mémoire qui commence à l'adresse 1600. Lorsque vous demandez à créer un tableau de 4 cases en mémoire, votre programme demande au système d'exploitation la permission d'utiliser 4 cases en mémoire. Chaque case du tableau contient un nombre du même type. Si le tableau est de type int, alors chaque case du tableau contiendra un int.

Les cases sont numérotées via des indices commençant à 0 : tableau[0], tableau[1], tableau[2], etc. La première valeur n'est pas stockée à la case 1 mais bien à la case 0 et donc la case maximale sera inférieure de 1, par rapport à son index.

Déclaration et initialisation d'un tableau en Pawn (C-like)

Voyons comment définir un tableau de 4 int :

int tableau[4];

Lire aussi: Modifier Activité Kbis Auto-Entrepreneur

Il suffit de rajouter entre crochets le nombre de cases que vous voulez mettre dans votre tableau. On peut aussi initialiser les cases au moment de la déclaration :

int tableau[4] = {10, 23}; // Valeurs insérées : 10, 23, 0, 0… la case n°0 prendra la valeur 10, la n°1 prendra 23, et toutes les autres prendront la valeur 0 (par défaut).

Pour initialiser tout le tableau à 0, il suffit d'initialiser au moins la première valeur à 0 :

int tableau[4] = {0}; // Toutes les cases du tableau seront initialisées à 0

Une autre méthode d'initialisation consiste à laisser les crochets vides et laisser le compilateur déduire la taille :

Lire aussi: INPI et Micro-Entreprise : Démarches

int tableau[] = {12, 19, 18, 2}; Ici, le compilateur déduira que le tableau est de taille 4 et les cases seront initialisées en fonction des nombres entre accolades.

Relation entre tableaux et pointeurs

En C-like (et donc en Pawn conceptuellement), si vous écrivez juste tableau, vous obtenez un pointeur : c'est un pointeur sur la première case du tableau. printf("%d", tableau[0]); affichera la première valeur. De même pour les autres indices : printf("%d", *tableau); renvoie la première case. Il est aussi possible d'obtenir la valeur de la seconde case avec *(tableau + 1) (adresse de tableau + 1).

Parcourir un tableau et afficher son contenu

Supposons que je veuille maintenant afficher les valeurs de chaque case du tableau. Le mieux est de se servir d'une boucle. Vous aurez à coup sûr souvent besoin d'afficher tout le contenu de votre tableau. Pourquoi ne pas écrire une fonction qui fait ça ? Ça va nous permettre de découvrir comment on envoie un tableau à une fonction.

Pour écrire une fonction qui affiche le contenu d'un tableau, il va falloir envoyer deux informations à la fonction :

• Le tableau (en fait l'adresse du tableau).
• Et aussi et surtout sa taille !

La fonction prend en paramètre un pointeur sur int (notre tableau), ainsi que la taille du tableau (très important pour savoir quand s'arrêter dans la boucle !). Notez qu'il existe une autre façon d'indiquer que la fonction reçoit un tableau. Plutôt que d'indiquer que la fonction attend un int *tableau, mettez ceci :

Lire aussi: Comment Calculer la TVA ?

void affiche(int tableau[], int tailleTableau)

Cela revient exactement au même, mais la présence des crochets permet au programmeur de bien voir que c'est un tableau que la fonction prend, et non un simple pointeur. Je vous conseille d'utiliser les crochets dans vos fonctions pour indiquer qu'elles attendent un tableau.

Pour illustrer, voici le prototype d'une fonction sommeTableau :

int sommeTableau(int tableau[], int tailleTableau);

Ensuite, créez une fonction moyenneTableau qui calcule et renvoie la moyenne des valeurs. Tout le contenu du tableau est affiché par la fonction via une boucle.

Ajouter une nouvelle valeur à un tableau en Pawn : stratégies

Contrairement à des langages dynamiques (PHP, JavaScript) où les tableaux peuvent être redimensionnés facilement, les tableaux déclarés statiquement (comme en Pawn/C) ont une taille fixe déterminée à la déclaration. Cependant, il existe plusieurs stratégies pratiques pour "ajouter" une nouvelle valeur à un tableau existant :

1. Préallouer une capacité suffisante : Déclarez un tableau plus grand que nécessaire et maintenez une variable indiquant la taille logique (nombre d'éléments utilisés). Pour ajouter une valeur, placez-la à l'indice suivant et incrémentez le compteur.
2. Créer un nouveau tableau plus grand et copier les valeurs : Comme en Java ou C, créez un nouveau tableau d'une taille supérieure, copiez les éléments existants, ajoutez la nouvelle valeur et remplacez l'ancien tableau par le nouveau. Cette méthode est simple mais coûteuse en temps si utilisée fréquemment.
3. Utiliser des structures dynamiques ou API du moteur (si disponibles) : Certains environnements fournissent des collections ou fonctions d'extension (ex. listes dynamiques, ArrayList en Java). Dans SA:MP/Pawn, on peut parfois recourir à plugins, natives ou allocations dynamiques fournies par l'environnement pour simuler des tableaux dynamiques.
4. ReDim / Re-allocation (conceptuel) : Dans d'autres langages, il existe une instruction ReDim ou une fonction arrayCopy qui permet d'agrandir et de préserver le contenu. En Pawn natif vous devrez imiter ce comportement en allouant un nouveau tableau et en copiant.

Exemple d'approche recommandée : tableau avec compteur

Une méthode robuste et efficace consiste à :

• Déclarer un tableau de taille maximale attendue : int items[100];
• Déclarer un compteur logique : int count = 0;
• Pour ajouter une valeur : si count < capacité, items[count] = nouvelleValeur; count++;

Cette approche évite de réallouer fréquemment la mémoire et reste simple à implémenter dans Pawn. Elle fonctionne particulièrement bien pour des jeux ou modes (SA:MP) où la mémoire et les performances sont importantes.

Redimensionner un tableau en copiant les éléments

Si vous ne pouvez pas connaître à l'avance la taille maximale, implémentez une fonction qui :

1. Crée un nouveau tableau d'une taille supérieure (par exemple, doublez la capacité).
2. Copie les éléments du tableau existant vers le nouveau tableau.
3. Ajoute la nouvelle valeur dans la première case libre du nouveau tableau.
4. Remplace l'ancien tableau par le nouveau (dans votre logique de gestion).

C'est la méthode utilisée sous le capot par beaucoup de structures dynamiques (ArrayList, vecteur en C++). Elle réduit le nombre de copies par rapport à l'extension d'un élément à la fois.

Passer un tableau à une fonction et modifier son contenu

Pour modifier ou ajouter logiquement des valeurs dans un tableau depuis une fonction, vous devez passer :

• Le tableau (en Pawn : son adresse, équivalent à un pointeur).
• La taille logique ou la capacité, et parfois le compteur d'éléments (passé par référence si vous souhaitez le modifier).

Les appels par référence permettent d'obtenir la valeur ainsi que l'adresse d'une variable et donc de pouvoir modifier ou utiliser sa valeur. En Pawn, les appels par référence (similaires aux pointeurs en C) sont couramment utilisés pour cet objectif.

Prototype utile

Par exemple :

public void AddValue(int tableau[], &int count, int capacity, int value)

Dans cette signature conceptuelle, &int count permet d'incrémenter le compteur depuis la fonction. La fonction vérifie si count < capacity, écrit la valeur et incrémente count ; sinon, elle peut signaler un besoin de redimensionnement.

Bonnes pratiques pour la gestion des tableaux en Pawn

• Toujours maintenir un compteur d’éléments logique si la capacité diffère du nombre d’éléments réellement utilisés.
• Utiliser des boucles pour parcourir un tableau plutôt que d'écrire un printf par case. Cela rend le code maintenable et évolutif.
• Quand vous envoyez un tableau à une fonction, passez aussi sa taille : la fonction ne connaît pas la taille du tableau par défaut.
• Initialiser les tableaux lorsque c'est possible (int tableau[4] = {0};) pour éviter des valeurs indéfinies.
• Éviter les redimensionnements fréquents ; si possible, préallouez ou doublez la capacité lors du redimensionnement.

Tableau récapitulatif : méthodes pour ajouter une valeur

Exemples concrets et recommandations pour SA:MP / Pawn

SA:MP intègre énormément de fichiers et fonctions natives ; parfois, des natives ou plugins fournissent des structures de données plus confortables. Toutefois, la méthode robuste la plus simple en Pawn est de gérer un tableau statique avec un compteur logique, ou d'implémenter un mécanisme de redimensionnement qui alloue un nouveau tableau et copie les éléments.

En bref : pour "ajouter" une nouvelle valeur dans un tableau Pawn, soit vous avez de la place dans le tableau déjà déclaré (utiliser un compteur), soit vous devez créer un nouveau tableau plus grand et copier les anciennes valeurs avant d'ajouter la nouvelle. Ces techniques sont les mêmes principes que l'on retrouve en C, Java, PHP ou JavaScript, adaptées aux contraintes de Pawn.

En résumé (points clés)

• Les tableaux stockent des éléments du même type côte à côte en mémoire.
• La taille d'un tableau statique est déterminée à la déclaration ; pour la simuler dynamique, utilisez redimensionnement par copie ou structure de contrôle (capacité + compteur).
• Initialiser les tableaux (ex. {0}) évite des valeurs indéfinies.
• Toujours passer la taille/logique du tableau aux fonctions qui le manipulent.
• En Pawn, utiliser les appels par référence pour modifier compteurs ou retourner des tableaux modifiés depuis des fonctions.

balises:

Articles populaires:

• Paiement cotisations URSSAF : le guide
• Franchise immobilière : Comment se lancer ?
• Tout savoir sur la fiscalité des intérêts en France
• Comptabilisation TVA : le guide
• Qui sont les personnages du jeu vidéo Freelancer ?