Boucle for et pointeur

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : Boucle for et pointeur

jamsss

Bonjour

Je suis actuellement sur un projet en C et j'ai un tableau de structures (avec 2 champs) qui ressemble à ça:

j'utilise donc des pointeurs *diti et *fiti qui pointent sur des cases du tableau, ce que je voudrais c'est parcourir ce tableau à l'aide d'une boucle for j'ai donc fait ça avec un pointeur test :

for(test = diti ; test < (fiti+1) ; test++)
{
................................................................
}

seulement ça ne fonctionne pas, la boucle est infinie...

Merci d'avance pour votre aide

Publicité

billgatesanonym

j'ai beaucoup lu

En informatique, il y a quatre grandes étapes :

- analyse
- programmation
- test
- debug

Cette quatrième étape est inévitable. Il ne faut donc pas avoir peur de l'affronter dès maintenant.
Cela consiste souvent à mettre des traces, pour voir comment évolue le programme.

Dans votre cas, je conseillerais de mettre ces deux lignes avant d'entrer dans la boucle, pour voir si les bornes sont bien celles que vous croyez avoir :

fprintf(stderr, "diti=%ld, (fiti+1)=%ld", (long int)(diti), (long int)(fiti+1));
exit(0);

Elmoricq

Modérateur

Hmm. Debugger au fprintf, on a quand même vu mieux. Il vaut mieux apprendre directement à utiliser un debugger, outil essentiel à tout développeur, pour toute sa carrière. Autant s'y mettre le plus tôt possible, c'est un gain de temps considérable.

---------------
Blacker than a moonless night, hotter and more bitter than hell itself... That is coffee.

gilou

Modérateur
It's the only NEET thing to do

Tant qu'on aura pas le code source, on ne fera que parler dans le vide sans avoir de chances de cerner la cause du pb.
A+,

---------------
I think you guys should really consider virtualizing the whole process and moving it to the cloud.

jamsss

Bon je l'avais pas mis complet parce qu'il est un peu long mais si vous y tenez

A noter que j'ai courcircuité toute la première partie qui ne sert qu'à entrer les données en mettant toute les infos directement dans les tableaux afin de tester la nouvelle fonction crée c'est à dire la fonction optimise()

