Discussion :

[wassim taktak]

Bonjour,

j'ai un exercice sur les pointeurs et les fonctions
l'énoncé :

Exercice 6
Ecrire un programme qui lit deux tableaux d'entiers t1 et t2 et leurs dimensions n1 et n2 au clavier et qui ajoute les éléments de B à la fin de A. Utiliser deux pointeurs p1 et p2 et afficher le tableau résultant t1.

j'ai essayé de le résoudre et j'ai fait un code or dans l'affichage il ne me donne qu'une seule case (alors que je veux le tableau concaténé) et son adresse (on veut le contenu) :
mon code:

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
51
52
53
54
55
#include<stdio.h>
#include<stdlib.h>
void saisie(int *n )
{
    do
    {
      printf("donner un entier n" );
      scanf("%d",n);}
   while(n>20);
}
 
int remplir(int *t,int n)
{
    int *p;
    for(p=t;p<t+n;p++)
    {
        printf("donnerla case %d",p-t);
        scanf("%d",p);
    }
}
void concatiner(int *t,int *t1,int n,int n1)
{
    int *p,*p2=t1;
  for(p=t+n;p<t1+n1;p++,p2++)
  {
    *p=*p2;
  }
  n=n+n1;
 
 
}
void afficher (int *t,int n)
{
    int *p,i;
       for(p=t;p<t+n;p++)
       printf("t[%d]=%d\n",p-t,*p);
 
}
void main()
{
 int n,*t,n1,*t1;
    saisie(&n);
    t=(int*)malloc(n*sizeof(int));
        remplir(t,n);
      saisie(&n1);
      t=(int*)malloc(n1*sizeof(int));
    remplir (t1,n1);
 
    concatiner(t,t1,n,n1);
 
    afficher(t,n);
    free(t);
    free(t1);
 
}

[Sve@r]

Salut
Il est pas mal ton code. Un peu brouillon avec ces t, n, t1, n2 (pourquoi n2 pour t1 et pas n1 pour t1 ?, pourquoi "t" et "t1" et pas "t1" et "t2" ?) mais presque correct. Tu as bien pigé les pointeurs et c'est le plus important. Les petits défauts qui font que ça ne fonctionne pas ce n'est qu'une question d'expérience et ça ce n'est pas un souci, ça viendra tout seul.

Donc le premier défaut c'est dans for(p=t+n;p<t1+n1;p++,p2++). En partant de p=t pour finir à p=t1+n1 déjà tu supposes que que "t" est placé avant "t1" et surtout qu'ils sont accolés en RAM !!!
Or non, ce n'est pas assuré et ce n'est même pas à envisager. Tu as alloué "t", tu as alloué "t1" tout ce que tu peux dire c'est qu'ils sont tous deux quelque part en RAM et qu'ils ne se recouvrent pas. Mais ils peuvent se trouver à 3000km l'un de l'autre, et rien ne dit qui est devant qui.
Alors il te faut trouver un autre moyen de voir que tout a été traité. Et c'est quoi qui te permet de déterminer que tout a été traité ? C'est simplement quand tu as traité t1 donc quand p1 se trouve à n1 cases de t1. Toutefois au lieu de calculer sur l'écart entre p1 et t1 (ce n'est pas parce que tu utilises des pointeurs qu'il ne faut utiliser que des pointeurs et que les calculs ne prennent pas du temps CPU pour rien), tu as tout à fait le droit d'utiliser un indice qui se réfèrera à n1 pour savoir quand t'arrêter.
Et enfin un peu d'aération dans le code ne fait pas de mal.

Code c :

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

1
2
3
4
5
6
void concatiner(int *t1, int n1, int *t2, int n2) {
	int *p1, *p2;
	int i;
	for (i=0, p1=t1+n1, p2=t2; i < n2; i++, p1++, p2++)
		*p1=(*p2);
}

