Discussion :

[RyuKa]

Bonjour,

je vous explique mon problème.
J'ai un tableau 2D de float et j'utilise des fonctions qui utilisent des vecteurs 1D de float.

Code :

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

float** h_Data_2D = (float **)malloc(pix_y*sizeof(float*));

Comme le tableau 2D n'est jamais que des vecteurs 1D mis bout à bout en mémoire, je me suis dit que je pouvais allouer un vecteur 1D de même taille et le faire pointer sur le premier élément du tableau 2D.

Code :

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

1
2
	float* h_Data = (float *)malloc(pix_x*pix_y*sizeof(float));
	h_Data = &h_Data_2D[0][0];

Bien sur, ça ne marche pas, mais je ne vois pas comment faire.

Je sais ré-écrire un tableau 2D dans un vecteur 1D, mais le but est justement d'utiliser les pointeurs pour ne rien ré-écrire et gagner du temps.

Est-ce possible ? Si oui, comment faire ?

Merci d'avance !

RyuKa

[Lucien63]

Ton tableau 2D n'est pas un tableau 2D voir Faq

Tu as une fuite mémoire sur la zone pointé par h_Data
Tu alloues une zone mémoire et ensuite tu fait pointer ton pointeur ailleurs.

[RyuKa]

Oui effectivement j'ai pris une ligne qui n'avait pas été modifié correctement ...

Code :

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

float** h_Data_2D = (float **)malloc(pix_y*sizeof(float*));

Et plus loin j'avais bien :

Code :

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

1
2
3
4
	for (int nj = 0; nj <pix_y; nj++)
	{
		h_Data_2D[nj]=(float *)malloc(pix_x*sizeof(float));
}

Et sinon je n'ai pas compris ton message.
Est-ce possible ou pas d'utiliser un pointeur 1D pour pointer sur un tableau 2D ? Il ne faut pas l'allouer pour ça ?

[souviron34]

Bien sur, ça ne marche pas, mais je ne vois pas comment faire.

mettre les parenthèses au bon endroit

[RyuKa]

Donc j'en déduis que c'est possible mais que je ne m'y prend pas correctement.

h_Data = &(h_Data_2D[0][0]); ne fonctionne pas ...

[Lucien63]

Est-ce possible ou pas d'utiliser un pointeur 1D pour pointer sur un tableau 2D ?

Oui, mais attention les blocs ne sont pas contigues dans le cas d'une allocation comme tu la faites.

Il ne faut pas l'allouer pour ça ?

non

h_Data = &(h_Data_2D[0][0]); ne fonctionne pas ...

Qu'est ce qui ne fonctionne pas ? (les parentaises ne sont pas utiles.)

[diogene]

Comme le dit Lucien63, les données doivent former un seul bloc et tu dois l'allouer de cette façon.
Par exemple:

Code :

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

1
2
3
4
5
6
7
8
   float * h_Data;  
   float** h_Data_2D = malloc(pix_y*sizeof * h_Data_2D );
   h_Data = h_Data_2D[0] = malloc(pix_x*pix_y*sizeof *h_Data);
   // mise à jour des autres pointeurs :
   for(i=1; i<pix_y; i++)  h_Data_2D[i]= h_Data_2D[i-1]+ pix_x;
....
   h_Data_2D[2][3] = 3.1416;
   h_Data[2*pix_x+3] = 3.1416;

[RyuKa]

Je ne peux pas faire ça, mon tableau est alloué et rempli au début du programme et mes autres fonctions qui nécessitent du 1D n'interviennent que plus tard.

J'ai des résultats incohérents malgrès tous mes essais. Et la fonction marche bien si je réécri le tableau en 1D : (

EDIT : ceci fonctionne

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
void mafonction(float** h_Data_2D,int pix_y,int pix_x)
{
	float* h_Data = (float *)malloc(pix_x*pix_y*sizeof *h_Data);
	for (int y=0;y<pix_y;y++)
	{
		for(int x=0;x<pix_x;x++)
		{
			h_Data[x+y*pix_x]=h_Data_2D[y][x];
		}
	}
 
             free(h_Data);
	FILE* Fichier_image5;
	Fichier_image5 = check_filename("output_data.raw","wb");
	fwrite( h_Data, sizeof(float), pix_y * pix_x, Fichier_image5);
}