Code :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*Déclarations des fonctions*/
void ajout_ville();
void distance();
void parcours();
void purger();
void optimise();
/*Déclarations des constantes*/
#define LONGNOM 30
#define NB_VILLES 20
#define NB_CHEMINS 5
/*Déclarations des variables globales*/
int *nbvilles;
char ville[NB_VILLES][LONGNOM]={"paris","arras","reims","dijon","metz"};
struct {
short ville_suiv;
short distance;
} chemin[NB_VILLES][NB_CHEMINS]={{{1,170},{2,140},{3,315},{-1,0},{-1,0}},{{0,170},{4,345},{2,160},{-1,0},{-1,0}},{{0,140},{1,160},{4,175},{-1,0},{-1,0}},{{0,315},{4,235},{-1,0},{-1,0},{-1,0}},{{1,345},{2,175},{3,235},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}},{{-1,0},{-1,0},{-1,0},{-1,0},{-1,0}}};;
typedef struct
{
short numville;
short numsuiv;
} DITI;
int main()
{
/*Déclarations des variables locales*/
int i,j;
char code[8];
nbvilles=0;
/*Initialisation du tableau 'chemin'
for(i=0;i<NB_VILLES;i++)
{
for(j=0;j<NB_CHEMINS;j++)
{
chemin[i][j].ville_suiv=-1;
}
}*/
/*Affichage du menu*/
while(strcmp(code,"quitter" )!=0)
{
printf("-Pour entrer une nouvelle ville, tapez 'ville'\n" );
printf("-Pour entrer une distance entre 2 villes, tapez 'distance'\n" );
printf("-Pour calculer un parcours, tapez 'parcours'\n" );
printf("-Pour rechercher l'itinéraire optimal entre deux villes, tapez 'optimise'\n" );
printf("-Pour quitter le programme, tapez 'quitter'\n" );
scanf("%s",code);
purger();
if(strcmp(code,"ville" )==0) ajout_ville(&nbvilles);
else if(strcmp(code,"distance" )==0) distance(&nbvilles);
else if(strcmp(code,"parcours" )==0) parcours(&nbvilles);
else if(strcmp(code,"optimise" )==0) optimise(&nbvilles);
}
return 0;
}
void ajout_ville(int *nbvilles)
{
int i;
char nomville[LONGNOM];
/*Vérification qu'on ne depasse pas la capacité du tableau*/
if(*nbvilles>=NB_VILLES)
{
printf("Vous avez atteint le nombre maximum de villes\n" );
return;
}
/*Entrée de la nouvelle ville*/
(*nbvilles)++;
printf("Entrez le nom de la nouvelle ville:\n" );
scanf("%s",nomville);
purger();
/*Vérification que la ville n'est pas déjà existante*/
for(i=0;i<*nbvilles;i++)
{
if(strcmp(ville[i],nomville)==0)
{
printf("La ville existe déjà !\n" );
(*nbvilles)--;
return;
}
}
/*Copie de la ville dans le tableau*/
strcpy(ville[*nbvilles-1],nomville);
}
void distance(int *nbvilles)
{
char ville1[LONGNOM],ville2[LONGNOM];
int longueur, depart, arrivee, i;
depart=21;
arrivee=21;
/*Entrée des villes et de la distance*/
printf("Entrez la première ville\n" );
scanf("%s",ville1);
purger();
printf("Entrez la deuxième ville\n" );
scanf("%s",ville2);
purger();
printf("Entrez la distance entre les 2\n" );
scanf("%i",&longueur);
purger();
/*Recherche des villes dans le tableau*/
for(i=0;i<*nbvilles;i++)
{
if(strcmp(ville[i],ville1)==0) depart=i;
if(strcmp(ville[i],ville2)==0) arrivee=i;
}
/*Vérification que les 2 villes existent*/
if(depart==21)
{
printf("La ville %s n'existe pas ! (Utilisez le module 'Entrer une ville')\n\n",ville1);
return;
}
if(arrivee==21)
{
printf("La ville %s n'existe pas ! (Utilisez le module 'Entrer une ville')\n\n",ville2);
return;
}
/*Entrées des informations dans le tableau chemin*/
i=0;
while(chemin[depart][i].ville_suiv!=-1) i++;
chemin[depart][i].ville_suiv=arrivee;
chemin[depart][i].distance=longueur;
i=0;
while (chemin[arrivee][i].ville_suiv!=-1) i++;
chemin[arrivee][i].ville_suiv=depart;
chemin[arrivee][i].distance=longueur;
}
void parcours(int *nbvilles)
{
int i,j,k,ville_courante,longueur,ville_precedente;
longueur=0;
/*Affichage de toutes les villes avec leur numéro*/
for(i=0;i<*nbvilles;i++) printf("%i-%s\n",i,ville[i]);
/*Demande de saisie de la ville de départ*/
printf("Entrez le numéro de la ville de départ:\n" );
scanf("%i",&ville_courante);
purger();
i=0;
while(chemin[ville_courante][i].ville_suiv!=-1)
{
printf("Destinations possibles:\n" );
for(j=0;chemin[ville_courante][j].ville_suiv!=-1;j++) printf("%i-%s\n",chemin[ville_courante][j].ville_suiv,ville[chemin[ville_courante][j].ville_suiv]);
printf("La longueur totale parcourue est de %i Km\n",longueur);
ville_precedente=ville_courante;
i=0;
printf("Entrez le numéro de la ville suivante:\n" );
scanf("%i",&ville_courante);
purger();
while(ville_precedente==ville_courante)
{
printf("Vous etes déja à %s, entrez une autre ville svp:\n",ville[ville_courante]);
scanf("%i",&ville_courante);
purger();
}
if(ville_courante==99) return;
k=0;
while(chemin[ville_courante][k].ville_suiv!=ville_precedente) k++;
longueur+=chemin[ville_courante][k].distance;
i++;
}
printf("Il n'y a pas d'autres villes suivantes ! (Utilisez le module 'Entrer une distance')\n\n" );
}
void optimise(int *nbvilles)
{
*nbvilles=5;
/*Déclarations des variables locales*/
DITI *diti;
DITI *fiti;
DITI *test;
int long_opti,optimal[NB_VILLES],nbville_opti,i,long_iti,ville_fin,j;
short sortie;
/*Allocation des pointeurs*/
diti=malloc(sizeof(DITI));
fiti=malloc(sizeof(DITI));
test=malloc(sizeof(DITI));
for(i=0;i<NB_VILLES;i++)
{
for(j=0;j<NB_CHEMINS;j++)
{
printf("%i\n",chemin[i][j].ville_suiv);
}
}
/*Initialisation des variables*/
long_opti=32000;
long_iti=0;
nbville_opti=0;
sortie=0;
/*Demande du choix de l'itinéraire*/
printf("Villes disponibles:\n" );
for(i=0;i<*nbvilles;i++) printf("%i-%s\n",i,ville[i]);
printf("Entrez l'itinéraire à calculer\n" );
printf("N° de la ville de départ\n" );
scanf("%hi",&diti->numville);
purger();
printf("N° de la ville d'arrivée\n" );
scanf("%i",&ville_fin);
purger();
/*On met le premier chemin à essayer dans la première case du tableau*/
if(chemin[0][diti->numville].ville_suiv!=-1) diti->numsuiv=0;
else printf("Il n'y a aucun chemin qui part de cette ville !\n" );
fiti=diti;
/*Boucle jusqu'à la fin de la recherche*/
while(sortie!=1)
{
if(chemin[fiti->numsuiv][fiti->numville].ville_suiv!=-1)
{
(fiti+1)->numville=chemin[fiti->numsuiv][fiti->numville].ville_suiv;
(fiti+1)->numsuiv=0;
}
else
{
fiti--;
if (fiti==diti) sortie=1;
}
/*Recherche si la ville n'est pas déjà présente*/
for(test=diti;test<(fiti+1);test++)
{
if((fiti+1)->numville==test->numville)
{
(fiti->numsuiv)++;
(fiti+1)->numville=chemin[fiti->numsuiv][fiti->numville].ville_suiv;
break;
}
else
{
long_iti+=chemin[fiti->numsuiv][fiti->numville].distance;
nbville_opti++;
fiti++;
}
}
if(fiti->numville==ville_fin && long_iti<long_opti)
{
long_opti=long_iti;
for(i=0;i<nbville_opti;i++) optimal[i]=(diti+i)->numville;
fiti--;
long_iti-=chemin[fiti->numville][fiti->numsuiv].distance;
nbville_opti--;
fiti->numsuiv++;
}
}
/*On affiche la longueur totale et la liste des villes traversés*/
printf("La distance la plus courte entre %s et %s est de %i Km\n",ville[diti->numville],ville[ville_fin],long_opti);
printf("Liste des villes traversées:\n" );
for(i=0;i<nbville_opti;i++) printf("%s\n",ville[optimal[i]]);
}
void purger()
{
int c;
while ((c=getchar()) != '\n' && c != EOF)
{}
}

