Discussion :

[Invité]

Bonjour tout le monde,

J'aimerai avoir votre aide sur un problème qui me tourmente depuis quelque jours avec une boucle (FOR).

Je vous explique premièrement qu'est ce que j'essaie de faire, dans mon code C, j'essaye de fusionner deux tableaux, A, et B dans un troisième intitulé Tableau_C.

La première fonction que j'avais fait, permet de définir la taille ainsi que la saisi des tableaux A et B.

La deuxième fonction qui s'intitule Fusion de deux Tableaux, permet de faire appel à la fonction précédente (Saisi), afin qu'elle puisse concaténer les deux tableaux (A et B), à mon point de vue, elle le fait, mais il ne m'affiche pas le dernier résultat qui est l'Affichage du tableaux C.

Après plusieurs tentatives, j'ai remarqué que le programme n'exécute pas ma dernière boucle For dans la fonction Fusion des Deux Tableaux.


Si vous pouvez m'aider, je vous en serais très reconnaissant, vos remarques et critiques seront d'une grande importance durant mon parcours d'apprentissage du langage C.

Je vous joint une copie de mon code.

Merci beaucoup à vous tous, et au plaisir de lire vos commentaires.

[-Eks-]

Tu pourrais déjà commencer par poster ton code sur le forum avec les balises de code (clique sur l'icône # et copie-colle ton code entre les balises - prévisualise ton message pour vérifier que le code s'affiche correctement), afin qu'il soit visible et que l'on sache de quoi on parle sur ce topic. Ensuite, on pourra discuter plus précisément de ton code, qui pose de nombreux problèmes.

De façon très globale, l'un des principaux problèmes dans ton code est que tu sembles ignorer le scope des variables que tu déclares. Ainsi : si tu modifies un tableau qui est local à une fonction, cette modification ne sera pas visible dans la fonction appelante sous prétexte que tu y as déclaré un tableau portant le même nom. Il s'agit de tableaux différents, qui ont chacun leur scope.

Pour qu'une fonction puisse modifier le contenu d'une variable déclarée dans la fonction appelante, il faut lui passer le pointeur vers cette variable. Pour un tableau, mettre en paramètre le nom du tableau équivaut en C à passer un pointeur vers son premier élément. Pour des variables autres que des tableaux, et qui ne seraient pas déjà des pointeurs, tu devra utiliser l'opérateur & pour signifier que tu veux passer l'adresse de la variable. C'est du C de base, révise ces bases.

Avant de poster ton code entre balises, éventuellement modifié, tu pourrais te pencher sur la multitude d'avertissements qu'il renvoie lors d'une tentative de compilation, essayer de traiter chacun de ces avertissements et comprendre pourquoi ils se manifestent et nous soumettre un code plus propre.

[Invité]

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
int Fusion_Deux_Tableaux(int Tableau_1[], int Tableau_2[], int Taille);
int SaisiDuTableau(int Tableau[]);
 
 
 
//***************************************************************************************************//
//                                       FONCTION MAIN                                               //
//***************************************************************************************************//
int main(int argc, char *argv[])
{
    printf("Hello Hamza, Lets get Fun Again!\n\n");
 
int Taille=0;
int Tableau_A[Taille];
int Tableau_B[Taille];
int Tableau_C[Taille+Taille];
 
    *Tableau_C=Fusion_Deux_Tableaux(Tableau_A, Tableau_B, Taille);
 
}
 
//***************************************************************************************************//
//                                       FONCTION DE FUSION                                          //
//***************************************************************************************************//
int Fusion_Deux_Tableaux(int Tableau_1[], int Tableau_2[], int Taille)
{
int j = 1;
int i = 0;
int k = 0;
//Taille = 0;
 
int TableauFusion[Taille+Taille];
 
SaisiDuTableau(Tableau_1);
    for(i=0 ; i<Taille ; i++)
        {
            TableauFusion[i]=Tableau_1[i];
        }
 
 
SaisiDuTableau(Tableau_2);
    i=0;
    for(k=Taille ; k<(Taille+Taille) ; k++)
        {
            TableauFusion[k]=Tableau_2[i];
            i++;
        }
 
for(i=0 ; (i<(Taille+Taille)) ;i++ )
   {
    printf("La valeur du %i element du Tableau est maintenant : %d\n\n", j, *(TableauFusion+i));
    j++;
 
   }
 
   return *TableauFusion;
 
}
 
//***************************************************************************************************//
//                                       SAISI FONCTION                                              //
//***************************************************************************************************//
 
