C ANSI allocation dynamique de tableau

Ce petit pro beug en sortie, pourquoi et que faire ?


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

int (*pi)[1][1]; /* pointeur sur un tableau d'entiers */

void main(void)
{
unsigned int taille; /* taille du tableau (non connue
à la compilation). */
int i, j;
printf("Entrez la taille du tableau : ");
scanf("%u",&taille);
pi = (int (*)[1][1]) malloc(taille * sizeof(int)*1*1);

for(i=0; i<(((int)taille)*1); i++)
{
for(j=0; j<(((int)taille)*1); j++)
{
*(pi[i][j]) = 0;
}
}

for(i=0; i<(((int)taille)*1); i++)
{
for(j=0; j<(((int)taille)*1); j++)
{
printf("%d\t", *(pi[i][j]));
}
printf("\n");
}

/* libere le pointeur */
free(pi);
}

tu cherches a faire quoi la???? une allocation dynamique d'un tabeau a 2 dimensions??? Si oui (c'est du C++, il te reste plus qu'a adapter) :

template <class T> T** CIM<T>::Alloue(int nbl,int nbc)
{
const type_info& typeInfo=typeid(T);
const char* nomType=typeInfo.name();

cout << "Type de donnees : " << nomType << endl;
getchar();

if (nbl == 0 || nbc ==0)
return (T **)0;

image = new T * [nbl];
if (image == 0)
{
cout << "Echec lors de l'allocation memoire!!!" << endl;
return (T **)0;
}
for (int i=0;i<nbl;i++)
{
image[i] = new T [nbc];
if (image[i] == 0)
{
for (int j=0;j<i;j++)
{
delete[] image[j];
delete[] image;
cout << "Echec lors de l'allocation memoire!!!" << endl;
return (T **)0;
}
}
}

printf("Allocation memoire de %d octets reussie.\n",nbl*nbc*sizeof(T));

return image;
}

template <class T> void CIM<T>::Desalloue(int nbl)
{
if (image != NULL)
{
for (int i=0;i<nbl;i++)
delete[] image[i];
delete[] image;
image = NULL;

cout << "Desallocation de " << nbl*NBC*sizeof(T) << " octets.\n" << endl;
}
else
cout << "Memoire deja desallouee!!!" << endl;
}

C'est des methodes d'une classe template, faut pas que ca t'effraie : tu t'interesses aux new et aux delete (remplaces par malloc et delete ...)



-------------------------------
Réponse au message :
-------------------------------

> Ce petit pro beug en sortie, pourquoi et que faire ?
>
>
> #include <stdio.h>
> #include <stdlib.h>
>
> int (*pi)[1][1]; /* pointeur sur un tableau d'entiers */
>
> void main(void)
> {
> unsigned int taille; /* taille du tableau (non connue
> à la compilation). */
> int i, j;
> printf("Entrez la taille du tableau : ");
> scanf("%u",&taille);
> pi = (int (*)[1][1]) malloc(taille * sizeof(int)*1*1);
>
> for(i=0; i<(((int)taille)*1); i++)
> {
> for(j=0; j<(((int)taille)*1); j++)
> {
> *(pi[i][j]) = 0;
> }
> }
>
> for(i=0; i<(((int)taille)*1); i++)
> {
> for(j=0; j<(((int)taille)*1); j++)
> {
> printf("%d\t", *(pi[i][j]));
> }
> printf("\n");
> }
>
> /* libere le pointeur */
> free(pi);
> }
>

faut a voir declare un **image quelquepart!!!



-------------------------------
Réponse au message :
-------------------------------

> tu cherches a faire quoi la???? une allocation dynamique d'un tabeau a 2 dimensions??? Si oui (c'est du C++, il te reste plus qu'a adapter) :
>
> template <class T> T** CIM<T>::Alloue(int nbl,int nbc)
> {
> const type_info& typeInfo=typeid(T);
> const char* nomType=typeInfo.name();
>
> cout << "Type de donnees : " << nomType << endl;
> getchar();
>
> if (nbl == 0 || nbc ==0)
> return (T **)0;
>
> image = new T * [nbl];
> if (image == 0)
> {
> cout << "Echec lors de l'allocation memoire!!!" << endl;
> return (T **)0;
> }
> for (int i=0;i<nbl;i++)
> {
> image[i] = new T [nbc];
> if (image[i] == 0)
> {
> for (int j=0;j<i;j++)
> {
> delete[] image[j];
> delete[] image;
> cout << "Echec lors de l'allocation memoire!!!" << endl;
> return (T **)0;
> }
> }
> }
>
> printf("Allocation memoire de %d octets reussie.\n",nbl*nbc*sizeof(T));
>
> return image;
> }
>
> template <class T> void CIM<T>::Desalloue(int nbl)
> {
> if (image != NULL)
> {
> for (int i=0;i<nbl;i++)
> delete[] image[i];
> delete[] image;
> image = NULL;
>
> cout << "Desallocation de " << nbl*NBC*sizeof(T) << " octets.\n" << endl;
> }
> else
> cout << "Memoire deja desallouee!!!" << endl;
> }
>
> C'est des methodes d'une classe template, faut pas que ca t'effraie : tu t'interesses aux new et aux delete (remplaces par malloc et delete ...)
>
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > Ce petit pro beug en sortie, pourquoi et que faire ?
> >
> >
> > #include <stdio.h>
> > #include <stdlib.h>
> >
> > int (*pi)[1][1]; /* pointeur sur un tableau d'entiers */
> >
> > void main(void)
> > {
> > unsigned int taille; /* taille du tableau (non connue
> > à la compilation). */
> > int i, j;
> > printf("Entrez la taille du tableau : ");
> > scanf("%u",&taille);
> > pi = (int (*)[1][1]) malloc(taille * sizeof(int)*1*1);
> >
> > for(i=0; i<(((int)taille)*1); i++)
> > {
> > for(j=0; j<(((int)taille)*1); j++)
> > {
> > *(pi[i][j]) = 0;
> > }
> > }
> >
> > for(i=0; i<(((int)taille)*1); i++)
> > {
> > for(j=0; j<(((int)taille)*1); j++)
> > {
> > printf("%d\t", *(pi[i][j]));
> > }
> > printf("\n");
> > }
> >
> > /* libere le pointeur */
> > free(pi);
> > }
> >
>

pi = (int ***)malloc(taille * sizeof(*pi));

ca c'est vraiment n'importe quoi nEUrOne!



-------------------------------
Réponse au message :
-------------------------------

> pi = (int ***)malloc(taille * sizeof(*pi));