Utiliser un tableau alloué dynamiquement dans une instruction conditionnelle en dehors de cette instruction

Bonjour,

Je suis sur un cas de déclaration de tableau qui me dérange.
Après que mon programme ait lu l'en-tête d'un fichier, il sait si le fichier contient un tableau d'entiers de 2 bytes ou de 4 bytes. Suivant le résultat, il peut allouer dynamiquement l'espace mémoire. Cette allocation se fait dans une instruction switch (ou if). Mais ensuite je ne peux pas utiliser mon tableau en dehors de cette instruction car le compilateur me dit que le tableau que j'essaie de manipuler doit l'être à l'endroit où il est déclaré.
Est-ce qu'il y a un moyen d'utiliser une méthode semblable à une surdéfinition pour que le pointeur sur le tableau que j'essaie d'utiliser en dehors de l'instruction switch puisse marcher ?

Code de déclaration ci-dessous :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

switch(TYPE) { case 2: { short int* tab=new short int[size_tab]; short int* tabtmp=new short int[size_tab]; break; } case 4: { long int* tab=new long int[size_tab]; long int* tabtmp=new long int[size_tab]; break; } }

---

Error pour les lignes suivantes en dehors de l'instruction de condition :

Code:

---

1 2 3 4 5

for(i=0; i < A; i++) { for(j=0; j < B; j++) tab[A*j+i]=tabtmp[B*i+j]; }

---

Il suffit de déclarer tab et tabtmp avant le switch.

Citation:

---

Envoyé par Laurent Gomila

Il suffit de déclarer tab et tabtmp avant le switch.

---

Comment le déclarer avant le switch si je ne connais pas son type avant ? Le type du tableau dépend de la condition. Si le fichier lu informe que le type est '2' alors les elmts du tableau sont des short int ; si c'est '4' alors ce sont des long.
Je fais truc* tab=new truc[size_tab]; ?

Ah pardon, j'avais lu un peu trop vite ton message.

Dans ce cas tu pourrais factoriser tout le code commun dans une fonction template

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