gilou

Modérateur
It's the only NEET thing to do

Je ne comprends pas votre logique:

Code :

DITI *diti;
   DITI *fiti;
   DITI *test;
 
   /*Allocation des pointeurs*/
   diti=malloc(sizeof(DITI));
   fiti=malloc(sizeof(DITI));
   test=malloc(sizeof(DITI));

Vous déclarez vos pointeurs et allouez la structure pointée. OK.

Mais ensuite, vous faites des allègrement des fiti++ et fiti-- alors que l'on n'a pas créé un tableau de DITI et donc que fiti++ a priori pointe sur n'importe quoi.
Ça ne marche pas pour les mêmes raisons dans la ligne
for (test=diti;test<(fiti+1);test++)
Nulle part vous n'avez réservé les adresses mémoires entre diti et fiti pour les utiliser comme des pointeurs sur des DITI (alloués je ne sais ou)
J'ai comme l'impression que vous avec pensé allouer un tableau et puis vous ne l'avez pas fait (peut être parce que vous n'en connaissiez pas la taille, variable).

Code :

if(chemin[fiti->numsuiv][fiti->numville].ville_suiv!=-1)
      {
       (fiti+1)->numville=chemin[fiti->numsuiv][fiti->numville].ville_suiv;
       (fiti+1)->numsuiv=0;
      }

