allocation des tab dynamiques

Version imprimable

29/10/2013, 18h41
chawki-e

allocation des tab dynamiques

Bonjour les amis , voilà je debute en langage C et j imagine que vous savez tous que pour un debutant la partie un peu chiante c est les pointeur :p
En ce qui concerne les allocation dynamique des tableau j ai rencontré ce probléme , celui de copier des tableau , je ne sais pas comment l ecrire avec la bonne syntaxe

utiliser des tableaux dynamiques
Remplir et afficher deux tableaux tab1 et tab2. Copier tab1, ensuite tab2 dans un tableau tab3. Afficher tab3.

Merci d avance :)

Garde toujours à l'esprit qu'un pointeur est une variable qui contient une adresse, c'est ce que je me répetait toujours au début.

N'hesite pas à regarder des cours sur internet

voici un exemple de manipulation de tableau de char:

Code:

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
int  main(void)
{
 
  char *a = malloc(sizeof(char) * 10); //declaration de 2 tableaux de char dynamique
  char *b = malloc(sizeof(char) * 10);
  //a verifier, si malloc à echoué, alors, il retourne NULL
 
  //remplissage
 
  memset(a, 'a', 10 * sizeof(char)); //on remplie a avec que des 'a'
  memset(b, 'b', 10 * sizeof(char)); //on remplie b avec que des 'b'
 
  //maintenant, on veux echanger le contenu de a avec le contenu de b
 
  char c[10];
 
  memcpy(c, a, sizeof(char) * 10);
  memcpy(a, b, sizeof(char) * 10);
  memcpy(b, c, sizeof(char) * 10);
 
 
  //affichage de a
  for (int i = 0; i < 10 ; ++i)
  {
    printf("%c", a[i]);
  }
 
  puts(""); //on saute juste une ligne
 
  //affichage de b
  for (int i = 0; i < 10 ; ++i)
  {
    printf("%c", b[i]);
  }
 
  puts(""); //on saute juste une ligne
 
  free(a);
  free(b);
 
  return 0;
 
}

30/10/2013, 15h51
AASProni

Le truc que les debutants oublient toujours avec les pointeurs et qui genere toujour des bugs, c'est l'oubli de l'allocation:lol:

à chaque pointeur n'oublie JAMAIS l'instruction "malloc" avec la taille précis avant de manipuler le pointeur
30/10/2013, 20h34
EpiTouille
Citation:

Envoyé par AASProni

Le truc que les debutants oublient toujours avec les pointeurs et qui genere toujour des bugs, c'est l'oubli de l'allocation:lol:

à chaque pointeur n'oublie JAMAIS l'instruction "malloc" avec la taille précis avant de manipuler le pointeur

Bonjour,

Je me permet d'y ajouter une certaine réserve
Code:

1 2 3 4 int a = 5; int *b = &a;
Ici, j'ai bien un pointeur b et pas de malloc. Il faut bien saisir le sens de malloc et ne pas l'utilisé par que "POINTEUR = MALLOC"

Citation:
Envoyé par AASProni
à chaque pointeur n'oublie JAMAIS l'instruction "malloc" avec la taille précis avant de manipuler le pointeur
Citation:
Envoyé par EpiTouille
Bonjour,

Je me permet d'y ajouter une certaine réserve
Code:

1 2 3 4 int a = 5; int *b = &a;
Ici, j'ai bien un pointeur b et pas de malloc. Il faut bien saisir le sens de malloc et ne pas l'utilisé par que "POINTEUR = MALLOC"
Bonjour
L'idée est bonne mais elle est mal formulée. EpiTouille en montre d'ailleurs un très bon contre-exemple où le malloc n'est pas présent.

