Rechercher : dans
Par :

Aide C++ : Structure & Fichier

Dernière réponse le 16 nov 2008 à 16:36:51 Louise, le 13 avr 2006 à 18:28:00 
 Signaler ce message aux modérateurs

Bonjour tout le monde! Je suis une débutante en programmation C++ et j'ai un exercice à faire qui est assez difficile pour moi. Voici l'énoncé de cela:
Concevoir un programme en C++ qui lit le fichier dinfo.txt , réalise un tri en ordre alphabétique sur le champ nom et sauvegarde le résultat dans un autre fichier appelé dinfo_apres_tri.txt . On suppose que le contenu du fichier dinfo.txt ne dépasse jamais 10 000 lignes.
En fait, le fichier dinfo.txt est une structure qui comporte une colonne de Nom, de Prénom, de Type, de Type d'appareil, de #extension téléphonique, de Bureau, de #prise, de #inventaire, d'adresse physique et d'adresse IP. Chaque colonne est séparée par un espace ou une tabulation, tous les champs sont remplis et ce fichier est sous format texte.

Voici ce que j'ai fait jusqu'à maintentant, mais je suis bloquée et je n'arrive pas à poursuivre... :

#include <iostream>
#include <fstream>

using std::cout;
using std::ifstream;


struct Info {
char Nom [30] ;
} ;


Lire_element (ifstream Fichier) {
Info Etudiant ;

Fichier >> Etudiant.Nom ;
Return Etudiant ;
}


main () {

ifstream Lecture ;
Info Membre ;

Lecture.open("dinfo.txt") ;
Membre = Lire_element (Lecture) ;

while ( ! Lecture.eof() ) {
for (i=0 ; i<strlen(Nom) ; i++) {



J'espère tellement que vous pourriez m'aider à me débloquer. Merci beaucoup!

Meilleures réponses pour « Aide C++ : Structure & Fichier » dans :
Le format BMP Voir Le format BMP Le format BMP est un des formats les plus simples développé conjointement par Microsoft et IBM, ce qui explique qu'il soit particulièrement répandu sur les plates formes Windows et OS/2. Un fichier BMP est un fichier bitmap, c'est-à...
[Windows XP] Recréer le fichier boot.ini pour le lancement VoirVoici la procédure à suivre pour recréer le fichier boot.ini : Démarrer avec le CD d'installation de Windows. Pour cela : Insérer le CD d'installation, et redémarrer votre PC. Si rien ne se passe, passer à l'autre étape. Au démarrage de votre...
Créer un fichier Autorun.inf VoirCréation de fichier autorun Autoriser l'exécution automatique Création du fichier autorun.inf Personnaliser l'icône Personnaliser le texte Personnaliser le menu Autoriser l'exécution automatique Une fonctionnalité de Windows...
La compilation et les modules en C et en C++ VoirCet article a pour vocation d'introduire les notions de bases de la compilation en C et en C++ et de la programmation modulaire. Il permet de mieux comprendre les messages d'erreur du compilateur. Les notions abordées ici sont indépendantes du...
Les structures en langage C VoirDifférence entre une structure et un tableau Un tableau permet de regrouper des éléments de même type, c'est-à-dire codés sur le même nombre de bits et de la même façon. Toutefois, il est généralement utile de pouvoir rassembler des éléments de...
Les structures en langage C++ VoirDifférence entre une structure et un tableau Un tableau permet de regrouper des éléments de même type, c'est-à-dire codés sur le même nombre de bits et de la même façon. Toutefois, il est généralement utile de pouvoir rassembler des éléments de...
Langage C - Les structures conditionnelles VoirQu'est-ce qu'une structure conditionnelle ? On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non. Ces structures conditionnelles peuvent être associées à des structures qui se répètent...

1

mamiemando, le 13 avr 2006 à 20:23:05
  • +1

Il manque la fin du programme. En fait c'est vraiment très simple à faire si tu utilises la structure map<> de la STL :
http://www.sgi.com/tech/stl/Map.html

L'exemple donné sur la page parle de lui-même en ce qui concerne l'insertion d'élément dans une map (opérateur []). Or l'opérateur ordonnant les std::string est par défaut (la vie est bien faite !) l'ordre alphabétique ;-)

#include <fstream>
#include <iostream>
#include <string>
#include <map>

// Une structure contenant les infos
struct infos{
  std::string nom;
  std::string prenom;
  std::string appareil;  
  std::string prise;  
  std::string inventaire;  
  std::string adresse_ip;  
};

// Parser une ligne d'info
bool read_line_infos(
  const std::string & f_in,
  struct infos & data
){
  //Lit une chaine et met infos dans data
  //return true si tout va bien, false sinon
}

// Lire le fichier d'info et le mettre dans un dico
bool read_file_infos(
  std::string & filename_in,
  std::map<std::string,struct infos> & dico
){
  std::ifstream f_in(filename_in);
  if (f_in){
    std::string ligne; // variable contenant chaque ligne lue

    // cette boucle s'arrête dès qu'une erreur de lecture survient
    for(unsigned int no_line=1;std::getline(fichier, ligne);++no_line){
       // afficher la ligne à l'écran
       struct infos data;
       if( !read_line_infos(ligne,data) ){
         std::cerr << "La ligne " << no_line 
             << "["<< ligne << "]" << std::endl;     
      }else{
         dico[data.nom]=data;
      }
    }
    return true;
  }
  std::cerr << "Le fichier " << filename 
        << "n'a pu être ouvert" << std::endl;
  return false;
}


bool read_file_infos(
  std::string & filename_out,
  const std::map<std::string,struct infos> & dico
){
  std::ofstream f_out(filename_out);
  if(f_out){
    std::map<std::string,struct infos>::const_iterator
      dit(dico.begin()),
      dend(dico.end());
    for(;dit!=dend;++dit){
      const struct_info & data=dit->second;
      f_out << data.nom << "\t" << data.prenom << std::endl;
    }
    return true;
  }
  return false;
}

int main(){
  const std::string filename_in="plop.txt";
  const std::string filename_out="plop2.txt";
  std::map<std::string,struct infos> dico;

  // Lire le fichier
  read_file_infos(filename_in,dico);

  // Ecrire les datas
  read_sorted_file_infos(filename_out,dico);
  return 0;
}


Ou quelque chose dans l'idée ;-)

Bonne chance

Répondre à mamiemando

2

Louise, le 14 avr 2006 à 04:03:34

Bonjour!
Premièrement, merci de m'avoir aidé!
Deuxièmement, je voudrais souligner que je ne pourrais pas utiliser des notions inconnues (que je n'ai pas encore vues à l'école), comme la bibliothèque <map> ... =(
Je me suis renseignée et je sais qu'il faut :
1) lire le fichier diinfo.txt ;
2) le mettre dans un tableau de structures ;
3) faire le tri en ordre alphabétique (de la colonne Nom) ;
4) enfin, mettre le tout dans le fichier dinfo_apres_tri.txt .
Comment pourrais-je écrire cela en C++?
Je vous remercie en avance!

