agrandir une matrice - Page 2

La fonction ne fait que te réserver un espace.
Tu en fais ce que tu veux après.

tiens etudie le code ci dessous , je l'ai fait y'a a peu pres 4 mois

#include <tigcclib.h>
void _main(void)
{
//la ton programme de creation de matrice que tu va enlever une fois ta matrice crée
short taille[3]={3,5,4}; //la taille de ta matrice
char matr[3][5][4]={{"0","1","2","3","4"},{"00","01","02","03","04"},{"000","001","002","003","004"}};//ta matrice
FILE *f = fopen ("matrice", "wb");
if(f==NULL) {ST_helpMsg ("erreur(ptet pas assez de mem)");ngetchx();return;}
fwrite(taille,sizeof(short),3,f); //la on stocke
fwrite(matr, 4*sizeof(char), 15, f);//2 matrice
fputc (0, f);
fputs ("data", f);
fputc (0, f);
fputc (OTH_TAG, f);
fclose (f);
short taille2[3];
//la ton programme qui reste sur la cal
//la ta fonction de lecture
FILE *f2 = fopen ("matrice", "rb");
if(f2==NULL) {ST_helpMsg ("matrice introuvables");ngetchx();return;}
fread(taille2,sizeof(short),3,f2); //la on en
char matr2[taille2[0]][taille2[1]][taille2[2]]; //sort
fread(matr2, taille2[2]*sizeof(char), taille2[0]*taille2[1], f2); //2
fclose (f2);
clrscr();
printf(matr2[2][4]);
ngetchx();

//la ta fonction d'edition
short taille3[3];
FILE *f3 = fopen ("matrice", "rb");
if(f3==NULL) {ST_helpMsg ("matrice introuvables");ngetchx();return;}
fread(taille3,sizeof(short),3,f3);
char matr3[taille3[0]][taille3[1]][taille3[2]];
fread(matr3, taille3[2]*sizeof(char), taille3[0]*taille3[1], f3); //on la sort de son trou....
fclose (f3);
//pour changer un ou plusiurs element de ta matrice ou inverser certains element ou...
strcpy(matr3[0][1],"999"); //on la modifie ...
FILE *f4 = fopen ("matrice", "wb");
if(f4==NULL) {ST_helpMsg ("erreur(ptet pas assez de mem)");ngetchx();return;}
fwrite(taille3,sizeof(short),3,f4);
fwrite(matr3, taille3[2]*sizeof(char), taille3[0]*taille3[1], f4);//et on la remet!
fputc (0, f4);
fputs ("data", f4);
fputc (0, f4);
fputc (OTH_TAG, f4);
fclose (f4);
//maintenant pour modifer la geule de ta matrice
//ex, je veux augmenter le nombre de colonne et diminuer le nombre de ligne(m'en fout si je perd des données)
short taille4[3];
FILE *f5 = fopen ("matrice", "rb");
if(f5==NULL) {ST_helpMsg ("matrice introuvables");ngetchx();return;}
fread(taille4,sizeof(short),3,f5); //la on en
char matr4[taille4[0]][taille4[1]][taille4[2]]; //sort
fread(matr4, taille4[2]*sizeof(char), taille4[0]*taille4[1], f5); //2
fclose (f5);
clrscr();
printf(matr4[0][1]);
ngetchx();

short taille5[3];
short i,j;
for(i=0;i<3;i++)taille5 [ i ] = taille4 [ i ] ;
taille5[1]=6;//mon nouveau nombre de colonne
taille5[0]=2;//mon nouveau nombre de ligne
char matr5[taille5[0]][taille5[1]][taille5[2]];//ma nouvelle matrice (vide pour le moment)

for(i=0;i<taille5[0];i++)
{
for(j=0;j<taille5[1];j++)
{
if(i<taille4[0] && j<taille4[1])
{
strcpy(matr5[ i ][j],matr4[ i ][j]);
}
else strcpy(matr4[ i ][j],"");
}
}
FILE *f6 = fopen("matrice","wb");
if(f6==NULL) {ST_helpMsg ("erreur(ptet pas assez de mem)");ngetchx();return;}
fwrite(taille5,sizeof(short),3,f6);
fwrite(matr5, taille5[2]*sizeof(char), taille5[0]*taille5[1], f6);
fputc (0, f6);
fputs ("data", f6);
fputc (0, f6);
fputc (OTH_TAG, f6);
fclose (f6);
//allez un ptit dernier pour la route
short taille6[3];
FILE *f7 = fopen ("matrice", "rb");
if(f7==NULL) {ST_helpMsg ("matrice introuvables");ngetchx();return;}
fread(taille6,sizeof(short),3,f7);
char matr6[taille6[0]][taille6[1]][taille6[2]];
fread(matr6, taille6[2]*sizeof(char), taille6[0]*taille6[1], f7);
fclose (f7);
clrscr();
for(i=0;i<taille6[0];i++)
{
for(j=0;j<taille6[1];j++)
{
printf(matr6[ i ][j]);
printf(":");
}
printf("\n");
}
ngetchx();
return;
}