template <typename T> void fonction(std::size_t size_tab) { T* tab = new T[size_tab]; // un std::vector<T> serait plus classe T* tabtmp = new T[size_tab];   ... }   // Ensuite dans ta fonction précédente... switch(TYPE) { case 2: fonction<short int>(size_tab); break;   case 4: fonction<long int>(size_tab); break; }

---

Merci pour cette solution. Je fais connaissance avec les templates. :ccool:
Bonne journée

Citation:

---

Envoyé par Laurent Gomila

tu pourrais factoriser tout le code commun dans une fonction template

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

template <typename T> void fonction(std::size_t size_tab) { T* tab = new T[size_tab]; // un std::vector<T> serait plus classe T* tabtmp = new T[size_tab];   ... }   // Ensuite dans ta fonction précédente... switch(TYPE) { case 2: fonction<short int>(size_tab); break;   case 4: fonction<long int>(size_tab); break; }

---

---

Finalement, je n'arrive pas à appliquer ta solution.
J'ai mis le programme que j'ai fais si dessous contenant ce que j'ai détaillé dans mon 1er message.
La partie concernant l'appel de la fonction avec templates ne compile pas. (Je mets les erreurs après le code.).
Il faut déclarer les tabeaux tabA et tabB dans le main mais je vois pas comment avec ce template...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

#include <iostream> #include <string> #include <fstream> #include <new> #include <iomanip> #include <cstdlib> #include <cmath> #include <algorithm> #include "read_header.h"   using namespace std;   void initialize(std::size_t size_tabA, std::size_t size_tabB);   template <typename T>   void initialize(std::size_t size_tabA, std::size_t size_tabB) { T* tabA = new T[size_tabA]; T* tabB = new T[size_tabB]; }   int main(int argc, char *argv[]) { string file_in;   long int TYPE, nbheadA, px_i, px_j, px_k; string og;   file_in=argv[1]; read_header(file_in, &TYPE, &nbheadA, &px_i, &px_j, &px_k, &og); if (px_k != 1 && og != "jhd") exit (-1);   unsigned long int size_tabA=px_i*nbheadA; unsigned long int size_tabB=px_i*px_j; //******************************************************************************* //Ouverture du fichier en lecture ifstream fichier(file_in.c_str(), ios::in); if(!fichier.is_open()) exit (-1); //******************************************************************************* switch(TYPE) { case 1: initialize<unsigned char>(size_tabA,size_tabB); fichier.read(reinterpret_cast<unsigned char*>(*tabA),size_tabA*sizeof(unsigned char)); fichier.read(reinterpret_cast<unsigned char*>(*tabB),size_tabB*sizeof(unsigned char)); break;   case 2: initialize<unsigned short int>(size_tabA,size_tabB); fichier.read(reinterpret_cast<unsigned short int*>(*tabA),size_tabA*sizeof(unsigned short int)); fichier.read(reinterpret_cast<unsigned short int*>(*tabB),size_tabB*sizeof(unsigned short int)); break; } fichier.close(); delete[] tabA; delete[] tabB; return (0); }

---

Code:

---

1 2 3 4 5

test.cpp: In function ‘int main(int, char**)’: test.cpp:45: erreur: ‘tabA’ was not declared in this scope test.cpp:46: erreur: ‘tabB’ was not declared in this scope test.cpp:56: erreur: ‘tabA’ was not declared in this scope test.cpp:57: erreur: ‘tabB’ was not declared in this scope

---

bonjour

Tu déclares des variables size_tabA et size_tabB

Code:

---

1 2	unsigned long int size_tabA=px_i*nbheadA; unsigned long int size_tabB=px_i*px_j;

---

et tu utilises des tabA et tabB donc normal que ça ne compile pas.

Edit: en relisant le post le Laurent, je pense qu'il te conseillait de TOUT refactoriser : l'initialisation du tableau et le traitement des donées :

Code:

---

1 2 3 4 5 6 7 8

template <typename T> void initialize(std::size_t size_tabA, std::size_t size_tabB) { T* tabA = new T[size_tabA]; T* tabB = new T[size_tabB]; fichier.read(T* tabA, size_tabA*sizeof(T)); fichier.read(T* tabB, size_tabB*sizeof(T)); }

---

EDIT2 : et en fait, ton problème est que tu définies tabA et tabB dans la fonction et donc que ces variables ne sont pas accessibles dans main.
il suffirait de modifier l'appel de fonction :

Code:

---

void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB)

---

mais c'est mieux de tout garder dans le template

Tout le code dépendant du type (donc tout le code qui utilise les tableaux) doit se trouver dans la fonction, tu ne peux pas n'y mettre qu'une partie.

Tout d'abord merci pour vos réponses.

Citation:

---

Envoyé par Laurent Gomila

Tout le code dépendant du type (donc tout le code qui utilise les tableaux) doit se trouver dans la fonction, tu ne peux pas n'y mettre qu'une partie.

---

Dans ce cas, je ne gagne pas grand chose par rapport à ce que je faisais au début et qui ne me conviens pas. A savoir je ne peux pas faire une déclaration dynamique d'un tableau dans le switch (avec ou sans fonction) puis en sortant du switch, j'utilise ce tableau (pour différents calculs par ex). Dans un langage de programmation qui s'appelle IDL ceci se fait tellement simplement que je me disais qu'il doit y avoir une solution. Voici comment le code se présente IDL et que je veux faire en C++ :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

pro test, file_in   ;******************* ;Simulation de la lecture de l'en-tête du Fichier file_in TYPE=fix(1) nbheadA=fix(2) px_i=fix(5000) px_j=fix(5000) px_k=fix(1) og='jhd' ;******************* ; (size_tabA == px_i*nbheadA) ; (size_tabB == px_i*px_j) openr, unit, file_in, ERROR = err, /get_lun;Ouverture du fichier file_in ;******************* ;Initialisation des tableaux tabA et tabB case TYPE of long(1): begin tabA=bytarr(px_i,nbheadA) tabB=bytarr(px_i,px_j) end long(2): begin tabA=intarr(px_i,nbheadA) tabB=intarr(px_i,px_j) end endcase ;******************* ;******************* ;Lecture de l'ensemble des tableaux du fichier readu,unit,tabA readu,unit,tabB ;******************* free_lun, unit;Fermeture du fichier ;Ensuite je continue de manipuler les tableaux tabA et tabB en dehors de l'instruction conditionnelle   end

---

J'ai bien compris que le template que tu m'as détaillé est forcément une part de la solution. Je crois bien que gbdivers a exposé la suite de la solution mais je suis en surchauffe là. Là je réfléchi à ce que tu m'as mis gbdivers, et je vais faire des tests...

Le problème est que IDL est (d'après le code que tu donnes) un language non typé, contrairement au c++ :
avec IDL, tu peux faire :

Code:

---

1 2 3 4

tabA = 1 tabA = 1.0 tabA = "une chaine" etc.

---

Il n'y a pas d'obligation 1 variable = 1 type

Alors qu'en C++, ce n'est pas possible (je simplifie un peu, tu pourrais utiliser des types variants telque boost::variant ou QVariant, mais ça serait soritir la grosse artillerie pour pas grand chose à mon avis)

La solution que j'utiliserais dans ce cas serait une classe template, qui encapsulerait le stockage et la manipulation des données (donc quelque chose de très classique) :

Code:

---

1 2 3 4 5 6 7 8 9

template< typename T > class MyArray { private: // ton conteneur std::vector<T> m_tabA; // mieux que manipuler T[] public: // tes functions et tes operateurs de manipulation de tes objets };

---

Tout dépend des manipulations que tu veux faire sur tes données

Citation:

---

Envoyé par gbdivers

Le problème est que IDL est (d'après le code que tu donnes) un language non typé, contrairement au c++

---

Oui je vois. C'est comme le php.

Citation:

---

Envoyé par gbdivers

...Tout dépend des manipulations que tu veux faire sur tes données

---

Ce que je veux faire c'est utiliser ce tableau tabB en parallèle à un autre (tabC de dimension 10 fois supérieur) pour créer un nouveau tableau (avec les mm dimensions que tabB). La manipulation des valeurs de tabB fera appel à une fonction moyenne pondérée ou, selon le cas, à une fonction à seuil unique. (TabA est supprimé après lecture).

Citation:

---

Envoyé par gbdivers

Code:

---

1 2 3 4 5 6 7 8 9

template< typename T > class MyArray { private: // ton conteneur std::vector<T> m_tabA; // mieux que manipuler T[] public: // tes functions et tes operateurs de manipulation de tes objets };

---

---

Désolais, mais est-ce qu'il serait possible de faire sans les classes ou alors j'aurais besoin de voir comment mon code du dessous se retrouve au final parce que je serais trop perdu :scarymov:.

J'ai fais un test en reprenant ta 1ère réponse. J'ai ce code... et ces erreurs :triste: :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

#include <iostream> #include <string> #include <fstream> #include <new> #include <iomanip> #include <cstdlib> #include <cmath> #include <algorithm> #include "fis_read_header.h"   using namespace std;   template <typename T> void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB);   void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB) { T* tabA = new T[size_tabA]; T* tabB = new T[size_tabB]; }   int main(int argc, char *argv[]) { string file_in;   long int TYPE, nbheadA, px_i, px_j, px_k; string og;   file_in=argv[1]; read_header(file_in, &TYPE, &nbheadA, &px_i, &px_j, &px_k, &og); if (px_k != 1 && og != "jhd") exit (-1);   unsigned long int size_tabA=px_i*nbheadA; unsigned long int size_tabB=px_i*px_j; //******************************************************************************* //Ouverture du fichier en lecture ifstream fichier(file_in.c_str(), ios::in); if(!fichier.is_open()) exit (-1); //******************************************************************************* switch(TYPE) { case 1: initialize<unsigned char>(tabA,size_tabA,tabB,size_tabB); fichier.read(reinterpret_cast<unsigned char*>(*tabA),size_tabA*sizeof(unsigned char)); fichier.read(reinterpret_cast<unsigned char*>(*tabB),size_tabB*sizeof(unsigned char)); break;   case 2: initialize<unsigned short int>(tabA,size_tabA,tabB,size_tabB); fichier.read(reinterpret_cast<unsigned short int*>(*tabA),size_tabA*sizeof(unsigned short int)); fichier.read(reinterpret_cast<unsigned short int*>(*tabB),size_tabB*sizeof(unsigned short int)); break; } fichier.close(); delete[] tabA; delete[] tabB; return (0); }

---

Encore des pb de déclaration qui me surpasse :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

test.cpp:16: erreur: variable or field ‘initialize’ declared void test.cpp:16: erreur: ‘T’ was not declared in this scope test.cpp:16: erreur: ‘tabA’ was not declared in this scope test.cpp:16: erreur: expected primary-expression before ‘size_tabA’ test.cpp:16: erreur: ‘T’ was not declared in this scope test.cpp:16: erreur: ‘tabB’ was not declared in this scope test.cpp:16: erreur: expected primary-expression before ‘size_tabB’ test.cpp: In function ‘int main(int, char**)’: test.cpp:43: erreur: ‘tabA’ was not declared in this scope test.cpp:43: erreur: ‘tabB’ was not declared in this scope test.cpp:55: erreur: ‘tabA’ was not declared in this scope test.cpp:56: erreur: ‘tabB’ was not declared in this scope

---

La différence de type n'a beau n'apparaître que lors de la déclaration du tableau, et le reste du code être identique, la différence est bien présente tout au long de ton algorithme. Donc il ne faut pas que tu cherches à séparer uniquement la création du tableau, c'est réellement tout ton algo qui dépend du type et qui doit donc être templatisé. Donc tout le code dépendant du tableau doit être paramétré par un type template T, après peu importe comment tu organises ça (une fonction, plusieurs fonctions, une classe, ...).

Tu déclares ici une fonction template "initialize<T>" (sans l'implémentation)

Code:

---

1 2	template <typename T> void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB);

---

puis ici, tu déclares et tu implémente une fonction "initialize" qui utilise un type T non définie :

Code:

---

1 2 3 4 5

void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB) { T* tabA = new T[size_tabA]; T* tabB = new T[size_tabB]; }

---

tu dois juste écrire :

Code:

---

1 2 3 4 5 6

template <typename T> void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB) { T* tabA = new T[size_tabA]; T* tabB = new T[size_tabB]; }

---

Pour les erreurs lignes 42 et 56, c'est toujours le même problèmes : tabA et tabB ne sont pas déclarés (et donc erreur de compilation)
Pour rappel, en C++, les variables ne sont pas "visibles" partout : tes variables tabA et tabB déclarées dans la fonction ne seront pas utilisables dans main.

Et vouloir séparer initialization et utilisation des tes données t'obligera à te balader avec des templates dans tout ton code, ce qui n'est pas une solution.

EDIT : décidement, je suis trop lent ce soir :)

Citation:

---

Envoyé par gbdivers

Tu déclares ici une fonction template "initialize<T>" (sans l'implémentation)...

---

J'ai corrigé cette partie pour... obtenir d'autres bugs lol.
J'ai aussi déclaré les 2 tableaux cette fois-ci... Désolé le compilateur m'a, une fois de plus, envoyé bouler.
Voici mon code de mer.. :
(Attention il est possible que cela pique aux yeux)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

#include <iostream> #include <string> #include <fstream> #include <new> #include <iomanip> #include <cstdlib> #include <cmath> #include <algorithm> #include "fis_read_header.h"   using namespace std;   template <typename T> void initialize(T* tabA, std::size_t size_tabA, T* tabB, std::size_t size_tabB) { T* tabA = new T[size_tabA]; T* tabB = new T[size_tabB]; }   int main(int argc, char *argv[]) { string file_in;   long int TYPE, nbheadA, px_i, px_j, px_k; string og;   file_in=argv[1]; read_header(file_in, &TYPE, &nbheadA, &px_i, &px_j, &px_k, &og); if (px_k != 1 && og != "jhd") exit (-1);   unsigned long int size_tabA=px_i*nbheadA; unsigned long int size_tabB=px_i*px_j;   T* tabA;//Déclaration du tableau A T* tabB;//... et du tableau B   //******************************************************************************* //Ouverture du fichier en lecture ifstream fichier(file_in.c_str(), ios::in); if(!fichier.is_open()) exit (-1); //******************************************************************************* switch(TYPE) { case 1: initialize<unsigned char>(tabA,size_tabA,tabB,size_tabB); fichier.read(reinterpret_cast<unsigned char*>(*tabA),size_tabA*sizeof(unsigned char)); fichier.read(reinterpret_cast<unsigned char*>(*tabB),size_tabB*sizeof(unsigned char)); break;   case 2: initialize<unsigned short int>(tabA,size_tabA,tabB,size_tabB); fichier.read(reinterpret_cast<unsigned short int*>(*tabA),size_tabA*sizeof(unsigned short int)); fichier.read(reinterpret_cast<unsigned short int*>(*tabB),size_tabB*sizeof(unsigned short int)); break; } fichier.close(); delete[] tabA; delete[] tabB; return (0); }

---

Code:

---

1 2 3 4 5 6 7 8 9

test.cpp: In function ‘void initialize(T*, size_t, T*, size_t)’: test.cpp:16: erreur: declaration of ‘T* tabA’ shadows a parameter test.cpp:17: erreur: declaration of ‘T* tabB’ shadows a parameter test.cpp: In function ‘int main(int, char**)’: test.cpp:38: erreur: ‘T’ was not declared in this scope test.cpp:38: erreur: ‘tabA’ was not declared in this scope test.cpp:39: erreur: ‘tabB’ was not declared in this scope test.cpp:55: erreur: type ‘<type error>’ argument given to ‘delete’, expected pointer test.cpp:56: erreur: type ‘<type error>’ argument given to ‘delete’, expected pointer

---

Bon qq à un pb de transport. Je pars me rendre utile.
A+

Bonsoir/jour

Si vos données sont au plus sur 4 octets (donc 1, 2 ou 4) alors je vous conseille d'utiliser un vecteur d'int (sur une machine 32 bits) dans tout les cas. Seule la façon d'initialiser le vecteur en lisant le fichier dépendra de la taille des données, bref ce ne sera pas un simple read mais une lecture nombre par nombre 'manuelle', ce qui n'est vraiment pas compliquer à faire.

A noter que votre read écrivant directement dans le vecteur est dangereux car il suppose que l'ordre de mémorisation des octets dans le fichier est celui utilisé par votre processeur.

Bon, je crois que je n'aurais jamais du te dire que c'était possible d'initialiser tes variables dans une fonction template et de les utiliser en dehors. Tu essayes de reproduire ce que tu faisais avec IDL et ce n'est pas la bonne solution. Donc oublie pour le moment.

La remarque de bruno_pages est effectivement mieux (pourquoi on n'y a pas pensé avant ?) Ca te permet d'utiliser un seul type de conteneur (rappel, un std::vector c'est mieux) et de mettre en template que la lecture du fichier.

Si tu dois lire de gros fichier et que la mémoire est critique, tu souhaiteras peut être utiliser un conteneur de type adapté à ton type. Dans ce cas, il FAUT mettre l'initialisation, la lecture ET le traitement des données dans des templates (dans des fonctions ou des classes templates, peut importe en effet)

Grâce aux réponses sur les templates, le cerveau reposé par une bonne nuit et la réponse de bruno_pages, j'ai compris qu'il me reste une solution qui ne bouffe pas bcp de temps machines (et mon but n'est pas un prog optimisé sur ce point de vue) :
En dehors du fait que je vais me lancer dans les vectors, je vais donc initialiser deux vectors (A et B) avant le switch avec les nombres entiers sur 4 octets. Puis dans le switch, j'initialise puis remplis deux vectors (C et D) avec des nombres, contenus dans un fichier, sur 1 ou 2 octets selon les deux possibilités, puis, toujours dans ce switch, je vais utiliser deux "static_cast" pour réinjecter les contenus de C et D respectivement dans A et B, je supprime C et D et après le switch je continu de manipuler A et B. Au final, je supprime les templates.
Concernant la fonction read, je savais pas qu'elle risquait de lire les données dans le désordre. C'est bien génant. Je vais donc devoir utiliser un "get" dans une boucle for...

Merci beaucoup pour toutes ces réponses !
Une Hola pour vous trois !
:lahola: