J´aurais besoin de savoir comment sa marche pour un projet que je dois rendre pour l´école. Merci.

tu as grandement raison, et je m´en vais prestément aquérir a ta requete.

il faut utiliser malloc de malloc.h ( standard library).

je ne me souvient pas tres bien du C, mais si mes souvenris sont corrects ca doit donner qqch de cette allure:

1. include malloc.h

int main(void)
{
void* tablo;

tablo = malloc(valeur_dynamique);
tablo[x] = truc; / / arithmétique des pointeurs

tablo = realloc(nouvelle_valeur);
tablo[y] = autre_truc;

free(tablo);

return 0;
}

tres tres franchement, je ne suis vraiment sur de rien, tu peux toujours essayer de compiler ca en mettant bien le projet comme il faut ( lier les librairies et tout) déclarer chaque variable.
au pire chercher dans les documentations les bonnes utilisation des fonctions d´allocations.

une chose est certaine ca ressemble a ca.

d´autres questions ?

heu probleme
j´ai dev-c++
mais je copie ton truc(pour essayer) je compile et que je test ca dit le fichier source n´a pas ete compilé
comment faire?

Tout depends si tu veux faire des tableaux a une ou deux dimensions, et tout depends si tu veux modifier leur taille en cours d´utilisation.

Peux tu preciser ?

je veut faire un tableau 2D dont je puisse modifier la taille en cours d´utilisation du programme.

Et ben c´est chaud ca

Tu peux deja faire un tableau dynamique et l´utiliser avec monTableau[i][j] avec ca :
-------------------------------------
Use a double pointer :
int ** Arr2D ; / / We start with a double pointer

/ * Allocate an array of pointers to int and make Arr2D a pointer to the base element of the array. */
Arr2D = new int * [H] ;
/ * For each row i of Arr2D ( Arr2D[i]), allocate an array of int´s and make Arr2D[i] a pointer to the base element of the array. */
for ( i=0; i < H; i++)
Arr2D[i] = new int[W] ;
The array can now be accessed simply with Arr2D[i][j] ! !!!
----------------------------
Si tu es en C, tu remplace les new par des mallocs.

Ensuite si tu veux modifier la taille, il faut coper les donner ( est ce que realloc le fait, j´en suis pas sur).

Oop sorry, il fallait lire " les données"

grr c chaud sa, je vais chercher plus simple lol...

new existe pas en C.

et tu oublies de mettre
. ..
et delte apres
car il faut toujours montrer comment désallouer aussi.

ce qui est bien avec les tableaux dynamique c´est qu´on peut créer un tableau dont chaque element pointe vers un tableau dont la longueur n´est pas la meme que celle de l´element d´a coté.

new existe pas en C

Fallait lire jusqu´au bout

je vais chercher plus simple

Les tableaux dynamique c´est pas simple, bon courage.

c est au niveau algo que je vais chercher plus simple.

Notez que malloc.h, c´est pas standard. Préférez stdlib.h .

OK, je vais essayer de simplifier:

Il te faut passer par deux fonctions qui alloueront et désalloueront la mémoire.

malloc() est la fonction pour allouer, et prend 1 paramètre: la taille en bytes à allouer.
Son principe est d´aller créer un tableau d´octets, de char en C, dans une région de la mémoire appellée Heap, qui n´est lui même rien d´autre qu´un gros tableau d´octets. En gros, il va créer un tableau dans un tableau. Il retourne ensuite le pointeur vers ce nouveau tableau.

Toi, de ton côté, tu dois avoir un pointeur du bon type qui pointera vers ce tableau, et comme ça tu pourra [] comme si le tableau était statique.

Attention! Normallement, c´est l´OS qui s´occupe d´allouer et de désallouer. Là, c´est toi, alors il faut prendre des précautions au cas ou: par exemple, s´il ne reste plus de mémoire à allouer, ect.
Et surtout, TOUJOURS désallouer! C´est le principe de se débarrasser du tableau dans la Heap. Il faut le faire avant que ton programme se termine. Pour cela, t´as une fonction:

free(), qui prend un paramètre, le pointeur vers le tableau, et ne retroune rien.

Ex.:

1. include < stdlib.h>

int main()
{
char *MonPointeur = malloc(10);
MonPointeur[7] = ´A´;
free(MonPointeur);
return 0;
}

N´oublie pas, malloc est une taille en octets: un int vaut par exemple en général 4 octets, mais ça dépend. Pour cela, il est toujours essentiel d´utiliser sizeof(), qui retourne la taille en octets d´une structure ou d´un type. Il suffit ensuite de multiplier ce nombre d´octets/type par le nombre que tu en veut, et voilà, le tour est joué.

Ex.:

1. include < stdlib.h>

int main()
{
int MonPointeur = malloc(10*sizeof(int));//Alloue 10 int
MonPointeur[7] = ´A´;
free(MonPointeur);
return 0;
}

Kelios
---------

arrfff naaaaaaaaan pas de ralloc c leeeennnnt pitié pas çaaa

quoi que si ca peut etre si le temps n´est pas important et si ya pas 500 realloc a faire.

le mieu a faire c une liste chaînée
un très bon site: http://www.cppfrance.com

" pas de ralloc c leeeennnnt pitié"
Cette remarque m´étonne grandement. D´autant plus que sa vérité est variable.

Étant donné que la libc est une runtime fourni par l´OS, chaque realloc est donc différent pour chaque OS(à moins bien sur que des OS utilisent le même code, par exemple avec une entende commune). Linux a même plusieurs version de libcs. Les algorithmes diffèrent alors, et une différence notable de rapidité peut être possible entre différentes implémentations de la libc.

De ce fait, il peut donc exister des realloc très rapides, et certains très lent. Ça dépend de l´algo.

En général, rien n´indique que realloc est lent. Consdérant ceci, il serait plus profitable que tu fasse valoir tes arguments contre l´utilisation de realloc, accouplé avec la libc qui, à ton avis, contient un realloc " lent".De là, nous pourrions alors partir une discussion enrichissante qui qui ne se base pas sur des opinions sans fondement.

Kelios
---------