Mettre plusieurs tableaux 1D dans une matrice

Bonjour à tous,

Existe-t-il une fonction c++ qui peut concaténer plusieurs tableaux en une seule matrice ?

merci d'avance :fleur:

Il y a des dizaines d'implémentation différentes d'une classe matrice, généralement au sein d'une bibliothèque bien plus vaste et qui sont (classe et bibliothèque) pour un certain nombre d'usage.

Donc, ne mettez pas la charrue avant les bœufs.

Analysez vos besoins, déduisez-en les fonctionnalités que doit avoir votre classe matrice.
Faites un référencement des bibliothèques qui ont ce type de classe.
Sélectionnez la bibliothèque ayant le plus de fonctionnalités qui correspondent à vos besoins.
Étendez cette classe matrice, si nécessaire. (Mais, bon, généralement, elles disposent d'une API en béton car déjà utilisées par des centaines de millier d'autres développeurs)

La réponse courte est "pas dans la bibliothèque standard, ni dans le langage".
En effet, il n'y a pas de concept de matrice dans le langage en lui même. Au mieux, un tableau de tableau, mais ca n'est pas du tout ce que tu veux.

Il n'y en a pas non plus dans la bibliothèque standard, car elle ne se préoccupe pas de concept aussi spécifique.

Donc, effectivement, il faut se tourner vers des bibliothèques adaptées, comme on peut par exemple en trouver dans Boost.

A quoi te servirai cette matrice?
N'as-tu pas un constructeur adapté?

Bonjour et merci pour vos réponses,


En fait, je voudrais éviter les deux boucles imbriquées "for" pour remplir la matrice:

Code:

---

1 2 3 4

for(int t=1;t<120;t++) for (int j = 1; j<2048; j++) array2d[t][j] = feats[j];

---

merci à vous :)

Il y a une astuce, si tu remplis l'intégralité du tableau.

Supposons une déclaration telle que int Bidule[N1][N2];.
Bidule est un tableau de N1 tableaux de N2 int.
Les tableaux étant contigüs, la mémoire occupée par Bidule est constitué de N1 blocs consécutifs (sans trou) chacun étant constitués de N2 blocs de la taille d'un int.
Donc, les entiers sont dans N1*N2 blocs contigüs.

Partant de là, l'entier Bidule[7][5] se trouve dans la case 7*N2 + 5.

Donc (&Bidule[0][0] + 7 * N2 + 5) est l'adresse de Bidule[7][5].

mieux, l'indice k dans Bidule vu comme un tableau 1D (&Bidule[0][0]) est le double indice [k/N2][k%N2].

Si jamais ton tableau est déclaré comme un int **Bidule, les N1 sous-tableaux ne sont pas voisins, seuls le sont les pointeurs vers eux (stockés dans le tableau racine)
Le seul cas intermédiaire permettant cela serait un int (*Bidule)[N2] = malloc(N1* N2*sizeof(int));

Code:

---

1 2 3 4 5 6

for (int i=0; i<120*2048; i++) { int t = i/2048, j = i%2048; if (t==0) continue;// (on a sauté le premier t dans ta boucle) if (j==0) continue;// (on a sauté le premier j dans ta boucle) array2d[t][j] = feats[j]; }

---

Mais ton problème serait aussi résolu en utilisant memcpy

Code:

---

1 2 3

for (int t = 1; t < 120; t++) { memcpy(&array2d[t][1], feats, 2047 * sizeof(feats[0]); }

---

Point beaucoup plus important: n'utilise jamais un nombre magique (comme 120 ou 2048), mais une variable/constante/macro de constante ayant cette valeur (comme feats_count)
Chaque fois que tu ne le fais pas, tu prends le risque d'une fuite mémoire, d'une variable non initialisée ou d'un dépassement de buffer, quand la valeur devra changer.
Et surtout, la valeur en elle même est moins importante que sa nature.

Autre question, pourquoi tes boucles ne commence-t-elle pas à 0 quand tu manipules tes tableaux? Le premier élément est-il correctement défini ailleurs?

Pourquoi ne pas avoir une matrice "plate" ? C'est généralement bien mieux et optimisé ainsi.
https://cpp.developpez.com/faq/cpp/?...au-de-tableaux

j'ai zappé qu'on est ici en C++ (c'est ca le soucis d'aider aussi en C).
:aie:

Effectivement, n'utilise pas de tableau brut. Un vecteur plat (linéarisé) dans une petite classe fera très bien le travail.

Par contre, dans ton cas précis, je déconseille un std::array, 120*2048 ca risque de faire un peu beaucoup pour la pile.