mais je voudrais éviter de ré-écrire quoi que ce soit, et je ne peux pas toucher à l'allocation de mon tableau 2D (en paramètres de cette fonction).

[diogene]

Tu n'as pas le choix : l'allocation telle que tu l'as faite ne permet pas de l'assimiler à un tableau 1D.

Dans le code que je t'ai proposé, seule est à changer l'allocation initiale du tableau. Le reste du code, excepté la désallocation et si il y a lieu les réallocations, utilisant le tableau 2D est inchangé ().

mais je voudrais éviter de ré-écrire quoi que ce soit...

On n'a rien sans un minimum d'effort (et ici il est vraiment minimum)

je ne peux pas toucher à l'allocation de mon tableau 2D

Il y a une raison de fond ?

[RyuKa]

de fond non, c'est juste que mes différentes fonctions s'intègrent à un programme plus grand (fais il y a longtemps) et que lui est entièrement écrit pour des tableaux 2D, et il m'est impossible d'ecrire mes fonctions en 2D (ici la raison est l'utilisation de librairie particulière).

Citation:
mais je voudrais éviter de ré-écrire quoi que ce soit...

On n'a rien sans un minimum d'effort (et ici il est vraiment minimum)

Non quand je disais ré-écrire, je parlais de ré-écrire les données du tableau 2D dans un vecteur, comme mon code ci-dessus, pas la programmation en elle même

[diogene]

de fond non, c'est juste que mes différentes fonctions s'intègrent à un programme plus grand (fais il y a longtemps) et que lui est entièrement écrit pour des tableaux 2D, et il m'est impossible d'ecrire mes fonctions en 2D (ici la raison est l'utilisation de librairie particulière).

Le tableau construit de la façon que je t'ai proposé est entièrement compatible à l'usage avec ton ancien tableau. Les seules modifications à apporter au programme sont
- le code utilisé pour l'allouer évidemment
- le code utilisé pour le détruire (il y a moins de free() à faire) évidemment
- le code utilisé pour le redimensionner si dans ton programme un redimensionnement est prévu.
Si tu n'as pas de redimensionnement dynamique du tableau et si ton code est correctement structuré, c'est minime.

Il est alors utilisable comme un tableau 2D comme h_Data_2D ou sous la forme d'un tableau 1D comme h_Data_2D[0] (ou h_Data dans le code précédent)

[RyuKa]

Je ré-essaierai alors, la premiere fois cela n'avait pas marché.
La boucle sur l'arithmetique de pointeur pour h_Data_2D est à mettre avant l'allocation des "sous-vecteurs" ? (h_Data_2D[n] = (float *)malloc(px_x*sizeof(float)) ou est-ce que ces 2ndes allocations disparaissent ?
Car j'avais aussi éssayé sans ...

Merci en tout cas pour ton aide

[diogene]

Le code est tel que celui écrit plus haut :

1- Allocation d'un tableau de pointeurs

Code :

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

   float** h_Data_2D = malloc(pix_y*sizeof * h_Data_2D );

2- Allocation d'un seul coup de toutes les données ce qui garantit que les données seront toutes consécutives en mémoire (c'est là la différence avec le système d'allocation que tu as utilisé)

Code :

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

   h_Data = h_Data_2D[0] = malloc(pix_x*pix_y*sizeof *h_Data);

3- Mise des adresses de départ des blocs de pix_x float dans le tableau de pointeurs

Code :

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

   for(i=1; i<pix_y; i++)  h_Data_2D[i]= h_Data_2D[i-1]+ pix_x;

Fin de la création du tableau.

Destruction du tableau :

Code :

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

1
2
free(h_Data_2D[0]); // ou free(h_Data );
free(h_Data_2D);

c'est tout.