Bonsoir j'essaie d'experimenter avec les pointeurs de pointeur et les
tableau a un dimension et je ne comprend pas vraiment pourquoi le petit
bout de code ci dessous fait un seg-fault dans une focntion mais marche
dans le main.
=================================code ==================== >
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
Bonsoir j'essaie d'experimenter avec les pointeurs de pointeur et les
tableau a un dimension et je ne comprend pas vraiment pourquoi le petit
bout de code ci dessous fait un seg-fault dans une focntion mais marche
dans le main.
=================================code ==================== >
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
Bonsoir j'essaie d'experimenter avec les pointeurs de pointeur et les
tableau a un dimension et je ne comprend pas vraiment pourquoi le petit
bout de code ci dessous fait un seg-fault dans une focntion mais marche
dans le main.
=================================code ==================== >
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
Bonsoir j'essaie d'experimenter avec les pointeurs de pointeur et les
tableau a un dimension et je ne comprend pas vraiment pourquoi le petit
bout de code ci dessous fait un seg-fault dans une focntion mais marche
dans le main.
Si quelqu'un a un recapitulatif sur l'utilisation des tableau a n dim et
leur relatin avec les les poiunteur de pointeur je prends...
merci,
O.
=================================code ==================== >
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
/* la non ... Segmentation fault*/
afficheall(t);
return 0;
}
void afficheall(char *** t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
}
Bonsoir j'essaie d'experimenter avec les pointeurs de pointeur et les
tableau a un dimension et je ne comprend pas vraiment pourquoi le petit
bout de code ci dessous fait un seg-fault dans une focntion mais marche
dans le main.
Si quelqu'un a un recapitulatif sur l'utilisation des tableau a n dim et
leur relatin avec les les poiunteur de pointeur je prends...
merci,
O.
=================================code ==================== >
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
/* la non ... Segmentation fault*/
afficheall(t);
return 0;
}
void afficheall(char *** t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
}
Bonsoir j'essaie d'experimenter avec les pointeurs de pointeur et les
tableau a un dimension et je ne comprend pas vraiment pourquoi le petit
bout de code ci dessous fait un seg-fault dans une focntion mais marche
dans le main.
Si quelqu'un a un recapitulatif sur l'utilisation des tableau a n dim et
leur relatin avec les les poiunteur de pointeur je prends...
merci,
O.
=================================code ==================== >
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
/* la non ... Segmentation fault*/
afficheall(t);
return 0;
}
void afficheall(char *** t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
}
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
/* la non ... Segmentation fault*/
afficheall(t);
return 0;
}
void afficheall(char *** t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
/* la non ... Segmentation fault*/
afficheall(t);
return 0;
}
void afficheall(char *** t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *** t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
/* la non ... Segmentation fault*/
afficheall(t);
return 0;
}
void afficheall(char *** t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
Erreur de type.
main.c: In function `main':
main.c:43: warning: passing arg 1 of `afficheall' from incompatible
pointer type
C'est pas char ***, c'est plutôt
#include <stdio.h>
void afficheall (char const *t[][3])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
}
int main (void)
{
int i, j;
char const *t[3][3] > {
{"123", "456", "789"},
{"aze", "rty", "uio"},
{"wxc", "vbn", "jkl"}
};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
afficheall (t);
return 0;
}
Erreur de type.
main.c: In function `main':
main.c:43: warning: passing arg 1 of `afficheall' from incompatible
pointer type
C'est pas char ***, c'est plutôt
#include <stdio.h>
void afficheall (char const *t[][3])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
}
int main (void)
{
int i, j;
char const *t[3][3] > {
{"123", "456", "789"},
{"aze", "rty", "uio"},
{"wxc", "vbn", "jkl"}
};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
afficheall (t);
return 0;
}
Erreur de type.
main.c: In function `main':
main.c:43: warning: passing arg 1 of `afficheall' from incompatible
pointer type
C'est pas char ***, c'est plutôt
#include <stdio.h>
void afficheall (char const *t[][3])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
}
int main (void)
{
int i, j;
char const *t[3][3] > {
{"123", "456", "789"},
{"aze", "rty", "uio"},
{"wxc", "vbn", "jkl"}
};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
afficheall (t);
return 0;
}
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si je
veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
gcc-only je crois (les specialistes te diront de quel standard ca fait
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si je
veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
gcc-only je crois (les specialistes te diront de quel standard ca fait
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si je
veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
gcc-only je crois (les specialistes te diront de quel standard ca fait
none wrote:
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si
je veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
gcc-only je crois (les specialistes te diront de quel standard ca fait
parie) :
int maFonction (void *parData, int parDim1, int parDim2)
{
typedef int Ligne[parDim1];
typedef Ligne Matrice[parDim2];
typedef Matrice *tableauA3Dimensions;
Matrice locMatrice = (Matrice *)parData;
return parData[1][0][5];
}
(en résumé, du typedef dynamique)
Sinon j'en profite pour reprendre ma vieille croisade contre la croyance
"tableau = pointeur", C'EST FAUX!!! Un pointeur s'utilise COMME un
tableau, mais un tableau de pointeur n'est pas equivalent a un tableau
de tableaux.
Dans ton cas, l'erreur vient du fait que tu utilises des tableaux de
pointeurs comme des tableaux de tableaux, or un tableau de tableaux a
quelque chose de plus : les données sont toutes packées dans l'ordre, et
tu peux caster un tableau multidimensionnel en tableau unidimensionnel.
Tu ne peux pas le faire avec un tableau de pointeurs car chaque case du
tableau principal contient non pas une valeur mais un pointeur
je vais tenter le dessin ascii
int **t
t
___
|ptr|->| 1 | 2 | 4 | 7 | 11 ...
|ptr|->| 2 | 8 |...
|ptr|
|ptr|
|ptr|
...
int t[3][3]
___________________________________
| 1 | 2 | 4 | 7 | 11| 18| -1| -2| -3|
-----------------------------------
`---+---' `---+---' `---+---'
t[1] t[2] t[3]
et donc tu peux caster ton tableau en tableau unidimensionnel. Pour
resoudre ton probleme, je te propose le code suivant (que je n'ai pas
teste, car je n'ai pas de compilateur sous la main) :
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
afficheall(&t[0][0]);/*adresse du premier element = adresse du debut
du tableau = char * ATTENTION ca ne marche que si t est un tableau
multidimensionnel!!! pas avec une declaration du type char ***t */
return 0;
}
/* tu peux donner a afficheall la taille d'une ligne
en appelant afficheall(&t[0][0], sizeof(t[0])); la j'ai mis 3 en dur */
/* note l'affichage est peut etre transposé, ou peut etre meme que ca
plante :p */
void afficheall(char *t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*(t+3*i+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
}
none wrote:
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si
je veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
gcc-only je crois (les specialistes te diront de quel standard ca fait
parie) :
int maFonction (void *parData, int parDim1, int parDim2)
{
typedef int Ligne[parDim1];
typedef Ligne Matrice[parDim2];
typedef Matrice *tableauA3Dimensions;
Matrice locMatrice = (Matrice *)parData;
return parData[1][0][5];
}
(en résumé, du typedef dynamique)
Sinon j'en profite pour reprendre ma vieille croisade contre la croyance
"tableau = pointeur", C'EST FAUX!!! Un pointeur s'utilise COMME un
tableau, mais un tableau de pointeur n'est pas equivalent a un tableau
de tableaux.
Dans ton cas, l'erreur vient du fait que tu utilises des tableaux de
pointeurs comme des tableaux de tableaux, or un tableau de tableaux a
quelque chose de plus : les données sont toutes packées dans l'ordre, et
tu peux caster un tableau multidimensionnel en tableau unidimensionnel.
Tu ne peux pas le faire avec un tableau de pointeurs car chaque case du
tableau principal contient non pas une valeur mais un pointeur
je vais tenter le dessin ascii
int **t
t
___
|ptr|->| 1 | 2 | 4 | 7 | 11 ...
|ptr|->| 2 | 8 |...
|ptr|
|ptr|
|ptr|
...
int t[3][3]
___________________________________
| 1 | 2 | 4 | 7 | 11| 18| -1| -2| -3|
-----------------------------------
`---+---' `---+---' `---+---'
t[1] t[2] t[3]
et donc tu peux caster ton tableau en tableau unidimensionnel. Pour
resoudre ton probleme, je te propose le code suivant (que je n'ai pas
teste, car je n'ai pas de compilateur sous la main) :
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
afficheall(&t[0][0]);/*adresse du premier element = adresse du debut
du tableau = char * ATTENTION ca ne marche que si t est un tableau
multidimensionnel!!! pas avec une declaration du type char ***t */
return 0;
}
/* tu peux donner a afficheall la taille d'une ligne
en appelant afficheall(&t[0][0], sizeof(t[0])); la j'ai mis 3 en dur */
/* note l'affichage est peut etre transposé, ou peut etre meme que ca
plante :p */
void afficheall(char *t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*(t+3*i+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
}
none wrote:
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si
je veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
gcc-only je crois (les specialistes te diront de quel standard ca fait
parie) :
int maFonction (void *parData, int parDim1, int parDim2)
{
typedef int Ligne[parDim1];
typedef Ligne Matrice[parDim2];
typedef Matrice *tableauA3Dimensions;
Matrice locMatrice = (Matrice *)parData;
return parData[1][0][5];
}
(en résumé, du typedef dynamique)
Sinon j'en profite pour reprendre ma vieille croisade contre la croyance
"tableau = pointeur", C'EST FAUX!!! Un pointeur s'utilise COMME un
tableau, mais un tableau de pointeur n'est pas equivalent a un tableau
de tableaux.
Dans ton cas, l'erreur vient du fait que tu utilises des tableaux de
pointeurs comme des tableaux de tableaux, or un tableau de tableaux a
quelque chose de plus : les données sont toutes packées dans l'ordre, et
tu peux caster un tableau multidimensionnel en tableau unidimensionnel.
Tu ne peux pas le faire avec un tableau de pointeurs car chaque case du
tableau principal contient non pas une valeur mais un pointeur
je vais tenter le dessin ascii
int **t
t
___
|ptr|->| 1 | 2 | 4 | 7 | 11 ...
|ptr|->| 2 | 8 |...
|ptr|
|ptr|
|ptr|
...
int t[3][3]
___________________________________
| 1 | 2 | 4 | 7 | 11| 18| -1| -2| -3|
-----------------------------------
`---+---' `---+---' `---+---'
t[1] t[2] t[3]
et donc tu peux caster ton tableau en tableau unidimensionnel. Pour
resoudre ton probleme, je te propose le code suivant (que je n'ai pas
teste, car je n'ai pas de compilateur sous la main) :
#include<stdio.h>
#include<stdlib.h>
void afficheall(char *t);
int main(void){
int i,j;
char * t[3][3] ={
{"123","456","789"},
{"aze","rty","uio"},
{"wxc","vbn","jkl"}
};
/* ici Ok */
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*((*(t+i))+j));
/* printf("----%sBn",*t[i]); */
/* printf("------%sBn",*t[j]); */
}
}
afficheall(&t[0][0]);/*adresse du premier element = adresse du debut
du tableau = char * ATTENTION ca ne marche que si t est un tableau
multidimensionnel!!! pas avec une declaration du type char ***t */
return 0;
}
/* tu peux donner a afficheall la taille d'une ligne
en appelant afficheall(&t[0][0], sizeof(t[0])); la j'ai mis 3 en dur */
/* note l'affichage est peut etre transposé, ou peut etre meme que ca
plante :p */
void afficheall(char *t){
int i,j;
for (i=0;i<3;i++){
for (j=0;j<3;j++){
printf("-t,---%sA n",*(t+3*i+j));
// printf("----%sBn",*t[i]);
//printf("------%sBn",*t[j]);
}
}
}
void afficheall (char const *t[][3])
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu ecris
la fonction. Ce qui n'est pas tres modulaire, comment faire si je veux mettre
ma fonction dans module separer.
void afficheall (char const *t[][3])
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu ecris
la fonction. Ce qui n'est pas tres modulaire, comment faire si je veux mettre
ma fonction dans module separer.
void afficheall (char const *t[][3])
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu ecris
la fonction. Ce qui n'est pas tres modulaire, comment faire si je veux mettre
ma fonction dans module separer.
Erreur de type.
main.c: In function `main':
main.c:43: warning: passing arg 1 of `afficheall' from incompatible
pointer type
C'est pas char ***, c'est plutôt
#include <stdio.h>
void afficheall (char const *t[][3])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
}
int main (void)
{
int i, j;
char const *t[3][3] > > {
{"123", "456", "789"},
{"aze", "rty", "uio"},
{"wxc", "vbn", "jkl"}
};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
afficheall (t);
return 0;
}
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si je
veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
Erreur de type.
main.c: In function `main':
main.c:43: warning: passing arg 1 of `afficheall' from incompatible
pointer type
C'est pas char ***, c'est plutôt
#include <stdio.h>
void afficheall (char const *t[][3])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
}
int main (void)
{
int i, j;
char const *t[3][3] > > {
{"123", "456", "789"},
{"aze", "rty", "uio"},
{"wxc", "vbn", "jkl"}
};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
afficheall (t);
return 0;
}
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si je
veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
Erreur de type.
main.c: In function `main':
main.c:43: warning: passing arg 1 of `afficheall' from incompatible
pointer type
C'est pas char ***, c'est plutôt
#include <stdio.h>
void afficheall (char const *t[][3])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
}
int main (void)
{
int i, j;
char const *t[3][3] > > {
{"123", "456", "789"},
{"aze", "rty", "uio"},
{"wxc", "vbn", "jkl"}
};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
{
printf ("'%s'n", t[i][j]);
}
}
afficheall (t);
return 0;
}
Ok mais ca supose que tu connais le bonne du tabeleau au momment ou tu
ecris la fonction. Ce qui n'est pas tres modulaire, comment faire si je
veux mettre ma fonction dans module separer.
La taille du tableau passe en argument n'etant pas connue a priori mais
definie dans le main du fichier principal ?
Voila un exemple de tableau de tableaux écrit en 5 minutes mais sans
plantage et sutout simple !
Alouer en dynamique et variable.
Compiler et tester sur TC2
C'est du C de base portable ,
le fichier "Alloc.h" s'apelle parfois "malloc.h" sur certain compilo.
L'appel du nombre de tableaux est un "int" on pourrait mettre un
long pour une "huge application"
ou des "unsigned int" ou "unsigned long" chacun fera sa propre cuisine...
Un bon exemple vaux mieux qu'un grand discours
#include "stdio.h"
#include "alloc.h"
/* pointeur de tableau de tableau */
/* le seul ,l,ment Global */
/* les tableaux eux mSme sont sur le stack */
char far **TabDeTab;
main()
/* efface l'ecran */
clrscr();
for (t=0 ; t<26; t++) {
memset(TabDeTab[t],65+t,30); /* avec 30 a, b,c, etc.. */
printf("%srn",TabDeTab[t]);
printf("Appuyer sur une touche pour lib,rer la m,moirern");
getchar();
for (i=0 ;i<nbTab; i++)
if( (TabDeTab[i] = malloc(lenTab)) == NULL) return(-1);
Voila un exemple de tableau de tableaux écrit en 5 minutes mais sans
plantage et sutout simple !
Alouer en dynamique et variable.
Compiler et tester sur TC2
C'est du C de base portable ,
le fichier "Alloc.h" s'apelle parfois "malloc.h" sur certain compilo.
L'appel du nombre de tableaux est un "int" on pourrait mettre un
long pour une "huge application"
ou des "unsigned int" ou "unsigned long" chacun fera sa propre cuisine...
Un bon exemple vaux mieux qu'un grand discours
#include "stdio.h"
#include "alloc.h"
/* pointeur de tableau de tableau */
/* le seul ,l,ment Global */
/* les tableaux eux mSme sont sur le stack */
char far **TabDeTab;
main()
/* efface l'ecran */
clrscr();
for (t=0 ; t<26; t++) {
memset(TabDeTab[t],65+t,30); /* avec 30 a, b,c, etc.. */
printf("%srn",TabDeTab[t]);
printf("Appuyer sur une touche pour lib,rer la m,moirern");
getchar();
for (i=0 ;i<nbTab; i++)
if( (TabDeTab[i] = malloc(lenTab)) == NULL) return(-1);
Voila un exemple de tableau de tableaux écrit en 5 minutes mais sans
plantage et sutout simple !
Alouer en dynamique et variable.
Compiler et tester sur TC2
C'est du C de base portable ,
le fichier "Alloc.h" s'apelle parfois "malloc.h" sur certain compilo.
L'appel du nombre de tableaux est un "int" on pourrait mettre un
long pour une "huge application"
ou des "unsigned int" ou "unsigned long" chacun fera sa propre cuisine...
Un bon exemple vaux mieux qu'un grand discours
#include "stdio.h"
#include "alloc.h"
/* pointeur de tableau de tableau */
/* le seul ,l,ment Global */
/* les tableaux eux mSme sont sur le stack */
char far **TabDeTab;
main()
/* efface l'ecran */
clrscr();
for (t=0 ; t<26; t++) {
memset(TabDeTab[t],65+t,30); /* avec 30 a, b,c, etc.. */
printf("%srn",TabDeTab[t]);
printf("Appuyer sur une touche pour lib,rer la m,moirern");
getchar();
for (i=0 ;i<nbTab; i++)
if( (TabDeTab[i] = malloc(lenTab)) == NULL) return(-1);