La règle exacte est la suivante: quand on déclare un pointeur (de type général <type> *ptr, il ne faut jamais s'occuper de *ptr si on ne s'est pas assuré au préalable que ptr contienne une adresse valide.

Ca peut être
ptr=malloc(...) ce qui est correct puisqu'un malloc() réussi renvoie une adresse valide (il convient toutefois de vérifier que malloc() a réussi en regardant si ptr n'est pas nul et en prenant une décision si c'est le cas)
ou bien ptr=adresse de quelque chose d autre (comme montré par EpiTouille)
ptr=copie d un autre pointeur (lui-même alors contenant une adresse valide
ptr paramètre de fonction recevant une adresse passée par une fonction appelante ; adresse bien entendu elle-aussi valide mais cette vérification est alors à charge du créateur de la fonction appelante

Une fois qu'on s'est assuré du contenu de ptr, alors et seulement alors on peut s'amuser à regarder/remplir *ptr...

Citation:

Envoyé par chawki-e

Bonjour les amis , voilà je debute en langage C et j imagine que vous savez tous que pour un debutant la partie un peu chiante c est les pointeur :p
En ce qui concerne les allocation dynamique des tableau j ai rencontré ce probléme , celui de copier des tableau , je ne sais pas comment l ecrire avec la bonne syntaxe

utiliser des tableaux dynamiques
Remplir et afficher deux tableaux tab1 et tab2. Copier tab1, ensuite tab2 dans un tableau tab3. Afficher tab3.

Merci d avance :)

Généralement on ne fais pas les exos des étudiants car cela ne les aide en rien voire cela les rends prêts à croire que les forums regorgent de gars prêts à bosser à leur place. Et le jour de l'exam ils sont alors dans le caca.

Toutefois cet exo étant typique du tout premier début du début, je vais faire une exception en espérant que cela te donne l'impulsion nécessaire à voler ensuite de tes propres ailes. Garde bien à l'esprit qu'il s'agit d'une exception qui ne saurait m'engager ni moi ni les autres intervenants à faire de même pour les autres exos

1) Remplir et afficher 2 tableaux tab1 et tab2 (on va présumer qu'il s'agit de tableaux de respectivement 5 et 10 int)
Code:

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 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 int main() int *tab1; int *tab2; int *tab3; int *pt; int i; tab1=malloc(5 * sizeof(int)); // Normallement il faudrait vérifier que tab1 n'est pas nul et prendre une décision si c'est le cas mais je ne pense pas que ce soit prévu dans l'exo tab2=malloc(10 * sizeof(int)); // Idem // Saisie tab1 for (i=0; i < 5; i++) { printf("Saisir tab1[%d] :", i); fflush(stdout); scanf("%d", &tab1[i]); } // Saisie tab2 for (i=0; i < 10; i++) { printf("Saisir tab2[%d] :", i); fflush(stdout); scanf("%d", &tab2[i]); } // Affichage tab1 for (i=0, pt=tab1; i < 5; i++, pt++) printf("tab1[%d]=[%d]\n", i, *pt); // Affichage tab2 for (i=0, pt=tab2; i < 10; i++, pt++) printf("tab2[%d]=[%d]\n", i, *pt); // Remplissage tab3 tab3=malloc(15 * sizeof(int)); for (i=0; i < 15; i++) { if (i < 5) tab3[i]=tab1[i]; else tab3[i]=tab2[i - 5]; } // Affichage tab3 for (i=0, pt=tab3; i < 15; i++, pt++) printf("tab3[%d]=[%d]\n", i, *pt); // Libération mémoires free(tab1); free(tab2); free(tab3); }
Essaye de t'en inspirer tout en sachant que si tu le montres tel quel à ton prof, celui-ci verra bien qu'il n'est pas de toi...

31/10/2013, 07h35
AASProni
Merci Sve@r et EpiTouille!

Je n'ai fait q'une reference globale des erreurs des debutants! Mais maitenant je crois que c'est un peu plus clair pour eux!

Un petit problème aussi, je me doit de dire que même moi, j'avais quelques dificultés avant, c'es la différence entre un pointeru et l'opérateur d'indirection! Je vais un peu utiliser le code de Sve@r
Code:

1 2 3 4 5 6 int *tab1;//pointeur int a = 5; printf("adresse de a %d :", *a);//operateur d'indirection tab1=malloc(5 * sizeof(int));
un pti eclaircissement sur ceci? et je crois que je ne devrait pas utiliser %d dans printf car le résultat est un chiffre hexadecimal

Ce code est faux. Tu ne peux appliquer l'opérateur * qu'à un pointeur, or ici a n'est pas un pointeur. Je pense que tu voulais utiliser l'opérateur &. La distinction entre pointeur et adresse est en effet importante. Un pointeur contient une adresse = la valeur d'un pointeur est l'adresse d'un autre élément. Il existe d'ailleurs un formateur adapté pour afficher les adresses : %p :
Code:

1 2 3 4 5 6 7 8 9 int main(void) { int a = 5; int *p = &a; printf("adresse de a = %p\n", &a); printf("adresse de p = %p\n", &p); printf("adresse de a contenue dans p = %p\n", p); printf("valeur de a grace au dereferencement de p = %d\n", *p); }

Citation:

Envoyé par AASProni

un pti eclaircissement sur ceci? et je crois que je ne devrait pas utiliser %d dans printf car le résultat est un chiffre hexadecimal

Un nombre est un nombre dans "l'absolu". Ensuite tu peux à ton gré choisir d'afficher ce nombre au format décimal (%d) ou au format hexadécimal (%x).

Le format "%p" a été créé après à cause des adresses 32 ou 64 bits et il les affiche en hexa
Citation:
Envoyé par Bktero
Code:

1 2 3 4 5 6 7 8 9 int main(void) { int a = 5; int *p = &a; printf("adresse de a = %p\n", &a); printf("adresse de p = %p\n", &p); printf("adresse de a contenue dans p = %p\n", p); printf("valeur de a grace au dereferencement de p = %d\n", *p); }
T'as oublié l'élémentaire printf("valeur de a = %d\n", a); :P

31/10/2013, 10h41
Bktero

Citation:

Envoyé par Sve@r

T'as oublié l'élémentaire printf("valeur de a = %d\n", a); :P

Tu es trop terre-à-terre :)

Citation:
Envoyé par Bktero
Ce code est faux. Tu ne peux appliquer l'opérateur * qu'à un pointeur, or ici a n'est pas un pointeur. Je pense que tu voulais utiliser l'opérateur &. La distinction entre pointeur et adresse est en effet importante. Un pointeur contient une adresse = la valeur d'un pointeur est l'adresse d'un autre élément. Il existe d'ailleurs un formateur adapté pour afficher les adresses : %p :
Code:

1 2 3 4 5 6 7 8 9 int main(void) { int a = 5; int *p = &a; printf("adresse de a = %p\n", &a); printf("adresse de p = %p\n", &p); printf("adresse de a contenue dans p = %p\n", p); printf("valeur de a grace au dereferencement de p = %d\n", *p); }
Chacun oubli quqlque chose au cours du temps et surtout au cours de l'ecriture!