Discussion :

[Nauvisse]

Bonjour,

J'ai un problème depuis des années déjà avec les tableaux de tableaux (problème que j'arrive à contourner en mettant tout dans une liste).

Code :

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

1
2
3
4
5
6
7
8
9
10
TYPE myfunction() // Type souhaité à retourner : int[7][5] ; type qu'on peut retourner : int**
{
  int grid[7][5] = malloc(7*5*sizeof(int));
  return grid;
}
 
int main()
{
  int grid[7][5] = myfunction(); // Type incompatible si myfunction retourne int** et elle ne peut pas retourner int[7][5].
}

Le problème est que :

Code :

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

int** grid1;

est différent de

Code :

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

int grid2[7][5];

. En effet grid[i+1][j] <=> *(grid+(i+1)*5+j) et avec int**, on perd les infos de la taille.

Y a-t-il une solution sans utiliser std::vector, une bibliothèque ou une classe pré-implantée svp ?

PS: Quand je tape :

Code :

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

1
2
3
4
5
6
 
int(*)[7][5] function()
{
  int grid[7][5] = new int[7][5];
  return grid;
}

le type de retour ne fonctionne pas plus et le new non plus.

[fred1599]

Bonjour,

Vous êtes sur un forum C et non C++. Vous devriez écrire ICI.

[CGi]

Vous êtes sur un forum C et non C++. Vous devriez écrire ICI.

Oui et non. Le problème initial tient plutôt du C.

@nauvisse Quand je vois ce code :

Code :

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

int grid[7][5] = malloc(7*5*sizeof(int));

Ça me laisse dire, que tu devrais reprendre un cours sur les tableaux du langage C.
Ici, tu tente d'initialiser un tableau déjà alloué sur la pile avec un pointeur d'une allocation sur le tas. Ça n'a aucun sens !

[Nauvisse]

Oui effectivement, c'est un compromis entre le C et le C++
Et aussi impossible d'initialiser un tableau déjà alloué sur la pile avec un pointeur d'une allocation sur le tas, effectivement.

Si je fais :

Code :

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

1
2
3
4
5
6
 
int** function()
{
  int** grid = new int[7][5];
  return grid;
}

ça ne marche pas, je lis <<cannot convert 'int(*)[5]' to 'int**' in initialisation>>

Je voudrais, dans la fonction qui utilise ensuite grid, écrire simplement grid[i][j] plutôt que *(grid+j+5*i).

Savez-vous svp ?

[foetus]

ça ne marche pas, je lis <<cannot convert 'int(*)[5]' to 'int**' in initialisation>>

Je voudrais, dans la fonction qui utilise ensuite grid, écrire simplement grid[i][j] plutôt que *(grid+j+5*i).

Savez-vous svp ?

Oui c'est normal

réponse rapide : vas relire les cours de pointeurs en C

Le type XX** est l'adresse d'1 pointeur d'1 variable de type XX.
Mais on utilise l'adresse d'1 variable (pointeur compris) que si on veut modifier la valeur de la dite variable.
La raison : en C, le passage de paramètres est 1 passage par valeur (lecture).

Parce que dans ton code, tu vas retourner l'adresse d'1 variable locale
Donc soit tu retournes juste 1 int* soit tu passes l'adresse d'1 pointeur sur 1 entier int**.

[dalfab]

Un tableau est complexe à gérer en C, une fonction ne peut ni recevoir ni retourner un tableau. Pour accéder à un tableau de tableaux, on peut se ramener à utiliser un pointeur sur des tableaux.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef int  Array5Int[5];
Array5Int*  myfunction( unsigned nb_rows ) // Type souhaité à retourner : int[7][5], remplacé par int (*)[5]
{
   Array5Int*  grid = malloc( nb_rows * sizeof(Array5Int) );  // alloue nb_rows éléments de type Array5Int
   return  grid;
}
int main()
{
   Array5Int*  grid = myfunction( 7 ); // myfunction( 7 ) retourne un int(*)[5] qui a 7 éléments
   grid[6][4] = 42;
}