Le second défaut c'est que si "t1" doit être concaténé à "t", il est alors nécessaire d'allouer pour "t" un espace suffisant pour pouvoir stocker "n+n1" éléments => revoir le malloc. Ce n'est pas en écrivant n=n+n1 de la ligne 28 que ça va agrandir le tableau alloué. De plus ce sont des variables locales à la fonction donc perdues quand la fonction se termine.
De même pour l'affichage, il faut afficher le tout.

Le 3° défaut (plus subtil car il a fallu que je compile ton code pour le voir mais le compilo te dit qu'il y a un truc qui ne va pas donc tu aurais dû le voir toi aussi) c'est dans ce while(n>20). Là je ne te dis rien. Un peu de réflexion devrait t'aider à trouver ce qui ne va pas.

Le 4° défaut c'est que "main" est de type int et ça c'est inscrit dans le marbre. Tu écris la fonction "main" tu écris int main et pas autre chose.

Ensuite question "programmation rigoureuse" tu devrais te forcer à utiliser les bon types pour tes variables. Un indice de tableau (ou sa taille) étant forcément positif, mettre tes variables en unsigned serait un plus. Officiellement le type exact c'est size_t (un type créé pour ça qu'on trouve dans <sys/types.h>) mais pour commencer tu peux te mettre en unsigned long. Plus tu te forceras à affiner tes types assez tôt plus ça te sera facile ensuite.

[wassim taktak]

merci beaucoup cher Sve@r ca m' a beaucoup aidé et le probléme est résolu
merci

[Sve@r]

Montre ton code et on te dira s'il est correct et/ou si on peut l'améliorer

[wassim taktak]

j'ai trouvé que l'erreur est dans l'emplacement de n =n+n1 alors je l'ai changé dans le prog principale main et ça marche maintenant en exécution

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
51
52
53
54
#include<stdio.h>
#include<stdlib.h>
void saisie(int *n )
{
 
 
      printf("donner un entier n" );
      scanf("%d",n);
}
 
int remplir(int *t,int n)
{
    int *p;
    for(p=t;p<t+n;p++)
    {
        printf("donnerla case %d",p-t);
        scanf("%d",p);
    }
}
void concatiner(int *t,int *t1,int n,int n1)
{
    int *p,*p2=t1;
  for(p=t+n;p<t1+n1;p++,p2++)
  {
    *p=*p2;
  }
 
 
 
}
void afficher (int *t,int n)
{
    int *p,i;
       for(p=t;p<t+n;p++)
       printf("t[%d]=%d\n",p-t,*p);
 
}
void main()
{
 int n,*t,n1,*t1;
    saisie(&n);
    t=(int*)malloc(n*sizeof(int));
        remplir(t,n);
      saisie(&n1);
      t1=(int*)malloc(n1*sizeof(int));
    remplir (t1,n1);
 
    concatiner(t,t1,n,n1);
  n=n+n1;
    afficher(t,n);
    free(t);
    free(t1);
 
}

[Sve@r]

j'ai trouvé que l'erreur est dans l'emplacement de n =n+n1 alors je l'ai changé dans le prog principale main

Oui ben t'as rien lu de ce que j'ai écrit. Déjà le while (n < 20) tu l'as supprimé alors que je voulais que tu trouves ce qui ne va pas. Ensuite tu as laissé le for(p=t+n;p<t1+n1;p++,p2++) alors que je t'ai clairement dit que cela ne pouvait pas fonctionner, expliqué pourquoi et donné à la place un code correct et que tu n'as même pas utilisé. Et tu as laissé void main alors que je t'ai là aussi dit que ce n'était pas bon.
Et concernant l'espace insuffisamment alloué au tableau initial bon ben on verra ça un autre jour...

et ça marche maintenant en exécution

Ca marche ça marche faut le dire vite. Moi j'ai un free(): invalid pointer puis un core dump.
Maintenant remplace...

Code c :

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

1
2
3
4
5
6
saisie(&n);
t=(int*)malloc(n*sizeof(int));
remplir(t,n);
saisie(&n1);
t1=(int*)malloc(n1*sizeof(int));
remplir (t1,n1);

par

Code c :

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

1
2
3
4
5
6
saisie(&n1);
t1=(int*)malloc(n1*sizeof(int));
remplir (t1,n1);
saisie(&n);
t=(int*)malloc(n*sizeof(int));
remplir(t,n);

