Discussion :

[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

[EpiTouille]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
 
}

[AASProni]

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

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

[EpiTouille]

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

à 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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"

[Sve@r]

à 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

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 c :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
}

[Sve@r]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

[Bktero]

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

Tu es trop terre-à-terre

[AASProni]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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!