Ca serait bien plus simple en C++:

Code :

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

1
2
3
4
5
6
#include <array>
int main() {
   using Grid = std::array<std::array<int,5>,7>;
   Grid  grid;             // pas d'allocation dynamique, peut être copié, et transmis et reçu de fonction
   grid[6][4] = 42;
}

[Nauvisse]

Merci beaucoup, j'avais pas pensé envoyer en entrée le pointeur plutôt que le récupérer en sortie. Je crois que ce code est correct :

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
 
void function(int (**gridPt)[5])
{
  *gridPt = new int[7][5];
 
  for (int j = 0 ; j < 5 ; ++j)
    for (int i = 0 ; i < 7 ; ++i)
      (*gridPt)[i][j] = 0;
 
  (*gridPt)[6][3] = 25;
}
 
int main(int argc, char *argv[])
{
  QCoreApplication qca(argc, argv);
 
  int (*grid)[5];
  function(&grid);
 
  int i,j;
 
  for (j = 0 ; j < 5 ; ++j)
  {
    for (i = 0 ; i < 7 ; ++i)
      printf("%d ",grid[i][j]);
    printf("\n");
  }
 
  delete [] grid;
 
  return qca.exec();
}

Bien compliqué toutefois.

Et si le nombre 5 est variable, je ne sais pas comment faire. Vous sauriez svp ?

[foetus]

Et si le nombre 5 est variable, je ne sais pas comment faire. Vous sauriez svp ?

Oui

Code :

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

1
2
3
4
5
6
7
8
9
10
11
typedef struct s_mytab {
//  ...
 
    char* data;
    size_t size;
    size_t allocated_size;
} t_mytab;
 
void mytab_create(t_mytab**, size_t size);
void mytab_delete(t_mytab*);
void mytab_init(t_mytab*);

[dalfab]

Avec new et delete, ça n'est plus plus du C, c'est du C++ du millénaire précédent. J'ai oublié.

[Nauvisse]

Merci Dalfab.

J'ai essayé, mais je n'arrive toujours pas à mettre comme argument d'une fonction qui crée le tableau le nombre de rangées et de colonnes, qu'il faille mettre le tableau en entrée ou en sortie de la fonction.

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
#include <QCoreApplication>
#include <iostream>
 
using namespace std; // std::array
 
void function1(int (**gridPt)[7])
{
  *gridPt = new int[5][7];
 
  for (int i = 0 ; i < 5 ; ++i)
    for (int j = 0 ; j < 7 ; ++j)
      (*gridPt)[i][j] = 0;
 
  (*gridPt)[4][6] = 5;
}
 
// Cette fonction ne marche pas.
void function2(int (**gridPt)[][colsNb], const int rowsNb, const int colsNb)
{
  *gridPt = new int[rowsNb][colsNb];
 
  for (int i = 0 ; i < rowsNb ; ++i)
    for (int j = 0 ; j < colsNb ; ++j)
      (*gridPt)[i][j] = 0;
 
  (*gridPt)[4][6] = 6;
}
 
// Méthode 1 : typedef
typedef int  Array7Int[7];
Array7Int*  myfunction(int rowsNb) // Type souhaité à retourner : int[5][7], remplacé par int (*)[7]
{
   Array7Int*  grid = (Array7Int*)malloc(rowsNb * sizeof(Array7Int));  // Alloue rowsNb éléments de type Array7Int
   return  grid;
}
 
// Méthode 2 : array<array<int,5>,7>
#include <array> // array<array<int,...>,...>
 