... et tu verras si ça marche encore...

[dalfab]

Bonjour,

Ton code commet 2 erreurs graves. D'ailleurs Sve@r te l'a déjà écris.
Il plante à la ligne 53 à cause de ces 2 erreurs. Comme c'est la dernière ligne du code peut-être que tu ne l'a pas vu.
Essai de concaténer t2 à t au lieu de t à t2, et le plantage sera bien plus visuel.

Je t'invite à bien relire tout ce que t'a écris Sve@r, tout doit être pris compte.

[wassim taktak]

salut a propos le while (n < 20) je pense qu'il faut la transformer en while (*n < 20) mais je l'ai effacé parce que je l'ai confondu avec l'énoncé d'un autre exercice
j'ai bien lu vos instructions monsieur et j'ai bien compris le fait que si je transforme le code en t2 avant t1 ça marche pas mais j'ai dit ça a marche car l'enseignante voudrait qu'on emploie que des pointeurs et pas des compteurs comme for(i=0, p=t+n, p1=t1; i < n1; i++, p++, p1++) mais en voyant vos instructions j'ai trouvé le coté bizarre
en tout cas merci pour votre attention et pour l'aide merci infiniment

[dalfab]

Relis bien, un code qui plante n'est pas un code qui marche.

[Sve@r]

salut a propos le while (n < 20) je penses qu'il faut la transformer en while (*n < 20)mais je l'ai effacé parce que je l'ai confendu avec l'enoncé d'un autre exercice

Ok c'est ça. "n" est un pointeur or c'est le pointé (la valeur saisie) que tu veux comparer à 20. Ok pas de souci, tu as trouvé l'erreur et c'est le plus important. Si maintenant tu ne veux plus faire ce test tu as effectivement le droit de l'enlever. C'est toi le patron.

j'ai bien lu vos instructions monsieur et j'ai bien compris le fait que si je transforme le code en t2 avant t1 ça marche pas mais j'ai dit ça a marche car l'enseignante voudrait qu'on emploit que des pointeurs et pas des compteurs comme for(i=0, p=t+n, p1=t1; i < n1; i++, p++, p1++)

Si la fonction est bien écrite, elle pourra concaténer n'importe quel t2 à n'importe quel t1, peu importe comment et dans quel ordre sont saisis/alloués t1 et t2. Là, force est de constater que la fonction n'est pas bien écrite car en plaçant un pointeur sur t1 et en le faisant finir à t2 cela signifie (dans l'esprit du codeur) que

• t1 est placé avant t2
• t1 et t2 sont collés l'un à l'autre

Or ces deux postulats sont absolument pas assurés, et absolument pas à envisager. En réalité, t1 et t2 sont placés absolument n'importe où en RAM, comme dans l'image ci-dessous

Tu vois bien que si tu pars de t1 pour aller jusqu'à t2, tu vas traiter des zones totalement inutiles. Et si (pire) tu veux changer le sens et concaténer t1 à t2 (comme l'a suggéré dalfab), ta fonction partira alors de t2 et là, avant qu'elle arrive jusqu'à t1...

Tu veux copier t2 dans (ou à la suite c'est pareil) de t1, tu dois commencer au début de t2 et finir à la fin de t2, pas ailleurs. Et concernant les consignes de ta prof, je pense que ce qu'elle veut c'est "pas d'indice" et non "pas de compteur", ce qui n'est pas tout à fait la même chose. En tout cas, si moi je disais "je veux que vous utilisez que des pointeurs" ce serait sous-entendu "pour traiter les éléments du tableau" ce qui n'interdirait pas d'utiliser aussi un compteur en parallèle pour savoir quand s'arrêter. Mais pas de souci, tu as montré que tu t'en sortais bien question pointeur, tu ne devrais avoir aucun mal à supprimer ce "i" de mon exemple. Tu as bien évidemment dû remarquer que dans cet exemple, "i" et "p2" montent en parallèle donc à chaque itération, "i"="p2-t2".