c'est ici que votre logique pêche: logiquement, ça devrait planter ici à l'exécution vu que fiti+1 peut à priori pointer sur n'importe quoi. Il y a plusieurs méthodes à envisager pour faire ce que vous voulez.
Soit vous utilisez un tableau de pointeurs sur des DITI, auquel cas vous vous devez faire un malloc pour la structure sur laquelle va pointer fiti+1, et alors seulement remplir cette structure. Mais votre algo devra tester que vous ne dépassez pas la taille du tableau.
Soit vous vous utilisez un tableau de DITI, et vous pouvez remplir la structure. Il sera alors plus simple d'utiliser des indexs que des pointeurs. Mais votre algo devra tester que vous ne dépassez pas la taille du tableau.
Soit vous utilisez une liste doublement chainée, vous avez a gérer des champs fiti->suivant et fiti->precedent au lieu de fiti++ et fiti-- et vous vous vous devez faire un malloc pour la structure sur laquelle va pointer fiti->suivant ici et alors seulement remplir cette structure.
A+,

Message cité 1 fois
Message édité par gilou le 30-12-2009 à 11:29:52

---------------
I think you guys should really consider virtualizing the whole process and moving it to the cloud.

jamsss

Bonjour,

tout d'abord merci de vous être penché sur le problème

gilou a écrit :

Je ne comprends pas votre logique:

La logique est bonne, en fait comme au départ on a fiti=diti, faire fiti+1 reviens à incrémenter fiti de 4 octets (structure de 2 entiers courts) et donc fiti+1 ne pointe pas n'importe ou, il pointera vers l'adresse de diti[1] et je vous prouve ce que j'avance, voici le screen du programme qui fonctionne (les problèmes ne venaient pas de la boucle for mais du reste de la fonction):

J'ai mis des printf dans le for, on voit bien le pointeur se déplacer de 4 octets, en tout cas problème résolu :bounce:

a+ :hello:

__tomjost

c'est un pseudo !

DISASTER! ... quesqu' on a pas mis encore sur
cette page!!!! :ouch:

jamsss

Bonjour et bonne année à tous !

Je viens enfin de comprendre ce qu'a essayé de me dire Gilou (mieux vaut tard que jamais !!!) il est vrai que les adresses du tableau diti ne sont pas allouées (d'ailleurs je ne comprends pas pourquoi ça ne plante pas....) j'ai donc essayé ça:

/*Allocation des pointeurs*/
for(i=0;i<*nbvilles;i++) diti[i]=malloc(sizeof(DITI));

mais pourquoi j'ai "D10.c:197: erreur: incompatible types in assignment" je capte pas

gilou

Modérateur
It's the only NEET thing to do

Citation :