int main(int argc, char *argv[])
{
  QCoreApplication qca(argc, argv);
 
  int i,j;
 
  // Variables à déclarer constantes
  const int  rowsNb = 5;
  const int  colsNb = 7;
 
  // Syntaxe
  int  *M1 [7];       // tableau de 7 pointeurs de int
  int (*M2)[7];       // pointeur de tableaux de 7 int
  int  n  = 5;        // acquisition de la valeur de n
  M2 = new int[n][7]; // allocation d'un tableau de n tableaux de 7 int
  // Avoid warning compiler
  for (i = 0 ; i < 7 ; ++i)
    M1[i] = NULL;
 
  // Méthode 1 : typedef
  Array7Int*  grid1 = myfunction(5); // myfunction(5) retourne un int(*)[7] qui a 5 éléments
  grid1[4][6] = 1;
 
  // Méthode 2 : std::array<std::array<int,5>,7>
  using Grid57 = array<array<int,7>,5>; // Sans doute équivalent à typedef array<array<int,5>,7> Grid75;
  Grid57  grid2;           // pas d'allocation dynamique, peut être copié, et transmis et reçu de fonction
  grid2[4][6] = 2;        // mais moment de la destruction inconnue
 
  // Méthode 3 : Sans using
  array<array<int,7>,5> grid3;
  grid3[4][6] = 3;
 
  // Méthode 4 : Sans appel de fonction
  int (*grid4)[colsNb] = new int[rowsNb][colsNb];
 
  for (int i = 0 ; i < rowsNb ; ++i)
    for (int j = 0 ; j < colsNb ; ++j)
      grid4[i][j] = 0;
 
  grid4[4][6] = 4;
 
  // Méthode 5 : Avec appel de fonction - rowsNb et colsNb fixes
  int (*grid5)[colsNb];
 
  function1(&grid5);
 
  // Méthode 6 : Avec appel de fonction - rowsNb et colsNb variables
  int (*grid6)[colsNb];
 
  function2(&grid6,rowsNb,colsNb);
 
  // Méthode 7 :  Avec using et appel de fonction - rowsNb et colsNb variables
  using GridRC = array<array<int,rowsNb>,colsNb>;
  int (*grid7)[colsNb];
 
  function2(&grid7,rowsNb,colsNb);
 
  // Affichage des grid
  for (               i = 0 ; i < rowsNb ; ++i)
    for (j = 0 ; j < colsNb ; ++j , printf("\n"))
      printf("%d ",grid1[i][j]);
 
  for (printf("\n") , i = 0 ; i < rowsNb ; ++i)
    for (j = 0 ; j < colsNb ; ++j , printf("\n"))
      printf("%d ",grid2[i][j]);
 
  for (printf("\n") , i = 0 ; i < rowsNb ; ++i)
    for (j = 0 ; j < colsNb ; ++j , printf("\n"))
      printf("%d ",grid3[i][j]);
 
  for (printf("\n") , i = 0 ; i < rowsNb ; ++i)
    for (j = 0 ; j < colsNb ; ++j , printf("\n"))
      printf("%d ",grid4[i][j]);
 
  for (printf("\n") , i = 0 ; i < rowsNb ; ++i)
    for (j = 0 ; j < colsNb ; ++j , printf("\n"))
      printf("%d ",grid5[i][j]);
 
  for (printf("\n") , i = 0 ; i < rowsNb ; ++i)
    for (j = 0 ; j < colsNb ; ++j , printf("\n"))
      printf("%d ",grid6[i][j]);
 
  // Ne pas oublier
  delete [] grid1;
  // delete [] grid2; // Sans doute effectué lorsque la variable n'est pas plus utilisée dans la fonction appelante.
  // delete [] grid3; // Sans doute effectué lorsque la variable n'est pas plus utilisée dans la fonction appelante.
  delete [] grid4;
  delete [] grid5;
  delete [] grid6;
 
  return qca.exec();
}

[Nauvisse]

J'ai trouvé.

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
 
#include <cassert>     // assert
 
typedef long long int     ent;
typedef long double       real;
 
template <class T>
List<T>::List(ent aSize)
{
  assert(aSize >= 0);
  _size = aSize;
  if (_size)
    _list = new T[aSize];
  else
    _list = (T*)0;
  for (ent i = 0 ; i < _size ; ++i)
    _list[i] = (T)0;
}
 
template <class T>
List<T>::~List(void)
{
  if (_list)
    delete [] _list;
}
 
