sscanf et la lecture de données entre guillemets

Bonjour.

J'ai une question toute bete et j'arrive pas a trouver le reponse depuis ce matin...

J'ai une chaine de caracteres comme celle ci :
"Nicolas Eymerich,Inquisiteur" "La deesse" 1 "zentner" "sala" "delcourt" "pas lus" "_" "_"

J'aimerais avec un sscanf du genre :
sscanf(lLigne,MASQUE,lSerie,lTitle,&lTome,lDessinateur,lScenariste,lEditeur,lComment,lPicture,lPret);

pouvoir recuperer les données entre guillemets et je n'arrive pas a trouver le masque adequat....

l'auriez vous sous la main?

Merci d'avance

Les pros du scanf ne seront pas sur ce forum.
J'aurais tendance à partir sur les regex (-> boost.regex), ou a utiliser des tabulations plutôt que des guillemets pour séparer les divers champs de ta BD de BDs.

Pour l'utilisation de sscanf il faut mieux voir sur le forum C.

Merci a tous les deux. Je vais aller poser ma uestion sur le forum du C.

Désolé pour le derangement:roll:

Citation:

Envoyé par loufoque

Pour l'utilisation de sscanf il faut mieux voir sur le forum C.

Bof cette fonction est tellement compliquée qu'elle est rarement utilisée en C.

Donc si en C++ vous avez autre chose (ce n'est pas possible pas les stream ?) autant en profiter.

Scanf démythifiée

Salut,

Vous pouvez essayer
Code:

1 2 int res = sscanf( ligne, "`\"%s\"\"%s\"\"%d\"\"%f\"", chaine1, chaine2, &unentier, &unfloat) ;
res renvoit le nombre de conversions réalisées.

Je ne garantis pas le résultat.

Mieux vaut se servir des flux ( sstream ) ou d' un string::tokenizer

Salut,

Si tu veux travailler en C++, il sera beaucoup plus facile d'utiliser les outils fournis par C++...

Je penses, entre autres, aux string et aux istringstream fournis dans la bibliotheque stantdard.

L'une des possiblités pourraient etre la suivante:

Code:

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
 
/* fonction qui prend la chaine de caractères et renvoye un tableau
   contenant les différents champs
   @in chaine "brute"
   @out tableau traité
   @require <vector>, <string>, <sstream>
 */
std::vector<std::string> TraiteChaine(const std::string& chaine)
{
    // on utilise un istringstream pour gérer les choses
    std::istringstream iss(chaine);
    //il nous faut une chainte temporaire
    std::string mot;
    // et un tableau pour le résultat
    std::vector<std::string> resultat;
    // on va travailler tant que l'istringstream n'a pas été entièrement traité
    // en découpant le flux à chaque "
    while(std::cin(iss,mot,'\"'))
    {
        //Au premier passage, mot vaut "", et, comme on a des " " qui
        //séparent parfois deux chaines, on les supprime
        if(mot!="" && mot!=" ")
        {
            //Dans certains cas, il y a des espaces surnuméraires avant
            // et/ou apres, supprimons les
            mot=mot.substr(mot.find_first_not_of(" "),mot.find_last_not_of(" ")+1);
            //juste pour te montrer le fonctionnement
            std::cout<<mot<<std::endl;
            //et placement du résultat dans le tableau
            resultat.push_back(mot);
        }
    }
    //fini :D on renvoie le tableau créé
    return resultat;
}

Ceci dit, il faut se rendre compte de plusieurs choses:

Certains champs sont, définitivement, numériques
L'utilisation des caractères " pour délimiter les chaines n'est pas ce qui se fait de mieux (l'utilisation d'un caractere "non utilisé" (tabulation, "pipe", ...)pourrait faciliter les choses)

Il serait donc pas mal d'envisager:
La création d'une structure pour les différents champs, adaptés à ce qu'ils doivent contenir
de modifier la chaine pour ne pas forcément avoir les guillemets (hormis ceux qui doivent apparaitre dans une chaine)

La structure que je verrais bien est du genre de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
struct livre
{
    std::string titre;
    std::string heros; //collection, peut etre ??
    int tome; //je présumes que le 1, c'est pour "tome 1"???
    std::string senario; //voir qui a fait quoi dans le groupe ;)
    std::string dessin; //
    std::string coauteur;
    //manquent les deux "-" pour lesquels ils faudrait savoir ce qu'ils 
    //représentent :P
    bool lu; //dans le fichier, prendrait "0" si non lu, 1 si lu...
};

La chaine deviendrait alors du genre de

Code:

Nicolas Eymerich,Inquisiteur\tLa deesse\t1\tzentner\tsala\tdelcourt\t0\t_\t_\n

(les \t représentant des tabulations, tu t'en doutes peut etre :P)

La fonction de récupération de la chaine pourrait devenir

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
/* fonction qui utilise les modifications proposées
   @in référence sur la structure adequate
       chaine à traiter
 */
void TraiteChaine(const std::string& chaine, livre& enreg)
{
    // il nous faut toujours le flux istringstream
    std::istringstream iss(chaine);
    //il nous faudra parfois éviter un \t ou l'autre...
    char ignore;
    // les différentes chaines risquent d'avoir des espaces,  
    // on s'arrete donc au \t suivant
    std::getline(iss,recup.titre,'\t');
    std::getline(iss,recup.heros,'\t');
    iss>>recup.tome>>ignore;
    std::getline(iss,recup.senario,'\t');
    std::getline(iss,recup.dessin,'\t');
    std::getline(iss,recup.coauteur,'\t');
    iss>>recup.lu>>ignore;
    std::getline(iss,recup.chaine1,'\t');
    std::getline(iss,recup.chaine2,'\t');
}

et, l'affichage qui va bien avec la structure

Code:

1
2
3
4
5
6
7
8
9
10
 
    std::cout<<recup.titre<<std::endl
             <<recup.heros<<std::endl
             <<recup.tome<<std::endl
             <<recup.senario<<std::endl
             <<recup.dessin<<std::endl
             <<recup.coauteur<<std::endl
             <<recup.chaine1<<std::endl
             <<recup.chaine2<<std::endl
             <<( (recup.lu) ? "lu": "non lu")<<std::endl;

que tu peux, bien évidemment, agrémenter à ta guise ;)