fais en des fonctions , se sera mieux

aïe j'avais pas vu mais pour l'agrandissement remlace les && par ||
et qqun pourrait me dire pkoi j'arrive pas a faire ca :
struc ma_structure
{
short c;
short a[c];
};

Parce que ce n'est pas standart.
Tu peux peut-être te débrouiller avec une extensions GNU :
struct ma_structure
{
short c
short a[];
};

Mais la taille indiquée par sizeof(struct ma_struct) sera fausse, et si tu ne pourras pas utiliser de tableau du structures.

Si tu ne veux pas utiliser d'extensions, utilise une taille de 1.
C'est un peu plus chiant par contre, parce qu'il faut retrancher 1 à sizeof(ma_structure) quand tu calcules la taille que tu vas allouer, mais ça marche.

C'est quand même une extension GNU largement supportée (notamment par d'autres compilos pour PC type VC++), et qui est dans le C99...

arg ca je le savais mais ca ne me plaît pas : je veux pile poil la taille que je demande
il faute que je passe par les pointeurs!
mais je pige pas pointeurs&tableaudechar ca m'everve et ca me donne mal a la tête!!!
qu'elle est la bonne solution parmi les suivantes pour faire un tableau : char tabl[3][4][5];3lignes , 4colonnes, 5caracteres
ca :

char ***tabl=NULL;
short i,j;
tabl = calloc (3,sizeof(**table));
for(i=0;i<3;i++)
{
tabl[ i ]=calloc(4,sizeof(*tabl));
for(j=0;j<4;j++)tabl[ i ][j]=calloc(5,sizeof(char));
}

ou bien ca:

char *tabl=calloc(3*4*5,sizeof(char));

ou bien encore une autre solution

juste comme ca,si je le demande c'est parce que je suis tout bonnement incapable de verifier
donc si vous pouviez m'expliquer comment acceder au données du tableau un fois crée ce serait sympa!

La première, surtout pas !
La deuxième à la limite. Mais tu ne pourras pas utiliser la notation [].

pkoi pas la premiere ? j'ai readapté ce qui est ecrit ds la doc tigccc
et la 2e pour voir une donner il faut faire ca pour aller chercher une donnée?

*(tabl+n°colonne+n°ligne) ;
//par exemple tabl[0][1]
printf(*(tabl+0+1));

J'avais pas bien lu pa première, je croyais que tu ne faisais qu'une allocation.
donc en fait, la première marche, mais est fortement déconseillée sur nos TI, parce que le nombre d'allocations est limité.
Mais en fait, si tu as lu la faq de TIGCC, utilise plutôt la dernière méthode qu'ils proposent, elle est nettement plus élégante.

Et pour la deuxièm, pour accéder aux données, réfléchis, la solution que tu as proposée est absurde : comment différencier l'accès à lélément t[0][1] de l'élément t[1][0] ?
Est-ce que tu sais comment est géré un tableau à plusieurs dimensions par le compilateur ?

eu ba ... non
mais je me suis gouré tout a l'heure :
c ca la bonne solution (enfin je l'espere packe quand je la teste ca marche pas vraiment vraiment... )
*(tabl+(n°colonne+n°ligne)*nbdecaractere*sizeof(char)) ;
donc pour le table [1][2]
*(tabl+1*5*sizeof(char)+2*5*sizeof(char));

ca a marché une fois
mais apres la ti me dit systematiquement protected memory violation
qu'est ce qu'il ne va pas?