template <class T>
T& List<T>::operator[](ent indexNb)
{
  assert(indexNb >= 0 && indexNb < _size);
  return _list[indexNb];
}
 
template <class T>
List<T>& List<T>::operator<<(const T& element)
{
  T* newList = new T[_size + 1];
  for (ent i = 0 ; i < _size ; ++i)
    newList[i] = _list[i];
  if (_list)
    delete [] _list;
  _list = newList;
  _list[_size++] = element;
  return *this;
}

puis :

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
 
  List<real> toto1 = List<real>(3);
 
  toto1[0] = 1.L; toto1[1] = 2.L; toto1[2] =  3.L;
 
  List<List<real> > toto2 = List<List<real> >(3);
 
  toto2[0] << 1.L << 2.L <<  3.L;
  toto2[1] << 4.L << 5.L <<  6.L <<  7.L;
  toto2[2] << 8.L << 9.L << 10.L << 11.L << 12.L;
 
  List<List<real> > toto3 = List<List<real> >(3);
 
  for (int i = 0 ; i < 3 ; ++i)
    toto3[i] = List<real>(3+i);
  toto3[0][0] = 1.L; toto3[0][1] = 2.L; toto3[0][2] =  3.L;
  toto3[1][0] = 4.L; toto3[1][1] = 5.L; toto3[1][2] =  6.L; toto3[1][3] =  7.L;
  toto3[2][0] = 8.L; toto3[2][1] = 9.L; toto3[2][2] = 10.L; toto3[2][3] = 11.L; toto3[2][4] = 12.L;

[dalfab]

On n'est pas du tout sur le bon forum, c'est clairement une version boguée de std::vector<>, version qui n'est ni exception-safe ni copy-safe!
Bien que sur le forum C, je commente en C++.

std::vector<> est la première collection que l'on apprend après std::string. Je t'encourage à te renseigner sur cette collection fondation qui existe depuis les années 80. Pour un tableau dynamique à plusieurs dimensions, ça marchote (non optimal et redimensionnement lourd, mais en effet devrait suffire à ton besoin.) et fera au moins aussi bien que la List<>.

Mon exemple réécrit avec std::vector<>(dimensions non constantes et redimensionnables) plutôt que std::array<,> (dimensions fixes).

Code :

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

1
2
3
4
5
6
#include <vector>
int  main() {
   using Grid = std::vector<std::vector<int>>;
   Grid  grid( 7, std::vector<int>(5) );             // allocation dynamique, peut être copié, et transmis et reçu de fonction
   grid[6][4] = 42;
}

[Nauvisse]

Merci beaucoup. Et effectivement, je m'oriente un peu plus vers une solution C++.

A cet égard, lorsque je fais

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
 
typedef long long int     ent;
typedef long double       real;
 
template <class T>
List<T>::List(ent aSize)
{
  assert(aSize >= 0);
  _size = aSize;
  if (_size)
    _list = new T[aSize];
  else
    _list = (T*)0;
  for (ent i = 0 ; i < _size ; ++i)
    _list[i] = (T)0;
printf("Construction TAILLE de List %p ayant _list %p\n",this,_list);
}
 
template <class T>
List<T>::~List(void)
{
  if (_list)
    delete [] _list;
printf("Destruction \t    de List %p ayant _list %p\n",this,_list);
}

puis :

Code :

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

1
2
 
  List<List<int>> grid8 = List<List<int>>(3);

J'aperçois :
- 3 constructions de petites listes ;
- puis 3 fois de suite : 1 construction suivie d'1 destruction (l'adresse retournée de List ressemble aux autres adresses de liste de liste mais l'adresse de _list est NULL) ;
- puis 1 construction de la grosse liste.

Savez-vous pourquoi y a-t-il 3 fois de suite 1 construction suivie d'1 destruction svp ?

[Nauvisse]

Ca y est. J'ai trouvé. J'ai remarqué une option du deboggeur (F11 avec Qt Creator) qui me permet de rentrer dans chaque ligne du code. J'ai ainsi compris à quel moment il construisait et détruisait les objets.

Merci de votre aide à tous.