Non: fiti est un pointeur sur une structure DITI.
faire fiti+1 incrémente fiti de la taille de la structure pointée DITI (éventuellement alignée) en effet, et fiti interprète cela comme une structure DITI mais rien ne dit que c'en est une. Mais si cette zone pointée n'a pas été allouée pour y mettre une structure DITI (et je n'ai pas vu cela dans votre code), en fait, après l'incrémentation, fiti pointe sur n'importe quoi, interprété comme un DITI.

A+,

---------------
I think you guys should really consider virtualizing the whole process and moving it to the cloud.

gilou

Modérateur
It's the only NEET thing to do

Citation :

diti[i]=malloc(sizeof(DITI));

diti est déclaré comme un pointeur, pas comme un tableau de pointeur, voila pourquoi ça coince.
Vous aimeriez déclarer DITI diti[*nbvilles]; mais comme on est en C ce n'est pas possible.

On doit donc passer par une déclaration dynamique de ce type: DITI *diti = malloc(*nbvilles*sizeof(DITI)); déclare diti comme un pointeur sur un DITI mais on en a alloué *nbvilles consécutifs. il faudra gérer la libération de ce qui est alloué en fin de fonction.

Ou alors, vous faites plus bourrin: DITI diti[NB_VILLES]; avec un tableau de la taille maximale.

A+,

Message édité par gilou le 01-01-2010 à 12:22:30

---------------
I think you guys should really consider virtualizing the whole process and moving it to the cloud.

jamsss

Ok merci ça fonctionne, je m'embrouille encore un peu avec les pointeurs mais ça commence à rentrer, ce que je trouve génant avec le c c'est que même quand un programme fonctionne, le code n'est pas forcément bien écrit, c'est pas évident quand on veut apprendre....

Message cité 1 fois

gilou

Modérateur
It's the only NEET thing to do

jamsss a écrit :

Petit a petit, en progressant, on apprend a écrire du code C propre.

Typiquement dans votre programme, nbvilles n'est pas kosher dans ses usages:
int *nbvilles; déclaré comme globale
Or nbvilles n'est employé comme variable que dans main et donc ce devrait être une variable locale à main).
distance(&nbvilles);
Or nbvilles n'est pas modifié par distance on devrait donc avoir distance(nbvilles); et le code de distance modifié pour employer un nombre et non un pointeur sur un nombre.

A+,

---------------
I think you guys should really consider virtualizing the whole process and moving it to the cloud.

jamsss

oui je suis d'accord pour *nbvilles, au départ je l'avais déclaré en local dans main, ce qui passait très bien sur un premier PC (avec mandriva 64 bits) et qui ne passait plus sur un deuxième PC (avec mandriva 32 bits), je l'ai mis en globale et le problème a semblé résolu (à moins que ça vienne de gcc mais je pense que c'est la même version ou alors c'est autre chose...)

gilou

Modérateur
It's the only NEET thing to do

Le problème a peut être semblé résolu, mais il ne l'était pas.
Quand un programme passe sur un compilo et pas sur un autre, c'est le plus souvent que le programme a un vrai problème, et que par chance, un des compilos compense, par hasard, le problème. Je me souviens d'un compilo C DEC qui initialisait à 0 toute variable numérique pas initialisée, et à "" toute chaine pas initialisée, etc. C'était sympa, mais ça camouflait les erreurs d'initialisation, lesquelles se manifestaient tout de suite à l'exécution du programme sur une machine SUN (après compilation du même source, par gcc).

Il est rare qu'on ait besoin d'une globale dans un programme C (les cas qui me viennent en tête sont des cas ou cette variable peut être accédée/modifiée par quelque chose d'externe au programme), au pire, une variable est déclarée dans le corps de main.

A+,

---------------
I think you guys should really consider virtualizing the whole process and moving it to the cloud.

Publicité

FORUM HardWare.fr

Programmation

Boucle for et pointeur

Sujets relatifs
[VBA] Boucle sur variables	[C] probleme sprintf et pointeur :S
Couper une boucle avec des includes	Boucle ping dans un batch pour détecter une déconnexion
Pb de boucle While avec 2 bases	[Résolu - PHP] Incrémenter une variable par autre chose que +1
URGENT : problème shell windows boucle for	appel d'une fonction dans une boucle ne se réalise qu'une fois
lecture d'un flv (random)	Problème avec boucle while qui ne s'arrêt pas
Plus de sujets relatifs à : Boucle for et pointeur

Page générée en 0.504 secondes