tableaux à valeur variable dans une classe

Bonjour tout le monde :smiley:

Je suis débutant aguerris sur arduino et m’attèle à la construction d’une class. J’aurais besoin d’utiliser un tableaux que se partage plusieurs méthode de la class. Mais qui serait de longueur variable en fonction d’un paramètre.

.h

class maClasse
{
public:
maClasse();
void  MaMethode1( byte maVariable ) ; 
void  MaMethode2( ) ;    

private:
byte _maVariable
monTableaux[_maVariable] ; // Je sais que c'est pas comme ça qu'il faut faire... :(
}

.cpp

void MaClasse:: MaMethode1( byte maVariable ) // Une première méthode qui donne l'information de la 
longueur de monTableaux. Et qui l'utilise
{
_maVariable= maVariable;   // Je copie la valeur de maVariable pour l'utilisez dans d'autres méthodes.
 for(byte i =0 ; i < maVariable ; i++){
monTableaux[i]=1 ;   // Un exemple d'utilisation de monTableaux
}

void MaClasse:: MaMethode2() // Une autre méthode qui utilise monTableaux.
{
 for(byte i =0 ; i < _maVariable ; i++){
monTableaux[i]=0 ;
}

Je sais que mon code est un peu farfelue mais c’est pour que vous compreniez en gros ce que je souhaite faire :slight_smile:
Il me semble que je suis obligé de déclarer monTableaux dans le .h si je veux l’utiliser avec les autres méthode.

Après mettre renseigné un peu partout. Il semble que l’on peu s’en sortir en mettant des : static ou const là ou il faut. Mais je souhaite que chaque objet puisse avoir un monTableaux[] de longueur différentes.

J’apprécie d’avance votre aide qui m’est précieuse :wink:

Tu peux allouer le tableau par new :

class maClasse {
  ...
  int* monTableau; // POINTEUR SUR UN TABLEAU de ints, à allouer.
}

maClasse::maClasse ( int taille )
{
  ...
  monTableau = new int [ taille ]; // ALLOCATION
}

maClasse::~maClasse ()
{
  delete[] monTableau;
}

en n’oubliant pas de le libérer dans le destructeur de la classe.
Il faut aussi probablement conserver la taille dans un membre de la classe.
Tu peux ensuite accéder aux éléments du tableau comme d’hab :

 monTableau[i] = 1;

Si les tailles des différents tableaux sont statiques et connues à la compilation et que c’est important d’allouer statiquement la mémoire, on peut aussi envisager un template de classe auquel on passe la taille voulue à la compilation. Ça génère des classes différentes mais sans allocations dynamiques de la mémoire.

 template <size_t N> class MaClasse {
  public:
  size_t taille; // pas obligatoire on peut utiliser N dans le code
  int tableau[N];

  MaClasse() {taille=N;}
  int obtenirElement(size_t indice) {
    return (indice < taille) ? tableau[indice] : 0; // retourne 0 si indice non valable
  }
};

(tapé ici depuis mon iPhone, non testé)

Yes MERCI !

La technique de biggil à marché ! :slight_smile: Merci aussi à J-M-L pour l'autre option :wink:

Cool :wink:

Pensez à écrire le destructeur comme mentionné par @biggil sinon vous aurez une fuite mémoire si vous en utilisez en tant qu’instances temporaires