HOWTO · C++
Retourner le pointeur vers le tableau en C++
Cet article montre comment retourner un pointeur vers un tableau à partir d'une fonction en C++
Sur cette page
Une fonction C++ peut renvoyer un pointeur vers un élément d’un tableau, mais ce pointeur ne contient ni la longueur du tableau ni d’information sur sa propriété. Pour l’utiliser sans risque, il faut savoir quel objet possède le stockage, combien d’éléments sont disponibles et combien de temps cet objet reste vivant. Pour les résultats courants, renvoyer un conteneur par valeur est généralement plus clair que de transférer un pointeur brut.
Comprendre à quoi renvoie un pointeur de tableau
Dans un paramètre de fonction, int values[] est ajusté en int* values. La borne fixe du tableau n’est pas conservée : il faut donc transmettre séparément le nombre d’éléments ou utiliser un conteneur qui mémorise sa taille. Le pointeur renvoie au premier élément ; un accès par indice tel que values[i] ne permet d’accéder aux éléments suivants que s’ils appartiennent au même tableau et que l’indice reste dans ses limites.
Renvoyer values renvoie cette adresse. Cela ne copie pas le tableau et ne prolonge pas sa durée de vie. Pour un objet std::array tel que values, l’appel de son membre values.data() renvoie un pointeur vers ses éléments. Ce pointeur reste valide uniquement tant que l’objet values est vivant et que son stockage n’a pas été invalidé.
Renvoyer un pointeur vers un tableau appartenant à l’appelant
Une méthode utile avec un pointeur brut consiste à laisser l’appelant posséder le tableau et à transmettre son adresse et sa longueur à une fonction. Celle-ci peut modifier les éléments puis renvoyer le même pointeur, ce qui facilite son utilisation par l’appelant. Ce dernier doit garder le tableau vivant et son stockage inchangé tant qu’il utilise le pointeur renvoyé.
Exécutez cet exemple :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#include <cstddef>
#include <iostream>
int* subtractFrom(int values[], std::size_t size, int amount) {
for (std::size_t i = 0; i < size; ++i) {
values[i] -= amount;
}
return values;
}
int main() {
int values[] = {5, 10, 15};
int* result = subtractFrom(values, 3, 2);
for (std::size_t i = 0; i < 3; ++i) {
if (i != 0) std::cout << ' ';
std::cout << result[i];
}
std::cout << '\n';
}
3 8 13
Le tableau appartient à main : il reste donc vivant pendant que result y est lu. La taille est transmise séparément, car le paramètre de la fonction ne connaît pas la longueur d’origine du tableau. Pour un conteneur de taille fixe, std::array<int, 3> values fournit un objet dont la taille est connue ; son membre data() peut fournir un pointeur vers un élément à une interface qui en a besoin.
Renvoyer un pointeur vers le stockage d’un tableau alloué dynamiquement
Une fonction peut allouer du stockage avec new[] et renvoyer le pointeur obtenu. L’appelant doit alors assurer manuellement le nettoyage : conserver le pointeur, ne pas accéder à plus d’éléments que le nombre alloué et libérer l’allocation une seule fois avec delete[] lorsqu’il a terminé. L’appelant doit aussi connaître le nombre d’éléments, car un pointeur brut ne le mémorise pas. Associer new[] à un delete scalaire, supprimer deux fois ou oublier de libérer le stockage entraîne des erreurs ou des fuites.
Dans cet exemple, makeSequence alloue et remplit trois entiers. L’appelant reçoit le pointeur, utilise le nombre d’éléments connu, puis libère le tableau avec le delete[] correspondant :
Le code et les libellés ou sorties affichés dans cette section restent en anglais.
#include <cstddef>
#include <iostream>
int* makeSequence(std::size_t count) {
int* values = new int[count];
for (std::size_t i = 0; i < count; ++i) {
values[i] = static_cast<int>(i * 5 + 3);
}
return values;
}
int main() {
const std::size_t count = 3;
int* values = makeSequence(count);
for (std::size_t i = 0; i < count; ++i) {
std::cout << values[i] << '\n';
}
delete[] values;
}
Cette technique permet de représenter une taille choisie à l’exécution, mais il est facile de perdre la trace de la propriété du stockage. Pour un résultat de longueur variable, préférez renvoyer std::vector<int> par valeur. Le vecteur gère son allocation, fournit sa taille et peut être déplacé efficacement. L’appelant ne doit utiliser ses éléments que tant que le vecteur est vivant et que son stockage n’a pas été invalidé par une opération qui le réalloue.
Éviter les pointeurs pendants et choisir un type de retour plus sûr
Ne renvoyez pas de pointeur vers un tableau local automatique. Sa durée de vie prend fin au retour de la fonction, et l’appelant se retrouve avec un pointeur pendant. Le cas d’un tableau local static est différent : son stockage persiste pendant toute la durée du programme, si bien que son pointeur ne devient pas pendant simplement parce que la fonction a terminé. Toutefois, les appels partagent le même tableau modifiable, sa capacité est fixe et les utilisations concurrentes ou imbriquées peuvent interférer. N’utilisez un stockage statique que si le partage d’état est intentionnel.
Pour un résultat de taille fixe, renvoyez std::array<int, N> par valeur. Pour un résultat de taille variable, renvoyez std::vector<int> par valeur. Ces types rendent la propriété explicite et évitent d’imposer à l’appelant une règle de nettoyage distincte pour un pointeur brut. Si une API doit renvoyer un pointeur vers un élément, documentez l’objet propriétaire et la durée de validité du pointeur ; ne l’utilisez pas après la destruction de son propriétaire ou une modification de son stockage.