int SaisiDuTableau(int Tableau[])
{
int j = 1;
int i = 0;
int Taille=0;
 
printf("Donner la taille du Tableau SVP!!\n\n");
scanf("%i", &Taille);
 
    for(i=0 ; i<Taille ; i++)
    {
        printf("donner le %d Element du tableau \n\n", j);
        scanf("%d", &Tableau[i]);
        j++;
    }
 
int ValTemporary1, ValTemporary2;
 
    for(i=0 ; (i<Taille) ;i++ )
        {
            for(j=i;j<(Taille);j++)
            {
                if((Tableau[i]>Tableau[j]))
                    {
                    ValTemporary1=Tableau[i];
                    Tableau[i]=0;
                    ValTemporary2=Tableau[j];
                    Tableau[j]=0;
                    Tableau[i]=ValTemporary2;
                    Tableau[j]=ValTemporary1;
                                ValTemporary1 = 0;
                                ValTemporary2 = 0;
                    }
            }
        }
j=1;
   for(i=0 ; (i<Taille) ;i++ )
   {
      printf("La valeur du %i element du Tableau est : %d\n\n", j, *(Tableau+i));
      j++;
   }
 
 
 
   return *Tableau;
}
 
 
//**********************************************************************************************************************//

[Sve@r]

Bonjour

J'ai pas lu ton code en détail car je me suis arrêté à ceci: *Tableau_C=Fusion_Deux_Tableaux(Tableau_A, Tableau_B, Taille), avec la fonction "Fusion_Deux_Tableaux()" qui renvoie un simple entier. Et là ça ne peut pas marcher.

Ce qu'il faut savoir sur les pointeurs et les tableaux, c'est que le nom d'un tableau correspond à l'adresse de son premier élément => tab <=> &tab[0]. Donc le pointé *tab corrrespond à son premier élément tab[0].
Ainsi, si j'écris int tab[10] puis tab[0]=123 ou *tab=123 les deux instructions sont strictement équivalentes. Et en allant plus loin, le tableau incrémenté de "n" fait pointer directement sue la case "n" => *(tab+n) <=> tab[n]. C'est de cette façon qu'on peut utiliser des pointeurs de balayage de tableaux qui peuvent traiter tout un tableau.

Donc en écrivant *Tableau_C=truc, tu stockes le résultat de "truc" (ici un int) dans la première case du tableau. Déjà le reste du tableau n'est pas rempli, et d'autre part, un simple int ne peut absolument pas correspondre à la fusion de deux tableaux d'int (ou alors l'int est super grand et contient tous les tableaux concaténés).

Pour fusionner deux tableaux dans un 3°, ta fonction doit recevoir les 3 tableaux en paramètre => void Fusion_Deux_Tableaux(int tabA[], int tabB[], int tabC[], int taille) (pas besoin de mettre de valeur dans les crochets pour les tableaux 1D). De là, la fonction ayant en main les 3 tableaux, pourra lire le premier, lire le second et remplir le 3°. Et je l'ai mis "void" car je ne vois pas ce qu'elle pourrait renvoyer.

Une autre solution existe aussi où la fonction de fusion alloue elle-même le tableau contenant le résultat de la fusion puis renvoie le pointeur de l'allocation mais c'est plus compliqué pour un débutant.

Accessoirement ce n'est pas très sain de mélanger "saisie" et "travail". Une fonction de fusion ne doit s'occuper que de la fusion et pas de la saisie qui se fait ailleurs (par exemple dans le main). Cela la rend plus universelle (demain le tableau pourrait venir d'un fichier et non plus du clavier, la fonction doit pouvoir le traiter pareillement).


Ah, une dernière chose, quand tu écris int taille=0; int Tableau_A[Taille] il n'y a rien qui te choque ??? Ce n'est pas parce que tu débutes que ça doit t'empêcher de réfléchir...

[foetus]

int taille=0; int Tableau_A[Taille] il n'y a rien qui te choque ???

utiliser 1 variable au lieu d'1 constante pour déclarer la taille d'1 tableau

[Sve@r]

utiliser 1 variable au lieu d'1 constante pour déclarer la taille d'1 tableau

Oui il y a déjà ça (encore qu'avec les VLA ça le fait) mais c'est surtout la taille à 0 qui m'a fait tiquer !!!

Et puis toi t'étais pas dans le jeu. Tu as largement prouvé ton niveau en C pour que t'aies pas besoin de donner la réponse. C'était pour le PO