Répondre à Louise

3

mamiemando, le 14 avr 2006 à 09:43:08
  • +1

Alors je ne sais plus si c'est toi ou pas qui m'avais déjà fourni la réponse : on l'a pas vu à l'école donc non... MAIS :)

1) Il faut bien comprendre qu'en informatique, le nombre de fonctions est tellement important que tu ne verras jamais toutes les fonctions
2) L'utilisation de la STL en l'occurrence des map est vraiment TRES classique
3) On pourrait s'en sortir en recodant un algo de tri (tri fusion, tri à bulle, tri par insertion) mais c'est un peu du masochisme si on ne te l'a pas demandé expressement
4) Le rôle des librairies est d'éviter de réinventer la roue à chaque fois.

A ta place je demanderai a ton/ta prof si ça pose un problème, sachant qu'en C++ la démarche des map est clairement la plus naturelle. Si tu n'y a pas le droit regarde comment s'implémente un tri par exemple pour une liste chainée, sachant que ce sera moins rapide en terme d'implémentation et d'éxecution.

Bonne chance

Répondre à mamiemando

4

Louise, le 16 avr 2006 à 13:37:50

Bon, c'est la vie...Vous ne me comprenez peut-être pas pour ce qui est de l'école et je ne sais pas trop de quoi vous parlez si c'était moi ou pas... En tout cas, je vais essayer de travailler cet exercice un peu plus selon ma petite connaissance et je vais le poster ici bientôt, s'il y a des erreurs, et on verra qu'est-ce que ça donne!

