Discussion :

[littlesquall]

Bonjour,

je recherche un peu d'aide quant à la création d'une matrice dynamique.
Voila dans une fonction, je lis dans un .txt un grand vecteur de 220500 termes, et quand je détecte qq chose, j'incrémente une valeur; jusque là c'est basic...

mais ce que je voudrai faire c que tjrs dans ma boucle for, dès que je détecte un signal et que j'incrémente mon compteur, je voudrait allouer dynamiquement une colonne de la matrice.

Comment je dois faire pour créer une colonne ?? sachant que je n'ai pas le définir un tableau à 2 dimensions avec les colonnes à 0 ...

Merci de votre aide !!

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
 
int input_vector[Fs*acquisition_time];
int *p_input_vector;
p_input_vector=input_vector;
int i,j,k,l,m,n,o;
int impulse_number=0;
 
//Ici j'ouvre mon fichier .txt
 
 
//Détection du nombre d'impulsions
for(i=0; i<Fs*acquisition_time; i++)
{
       if(abs(input_vector[i])>seuil_detection)
       {
	if(i+2000<Fs*acquisition_time && i>200)
	{
	         impulse_number++;
                         // j'ai détecté un signal et j'incrémente mon compteur
 
                        // ICI j'aimerai donc allouer une colonne d'une matrice    
                           dans laquelle je v pouvoir recoipier le signal
 
	j=i-200;
 
	if(impulse_number==0)
	{
		printf("Il n'y a aucune impulsion détectée...\n");
	}
	then
	{
 
	int impulse_matrix[impulse_time][impulse_number];

[leptityugi]

je n'ai pas bien compris ton probleme tu veut alouer dynamiquement un tableau??

de plus je n'ai pas compris cette phrase:

Comment je dois faire pour créer une colonne ?? sachant que je n'ai pas le définir un tableau à 2 dimensions avec les colonnes à 0 ...

[AxldenieD]

pour définir un tableau dynamic, il faut utiliser la fonction malloc

exemple

tu veux définir un tableau dont tu ne connais pas la taille (je le fais pour un tableau à une dimension tu extrapolera pour un tableau à 2 dimensions)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   //declaration du pointeur qui servira à la construction du tableau
   //on considère le tableau remplit d'entiers
   int *ptr;
   int l=50; //variable définissant la taille du tableau
   //creation du tableau :
   ptr=malloc(sizeof(int)*l);
   //le tableau est créé et son accès se fais comme tout autre tableau
   return 0;
}

A savoir que tu n'a pas le droit de faire des déclarations de variables ou tu veux dans ton code il faut les faire en début de programme
voila esperant t'avoir éclairé un peu

[Skyounet]

pour définir un tableau dynamic, il faut utiliser la fonction malloc

exemple

tu veux définir un tableau dont tu ne connais pas la taille (je le fais pour un tableau à une dimension tu extrapolera pour un tableau à 2 dimensions)

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
//declaration du pointeur qui servira à la construction du tableau
//on considère le tableau remplit d'entiers
int *ptr;
int l=50; //variable définissant la taille du tableau
//creation du tableau :
ptr=malloc(sizeof(int)*l);
//le tableau est créé et son accès se fais comme tout autre tableau
return 0;
}

A savoir que tu n'a pas le droit de faire des déclarations de variables ou tu veux dans ton code il faut les faire en début de programme
voila esperant t'avoir éclairé un peu

De plus tu a oublie le free qui va bien (c'est vrai que la ce sera fait tout seul a la fin du main mais le free c'est une bonne habitude a prendre...)

[gentil_robot]

A savoir que tu n'a pas le droit de faire des déclarations de variables ou tu veux dans ton code il faut les faire en début de programme

Ca veut dire quoi en "début de programme" ?

C'est en début de bloc (d'accolades) que ca doit se faire.

[Emmanuel Delahaye]

Comment je dois faire pour créer une colonne ?? sachant que je n'ai pas le définir un tableau à 2 dimensions avec les colonnes à 0 ...

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
 
int input_vector[Fs*acquisition_time];
int *p_input_vector;
p_input_vector=input_vector;
int i,j,k,l,m,n,o;
int impulse_number=0;
 
//Ici j'ouvre mon fichier .txt
 
 
//Détection du nombre d'impulsions
for(i=0; i<Fs*acquisition_time; i++)
{
       if(abs(input_vector[i])>seuil_detection)
       {
	if(i+2000<Fs*acquisition_time && i>200)
	{
	         impulse_number++;
                         // j'ai détecté un signal et j'incrémente mon compteur
 
                        // ICI j'aimerai donc allouer une colonne d'une matrice    
                           dans laquelle je v pouvoir recoipier le signal
 
	j=i-200;
 
	if(impulse_number==0)
	{
		printf("Il n'y a aucune impulsion détectée...\n");
	}
	then
	{
 
	int impulse_matrix[impulse_time][impulse_number];

Une matrice creuse ?

Un tableau de pointeurs

Statique :

Code :

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

T *a[N];

Dynamique :

Code :

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

T **a = malloc (N* sizeof *a);

Tous les pointeusrs sont forcés à NULL.

Ensuite, tu alloues les lignes selon tes besoins :

Code :

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

1
2
3
  a[x] = malloc (sizeof *a[x]* n);
<...> 
  a[y] = malloc (sizeof *a[y]* m);

Prévoir un mécanisme de sentinelle, ou alors garder la taille en mémoire. Dans ce cas, une structure s'impose :

Code :

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

1
2
3
4
5
6
 
struct tab_dyn
{
   T *p;
   size_t n;
};

et le tableau qui va avec :

Statique :

Code :

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

struct tab_dyn *a[N];

Dynamique :

Code :

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

struct tab_dyn **a = malloc (N* sizeof *a);

(Observer au passage la maintenance réduite malgré le changement de type...)

[semaj_james]

si tu veux créer des tableaux à 2 dimensions tu peux faire;

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
 
// Matrice Rectangulaire Dynamique (mrd)
// allocation dynamique d'une matrice de taille (nbl, nbc)
 
#define composante int
typedef composante *mat_dyn;   //tableau d'entier
 
mat_dyn alloc_mrd(int nbl,int nbc)
 {return((mat_dyn)malloc((nbl)*nbc*sizeof(composante)));}
 
/* macro permettant d'acceder a l'element en ligne l et 
colonne c par m[l*nbc+c] */
#define adr_mrd(l,c,nbc) ((l)*(nbc)+(c))  
 
 
int main(void)
{
mat_dyn matrice;
 
matrice=alloc_mrd(ligne,colonne);  
matrice[adr_mrd(i,j,colonne)]=0;
 
return 0;
}

[littlesquall]

merci pour toutes vos réponses !!

c vrai que je me suis mal exprimé sur ma dernière phrase.
Je peux déclarer une matrice à deux dimensions dont je connais uniquement le nombre de lignes (2201), mais mais c'est ma boucle "for" qui me donne le nombre de colonnes...

Ce que je pensais faire c'est créer dynamiquement un tableau à 2 dimensions en définissant le nombre de lignes.
Et dès que j'incrémente mon compteur, je créé une colonne de ma matrice ainsi de suite.

J'ai essayé avec des malloc mais quand j'arrive à la derniere colonne de mon tableau, il me la garde nickel mais m'a remplacé toutes mes colonnes précédentes.

Vous voyez ce que je veux dire ?

Je cherche donc un moyen d'ajouter une colonne à chaque fois que j'incrémente mon compteur, mais sans perdre l'information déjà trouvée sur les colonnes précédentes... c'est trodu...lol


Merci d'avance

[Emmanuel Delahaye]

Vous voyez ce que je veux dire ?

Pas du tout. Poste ton code.

[pcaboche]

J'ai essayé avec des malloc mais quand j'arrive à la derniere colonne de mon tableau, il me la garde nickel mais m'a remplacé toutes mes colonnes précédentes.

C'est normal. Un malloc t'allouera un nouveau tableau en mémoire. Si tu veux que tes valeurs précédentes soient recopiées, il faut utiliser la fonction realloc :

void *realloc(void *ptr, size_t size);

realloc() changes the size of the memory block pointed to
by ptr to size bytes. The contents will be unchanged to
the minimum of the old an new sizes; newly allocated mem-
ory will be uninitialized. If ptr is NULL, the call is
equivalent to malloc(size); if size is equal to zero, the
call is equivalent to free(ptr). Unless ptr is NULL, it
must have been returned by an earlier call to malloc(),
calloc() or realloc().

Par contre, à chaque augmentation de taille du tableau, tes valeurs précédentes vont être recopiées (il faut en tenir compte pour les performances)

Maintenant, est-ce que tu as un réel besoin de tout faire en C? Parce qu'en C++, tu as un certain nombre de conteneurs standards dans la STL (listes, tableaux dynamiques, maps...)

[littlesquall]

Pour le code, je l'ai déjà posté au tout premier post...

sinon oui g bien utilisé le realloc mais certainement mal en fait.
Je vais revoir ça avec les conseils que vous m'avez donné !

[pcaboche]

Exemple d'utilisation de realloc sur un tableau d'entiers :

Code :

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

1
2
3
4
int * tab ;
...
 
tab = (int*) realloc(tab, sizeof(int) * nouvelle_taille );

Sinon, tu as les vectors du C++:

Code :

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

1
2
3
4
5
6
7
8
9
#include <vector>
using namespace std ;
 
...
 
vector<int> tab ;
...
 
tab.push_back(unEntier) ;

[Emmanuel Delahaye]

Exemple d'utilisation de realloc sur un tableau d'entiers :

Code :

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

1
2
3
int * tab ;
...
tab = (int*) realloc(tab, sizeof(int) * nouvelle_taille );

C'est quoi ce cast ? D'autre part, realloc() peut échouer. Il convient de ne pas se précipiter...

http://emmanuel-delahaye.developpez....es.htm#realloc

[pcaboche]

C'est quoi ce cast ? D'autre part, realloc() peut échouer. Il convient de ne pas se précipiter...

Le question que je me pose, c'est: pourquoi vous ne faites pas de cast avec un malloc, realloc, calloc?

En effet, malloc, realloc et calloc renvoient un void*, qu'il est normalement nécessaire de caster dans le type de la variable alloué.

Ensuite, il est vrai que le realloc peux échouer. Dans ce cas, il renverra NULL (realloc renverra également NULL si la nouvelle taille est égale à 0). Il faut donc tester la variable:

Code :

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

1
2
3
4
5
6
7
tab = (int*) realloc(tab, sizeof(int) * nouvelle_taille );
 
if (tab == NULL) {
  // erreur
} else {
  ...
}

[gl]

C'est quoi ce cast ? D'autre part, realloc() peut échouer. Il convient de ne pas se précipiter...

Le question que je me pose, c'est: pourquoi vous ne faites pas de cast avec un malloc, realloc, calloc?

En effet, malloc, realloc et calloc renvoient un void*, qu'il est normalement nécessaire de caster dans le type de la variable alloué.

En C le cast entre void* et un autre type pointeur est implicite, le cast n'est donc pas necessaire.

Ensuite, il est vrai que le realloc peux échouer. Dans ce cas, il renverra NULL (realloc renverra également NULL si la nouvelle taille est égale à 0). Il faut donc tester la variable:

Code :

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

1
2
3
4
5
6
7
tab = (int*) realloc(tab, sizeof(int) * nouvelle_taille );
 
if (tab == NULL) {
  // erreur
} else {
  ...
}

Et ne pas utiliser le meme pointeur avant et apres la reallocation afin de pouvoir retomber sur nos pieds en cas d'echec et pouvoir liberer ce qui a deja ete alloue, c'est a dire :

Code :

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

tab2 = realloc(tab1, sizeof(int) * nouvelle_taille );

PS : au passage je te conseille dans les allocations de ne pas utiliser sizeof(int) mais plutot sizeof(*tab) ce qui est equivalent si tab est un int* et beaucoup plus simple a maintenir le jour ou tab change de type.

[Emmanuel Delahaye]

Le question que je me pose, c'est: pourquoi vous ne faites pas de cast avec un malloc, realloc, calloc?

Huh ? Pourquoi faire ?

En effet, malloc, realloc et calloc renvoient un void*, qu'il est normalement nécessaire de caster dans le type de la variable alloué.

Gni ? Qui a dit ça ? La norme au contraire dit que la conversion T* vers void * et inversement est implicte et définie. Aucun cast n'est nécessaire.

http://emmanuel-delahaye.developpez....tes.htm#malloc

Ensuite, il est vrai que le realloc peux échouer. Dans ce cas, il renverra NULL (realloc renverra également NULL si la nouvelle taille est égale à 0). Il faut donc tester la variable:

Code :

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

1
2
3
4
5
6
7
tab = (int*) realloc(tab, sizeof(int) * nouvelle_taille );
 
if (tab == NULL) {
  // erreur
} else {
  ...
}

C'est plus grave que ça. Visiblement, tu n'as pas lu mon lien...

bis:

http://emmanuel-delahaye.developpez....es.htm#realloc

[pcaboche]

Justement, extrait de
http://emmanuel-delahaye.developpez....tes.htm#malloc :

Il est techniquement possible, à de rares exceptions syntaxiques près, de faire compiler du code C par un compilateur C++. Néanmoins, cette pratique est rarement justifiée et est largement déconseillée.

En effet, en dehors des points syntaxiques évidents (comme par exemple la conversion de type explicite void* <-> type* qui justement oblige à utiliser le cast) ...

Il n'est pas rare que je me retrouve à compiler du C avec un compilateur C++. Maintenant, dans pareille situation, je vais pas m'amuser à tout réécrire pour que tout soit 100% C++ non plus ! D'ailleurs, si tu veux que ton code soit réutilisable par un programmeur C++, alors il faudra effectivement faire un cast, donc c'est un peu une habitude que j'ai prise de le faire systématiquement.

Pour ce qui est du sizeof(*tab) au lieu du sizeof(int), vous avez tout à fait raison, je suis allé un peu vite en besogne. Pareil pour ce qui est de la déclaration d'une variable suplémentaire pour pouvoir retomber sur nos pattes en cas de problèmes.

Maintenant, mon but au départ c'était d'aider littlesquall a résoudre son problème de tableau dynamique. C'est pourquoi je lui ai parlé de la fonction realloc afin de ne pas perdre la trace des éléments précédents (c'est quand même la moindre des choses!). Ensuite, j'ai essayé de donner un exemple à littlesquall puisque ce dernier avait des difficultés à utiliser la fonction realloc.

Enfin, j'ai demandé à littlesquall si il y avait une contrainte technique qui l'obligeait à faire du C "pur", ou si il pouvait utiliser les conteneurs standards du C++. Auquel cas, cela lui faciliterait grandement la vie je pense (notamment concernant la gestion des allocation de mémoire) et il pourrait se concentrer sur la résolution de son problème plutôt que de savoir si dans la norme ISO C-99 il faut faire un cast ou pas !

C'est plus grave que ça. Visiblement, tu n'as pas lu mon lien...

Oui, mais toi t'as pas lu la question de littlesquall, alors...