Discussion :

[alter]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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];
}

[Laurent Gomila]

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

[alter]

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]; ?

[Laurent Gomila]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[alter]

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

tu pourrais factoriser tout le code commun dans une fonction template

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[alter]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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