Répondre à Louise

5

mamiemando, le 18 avr 2006 à 18:42:56

Ce que tu peux faire aussi pour ton exercice c'est implémenter un objet équivalent à une map... Mais bon c'est une perte de temps.

Demande à ton prof si tu as le droit d'utiliser les map ou pas parce que c'est vraiment le plus simple.

Si tu n'y as pas le droit essayer de t'inspirer des structures d'arbres (à l'extrème rigueur des listes chainées triées)... sachant que les map du c++ reposent en fait sur une structure d'arbre.

Bonne chance

Répondre à mamiemando

6

Louise, le 18 avr 2006 à 21:58:41

Bon...J'ai essayé de faire du mieux que je peux avec ce que je connais jusqu'à maintenant. Cependant, dans mon main(){ je veux que le tri se fait là, mais comment puis-je passer d'un nom à un autre afin de les comparer pour les placer en ordre alphabétique?...

#include <iostream>
#include <fstream>
#include <string>

using std::cout;
using std::ifstream;
using std::ofstream;


struct Utilisateur {
char Nom[20] , Prenom[20] , Type_appareil[10] , Extension_telephonique[5] ;
char Bureau[10] , Prise[20] , Inventaire[10] , Adresse_physique[20] ;
char Adresse_Ip[20] ;
};


Lire_Element (ifstream Fichier) {
Utilisateur Un_utilisateur;

Fichier >> Un_utilisateur.Nom ;
Fichier >> Un_utilisateur.Prenom ;
Fichier >> Un_utilisateur.Type_appareil ;
Fichier >> Un_utilisateur.Extension_telephonique ;
Fichier >> Un_utilisateur.Bureau ;
Fichier >> Un_utilisateur.Prise ;
Fichier >> Un_utilisateur.Inventaire ;
Fichier >> Un_utilisateur.Adresse_physique ;
Fichier >> Un_utilisateur.Adresse_Ip ;
return Un_utilisateur;
}


main () {

ifstream Infos ;
Utilisateur User ;
ofstream Nouveau ;

Infos.open("dinfo.txt") ;
Nouveau.open("dinfo_apres_tri.txt");

while ( ! Infos.eof()) {
for (i=0 ; i<20 ; i++) {
strncmp ( ?????????????
??????????????????????????
??????????????????????????
Nouveau << ????? ;
}}

Infos.close();
Nouveau.close(),
}

Répondre à Louise

7

Louise, le 19 avr 2006 à 13:23:10

?????

Répondre à Louise

8

Louise, le 20 avr 2006 à 00:44:56

Quelqu'un, s'il vous plaît!!!

Répondre à Louise

9

mamiemando, le 20 avr 2006 à 12:34:04
  • +1

Tu peux utiliser les fonctions strcmp et qsort par exemple. la fonction qsort prend en paramètre un pointeur sur une fonction définissant ta relation d'ordre.

http://www.linux-kheops.com/doc/man/manfr/man-html-0.9/man3/­qsort.3.html
http://www.hmug.org/man/3/strcmp.php

Exemple d'utilisation
http://www.lri.fr/~aze/page_c/aide_c/qsort.html

Note au passage quesi tu utilisais des std::string pour tes champs tu pourrais :
- t'abstraire de la taille des champ, puisque une stdd:string est virtuellement de longueur infinie
- utiliser l'opérateur < pour comparer tes chaînes

Bonne chance

Répondre à mamiemando

10

Louise, le 20 avr 2006 à 15:05:48

J'suis allée voir ce que vous m'aviez donné sur le qsort. Mais il y a une chose que je ne comprends pas. C'est que dans mon fichier dinfo.txt, je ne peux pas savoir c'est quoi le nombre de Nom qu'il y a de-dans, donc comment pourrais-je comparer nom par nom si je ne sais pas quand ça termine?!
Je comprends que chaque Nom est formé sous forme de tableau et qu'il est possible de pouvoir comparer lettre par lettre pour les placer en ordre alphabétique, mais pour sauter d'un Nom à un autre dans une structure, je ne vois pas comment on pourrait faire ça si c'est de longueur indéfinie.
(désolé si j'suis un peu nulle dans tout ça...)

Répondre à Louise

11

mamiemando, le 20 avr 2006 à 15:25:33

Utilise la fonction getline :

http://c.developpez.com/faq/cpp/?page=fichiers#FICHIERS_lect­ure_par_ligne

Le fonction getligne s'arrêtera quand tu auras fini de lire ton fichier.
Enfin pour comparer deux nom utilise la fonction strcmp comme dit plus haut

extern "C"{
  #include <string.h>
}

int main(){
  printf("strcmp=%d\n",strcmp("plop","tapir"));
  return 0;
}

Mais bon objectivement tu crois pas que ce serait plus simple si tu utilisais des string et des map, comme tout le monde ;)

Bonne chance

Répondre à mamiemando

12

Louise, le 20 avr 2006 à 16:44:22

C'est surement plus simple avec les map et les string... Mais j'aimerais vraiment faire avec les structures et les fichiers de la façon que je fais, parce que j'aimerais bien maîtriser les notions de base en premier et après je pourrais faire avec des notions un peu plus complexes. Cependant, je n'arrive même pas à faire correctement mon programme... Bon voici ce que j'ai fait jusqu'à date (j'ai essayé de comprendre la fonction getline que vous m'aviez donné, en fait, ce qui est en gras ne me semble pas vraiment exact), pourriez-vous me débogger svp :

#include <iostream>
#include <fstream>
#include <string>

using std::cout;
using std::ifstream;
using std::ofstream;


struct Utilisateur {
char Nom[20] , Prenom[20] , Type_appareil[10] , Extension_telephonique[5] ;
char Bureau[10] , Prise[20] , Inventaire[10] , Adresse_physique[20] ;
char Adresse_Ip[20] ;
};


Lire_Element (ifstream Fichier) {
Utilisateur Un_utilisateur;

Fichier >> Un_utilisateur.Nom ;
Fichier >> Un_utilisateur.Prenom ;
Fichier >> Un_utilisateur.Type_appareil ;
Fichier >> Un_utilisateur.Extension_telephonique ;
Fichier >> Un_utilisateur.Bureau ;
Fichier >> Un_utilisateur.Prise ;
Fichier >> Un_utilisateur.Inventaire ;
Fichier >> Un_utilisateur.Adresse_physique ;
Fichier >> Un_utilisateur.Adresse_Ip ;
return Un_utilisateur;
}


main () {

ifstream Infos ;
Utilisateur User ;
ofstream Nouveau ;

Infos.open("dinfo.txt") ;
Nouveau.open("dinfo_apres_tri.txt");

if (Infos) {
std::string Ligne1;
std::string Ligne2
std::getline (Infos , Ligne1) ;
while ( ! Infos.eof() ){
while ( strcmp (Un_utilisateur.Nom , Ligne1) < 0) {
strcpy (Ligne2 , Ligne1);
strcpy (Ligne1 , Un_utilisateur.Nom);
}
Nouveau << Ligne1 << endl;
}}

Infos.close();
Nouveau.close(),
return 0;
}


Les erreurs qui se sont apparues lors de la compilation sont:
tp3.cpp: In function `int main()':
tp3.cpp:52: error: `Ligne2' does not name a type
tp3.cpp:54: error: `Un_utilisateur' undeclared (first use this function)
tp3.cpp:54: error: (Each undeclared identifier is reported only once for each function it appears in.)
tp3.cpp:55: error: `Ligne2' undeclared (first use this function)

Répondre à Louise

13

Louise, le 21 avr 2006 à 03:05:44

...

Répondre à Louise

14

kiruasam, le 21 avr 2006 à 16:39:52

tp3.cpp:52: error: `Ligne2' does not name a type
Normal, tu as oublié un point-virgule :

std::string Ligne2 ;

tp3.cpp:54: error: `Un_utilisateur' undeclared (first use this function)
Tu as déclarer une variable "Un_utilisateur" mais dans la fonction Lire_Element, donc elle n'est utilisable que dans cette fonction.
La variable de type utilisateur que tu as déclaré dans la fonction Main est User, donc :
while ( strcmp (User.Nom , Ligne1) < 0)


Voila pour les erreurs de compilation en tout cas,
Good luck
Moi je dis ça...je dis rien ^^

Répondre à kiruasam

49

 10fer, le 16 nov 2008 à 16:36:51

Tu pe verifier mon programme car jarrive pa a obtenir ce quil me demande voila ce quil ve


Jeu de vie ou mort
Sur une matrice n x n, une "situation" est composée de cases noires et de cases blanches. Les
cases noires indiquent une "situation de vie", et les cases blanches, une "situation de mort".
Pour une case m[i][j], on définit quatre voisins :
m[i-1][j], m[i+1][j], m[i][j-1] et m[i][j+1].
À chaque tour de jeu, on réexamine la situation des cases de la grille selon les règles
suivantes:
Quatre voisins noirs : "mort par étouffement".
Si la case est blanche, elle reste blanche.
Si la case est noire, elle devient blanche.
Trois voisins noirs : aucun changement.
Deux voisins noirs : "naissance".
Si la case est noire, elle reste noire.
Si la case est blanche, elle devient noire.
Un voisin noir : aucun changement
Zéro voisin noir : "mort par isolement".
Si la case est blanche, elle reste blanche.
Si la case est noire, elle devient blanche.
Écrire un programme qui, après avoir lu une configuration initiale, demande à l'utilisateur le
nombre d'étapes qu'il veut visualiser, et les affiche une à une à l'écran.
Le problème peut être simplifié en prenant une matrice (n+2)x(n+2) dont les contours sont
toujours blancs. En effet, comme les cases blanches n'interviennent pas dans la décision de
modification de l'état d'une case, cette bordure rajoutée artificiellement permettra de ne pas
faire de traitement particulier pour les cases de bordure ou pour les cases d'angle de la matrice
n x n, qui sans cela ne posséderaient que deux ou trois voisins chacune.
On pourra tester le programme produit sur la configuration initiale suivante :
Pour cela, créer un tableau contenant 49 caractères B (pour "blanc") ou N (pour "noir") dans
un ordre qui corresponde à la configuration du dessin ci-dessus, lue ligne par ligne.
On aura intérêt à utiliser les définitions suivantes :
#define T 9
char grille[T][T];
On écrira les fonctions suivantes :
· initialise : initialise la matrice, en mettant des cases blanches sur tout le contour, et en
lisant la couleur initiale de chacune des cases non situées au bord.
· compte : retourne le nombre de voisins noirs d'une case.
· change : calcule une nouvelle situation.
Attention :
Pour l'écriture de cette fonction, il est absolument nécessaire de compter le nombre de
voisins noirs de chaque case en se référant à la situation précédente, et non à la
situation courante.
· affiche : affiche une situation, par exemple sous la forme suivante :
Combien d'étapes souhaitez-vous visualiser : 15
Etape : 0
B B B B B B N
B B B B B N N
B B B B N N N
B B B N N N N
B B N N N N N
B N N N N N N
N N N N N N N
Etape : 1
...
Etape : 15
N N N N N N N
N N B N B N N
N B N N N B N
N N N B N N N
N B N N B N N
N N B N N B N
N N N N N N N
>





et voila mon programme:


#include <stdio.h>
#define T 9

main()

{
char grille[T][T];
int ligne,colone,limit_debut,limit_fin,nombres_de_voisins_noirs;
int nombre_etape_choisi,numero_etape;

numero_etape = 0;
printf("Combien d'etapes souhaiter vous voir?\n");
scanf("%d", &nombre_etape_choisi);


/*--------------------------------------------------------------------------------------------- */
/* FONCTION INITIALISATION GRILLE */
/*--------------------------------------------------------------------------------------------- */

// On initialise tout avec "B" en prenant en compte les bordures

for (ligne=0; ligne <= 9; ligne++)
{
for (colone=0; colone < 9; colone++)
{
grille[ligne][colone] = 'B';
}
grille[ligne][colone] = grille[ligne+1][colone];
printf("\n");
}

// On initialise tout sauf les bordures

limit_debut = 7;
limit_fin = 0;

for (ligne=1; ligne <= 7; ligne++)
{
for (colone=1; colone < 8; colone++)
{

if(colone >= limit_debut || colone <= limit_fin )
{grille[ligne][colone] = 'N';}
}
limit_debut = limit_debut - 1;
}

















// FONCTION AFFICHAGE
system("cls");
printf("\n-----Etape %d-----\n", numero_etape);

for (ligne=1; ligne < 8; ligne++)
{
for (colone=1; colone < 8; colone++)
{
printf("%1c ", grille[ligne][colone]);
}
grille[ligne][colone] = grille[ligne+1][colone];
printf("\n");
}
system("PAUSE");

do{

numero_etape++;
system("cls");

printf("\n-----Etape %d-----\n", numero_etape);
/*--------------------------------------------------------------------------------------------- */
/* FONCTION AFFICHAGE GRILLE */
/*--------------------------------------------------------------------------------------------- */

// FONCTION AFFICHAGE

for (ligne=1; ligne < 8; ligne++)
{
for (colone=1; colone < 8; colone++)
{


/*--------------------------------------------------------------------------------------------- */
/* FONCTION NOMBRE3 VOISINS */
/*--------------------------------------------------------------------------------------------- */

nombres_de_voisins_noirs = 0;


if(grille[ligne - 1][colone] == 'N')
{nombres_de_voisins_noirs++;};
if(grille[ligne + 1][colone] == 'N')
{nombres_de_voisins_noirs++;};
if(grille[ligne][colone - 1] == 'N')
{nombres_de_voisins_noirs++;};
if(grille[ligne][colone + 1] == 'N')
{nombres_de_voisins_noirs++;} ;


/*--------------------------------------------------------------------------------------------- */
/* FONCTION CHANGEMENT SITUATION */
/*--------------------------------------------------------------------------------------------- */


switch(nombres_de_voisins_noirs)
{
case 0:
if(grille[ligne][colone] == 'N')
{
grille[ligne][colone] = 'B';
}
break;
case 2:
if(grille[ligne][colone] == 'B')
{
grille[ligne][colone] = 'N';
}
break;
case 4:
if(grille[ligne][colone] == 'N')
{
grille[ligne][colone] = 'B';
}
break;
default:
break;
}



printf("%1c ", grille[ligne][colone]);
}

printf("\n");
}
system("PAUSE");

}while(numero_etape != nombre_etape_choisi);

printf("\n");
system("PAUSE");
}

/*--------------------------------------------------------------------------------------------- */
/* FONCTION CHANGEMENT SITUATION */
/*--------------------------------------------------------------------------------------------- */

tu pourra me le faire avan mardi stp fo ke je le rend jeudi mersi d'avance

Répondre à 10fer

15

Louise, le 21 avr 2006 à 19:56:29

Bon...J'ai corrigé ce que Kiruasam m'a dit de corriger...MAIS ça ne fonctionne toujours pas...

#include <iostream>
#include <fstream>
#include <string>

using std::cout;
using std::ifstream;
using std::ofstream;


struct Utilisateur {
char Nom[20] , Prenom[20] , Type_appareil[10] , Extension_telephonique[5] ;
char Bureau[10] , Prise[20] , Inventaire[10] , Adresse_physique[20] ;
char Adresse_Ip[20] ;
};


Lire_Element (ifstream Fichier) {
Utilisateur Un_utilisateur;

Fichier >> Un_utilisateur.Nom ;
Fichier >> Un_utilisateur.Prenom ;
Fichier >> Un_utilisateur.Type_appareil ;
Fichier >> Un_utilisateur.Extension_telephonique ;
Fichier >> Un_utilisateur.Bureau ;
Fichier >> Un_utilisateur.Prise ;
Fichier >> Un_utilisateur.Inventaire ;
Fichier >> Un_utilisateur.Adresse_physique ;
Fichier >> Un_utilisateur.Adresse_Ip ;
return Un_utilisateur;
}


main () {

ifstream Infos ;
Utilisateur User ;
ofstream Nouveau ;

Infos.open("dinfo.txt") ;
Nouveau.open("dinfo_apres_tri.txt");

if (Infos) {
std::string Ligne1;
std::string Ligne2;
std::getline (Infos , Ligne1) ;
while ( ! Infos.eof() ){
while ( strcmp (User.Nom , Ligne1) < 0) {
strcpy (Ligne2 , Ligne1);
strcpy (Ligne1 , User.Nom);
}
Nouveau << Ligne1 << endl;
}}
Infos.close();
Nouveau.close(),
return 0;
}


Voici les erreurs de compilation cette fois-ci:
tp3.cpp: In function `std::ifstream Lire_Element(std::ifstream)':
tp3.cpp:36: error: conversion from `Utilisateur' to non-scalar type `std::ifstream' requested
tp3.cpp: In function `int main()':
tp3.cpp:54: error: no matching function for call to `strcmp(char[20], std::string&)'
/usr/include/iso/string_iso.h:65: note: candidates are: int strcmp(const char*, const char*)
tp3.cpp:55: error: no matching function for call to `strcpy(std::string&, std::string&)'
/usr/include/iso/string_iso.h:66: note: candidates are: char* strcpy(char*, const char*)
tp3.cpp:56: error: no matching function for call to `strcpy(std::string&, char[20])'
/usr/include/iso/string_iso.h:66: note: candidates are: char* strcpy(char*, const char*)

Répondre à Louise

16

mamiemando, le 21 avr 2006 à 21:53:07
  • +1

Une fonction doit toujours avoir un type de retour, que tu as oublié de précisé :

Utilisateur Lire_Element (ifstream Fichier) {
  Utilisateur Un_utilisateur;

  Fichier >> Un_utilisateur.Nom ;
  ...
  Fichier >> Un_utilisateur.Adresse_Ip ;
  return Un_utilisateur;
} 

Si la fonction ne retourne rien, son type de retour est void
void plop(){
  printf("plop\n");
}

Ensuite les messages d'erreurs te disent qu'ils ne connaissent pas strcmp, et pour cause, cette fonction attend en paramètre deux char*, et tu lui passes un char* et un std::string.

Il faut donc convertir tes strings avec les méthodes c_str(). Par ailleurs tu peux utiliser :
- l'opérateur = si à gauche de l'opérateur c'est un std::string pour faire une recopie de chaîne, à la place du strcpy.
- l'opérateur == si à gauche de l'opérateur c'est un std::string pour faire une comparaison de chaîne, à la place du strcmp.
if (Infos) {
  std::string Ligne1;
  std::string Ligne2;
  std::getline (Infos , Ligne1) ;
  while ( ! Infos.eof() ){
    while ( strcmp (User.Nom , Ligne1.c_str()) < 0) {
      Ligne2=Ligne1;
      Ligne1=User.Nom;
    }
    Nouveau << Ligne1 << endl;
  }
}

Je t'invite à prendre le temps de lire les docs :
http://www.sgi.com/tech/stl/basic_string.html
http://www.hmug.org/man/3/strcmp.php
http://www.linux-kheops.com/doc/man/manfr/man-html-0.9/man3/strcpy.3.html

Bonne chance

Répondre à mamiemando

17

Louise, le 22 avr 2006 à 01:42:08

Merci pour votre support! Je pense que le programme fonctionne bien car il n'y a plus d'erreurs lors de la compilation. J'ai aussi ajouté :
Infos.close();
Nouveau.close() ;
avant return 0; pour fermer les 2 fichiers.
Cependant, pour voir si le programme a réellement fait le tri en ordre alphabétique voulu, comment fait-on pour voir le contenu du fichier dinfo_apres_tri.txt ?

Répondre à Louise

18

mamiemando, le 22 avr 2006 à 02:32:24

Ben tu ouvres ce fichier en lecture, tu le parcours avec des std::getline, et tu affiches la ligne lue... Comme c'est très voisin de choses que tu as déjà faites tu devrais y arriver sans problème.

Bonne chance

Répondre à mamiemando

19

Louise, le 22 avr 2006 à 05:20:32

Bon j'ai essayé de créer un programme qui va lire mon nouveau fichier dinfo_apres_tri.txt pour vérifier si mon premier programme a bien fait son travail de triage. Il n'y a pas eu d'erreurs de compilation, cependant, quand je l'exécute, il ne fait absolument rien. Que puis-je faire pour corriger tout ça?

#include <iostream>
#include <fstream>
#include <string>

using std::cout;
using std::endl;
using std::ifstream;


struct Utilisateur {
char Nom[20] , Prenom[20] , Type_appareil[10] , Extension_telephonique[5] ;
char Bureau[10] , Prise[20] , Inventaire[10] , Adresse_physique[20] ;
char Adresse_Ip[20] ;
};


main () {

ifstream Infos ;
Infos.open("dinfo_apres_tri.txt") ;

if (Infos) {
std::string Ligne;
std::getline (Infos , Ligne) ;
while ( ! Infos.eof() ){
cout << Ligne << endl;
}}
Infos.close();
return 0;
}

Répondre à Louise
Collection CommentÇaMarche.net