Discussion :

[mido1951]

bonjour,
J'ai un fichier:

Code :

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

1
2
3
4
5
6
7
8
9
 
seq_id01,ch_idx,pos1,end1,GGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATTTTTTTTTTTTTTTTTCGACTACGCTACGACTCGATCACGATCC
seq_id01,ch_idy,pos2,end2,TTTTGGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATTTTTTCGACTACGCTACGGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATGATCC
seq_id01,ch_idd,pos3,end3,GCTAGCTACGACTACGACTACGCATAAAAAAAAAAAAAGACTACGCTACGACTCGATCACGATCC
seq_id02,ch_idv,pos1,end2,AAAAAAAAAAAAAAAACGATCACGACTACGATCGCATCAGCTAGCATTTTTTTTTTTTTTACGACTTTCGCGCTCAGCATCTGACTAC
seq_id02,ch_idu,pos2,end2,ACGACTAGCATCAGCATCTTTTTTTACGACGGGGGGGGGGGGGGCGCGCGCGCGAAAAAAAAAAAAAAAAAAAAAAAAAA
seq_id03,ch_idx,pos1,end1,TTTTTTCGATCGTATAAACGATCGACTCGCTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTCGACGATCACA
seq_id03,ch_idx,pos2,end2,AAAACATCAGCATCAGCTCGCCCCCCCCCCCCCCAGCATCAGCTAGCATCAGCTACGACTACGATCAGCTACGACTAAA
.......

Je veux recuperer les lignes mais je veux décomposer les lignes suivant les virgule(,) et stocker chaque partie dans une variable.
comment faire?

[takago]

Salut,

perso je ferais une liste chaînée, tu aura une case de liste par ligne, et dans cette case tu met un char **, comme sa tu pourra stoker chaque chaîne entre les virgules, et tu fait un next quand tu voie un '\0', tu malloc ton tab comme ceci :

Code :

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

tab = malloc(sizeof(char*)* 5)

et après tu malloc ton tab[0][case_a_malloc] de la taille de se que tu a lus jusque a ta virgule.
Je ne sais pas si je suis bien clair.

Cordialement,

Takago.

[ternel]

Un format de scanf tel que "%s,%s,%d,%d,%s" pourrait te servir. (en supposant que les positions sont des nombres).

En fouillant un peu plus, je suis sur que tu peux même indiquer les tailles max des champs.

[mido1951]

Salut,

perso je ferais une liste chaînée, tu aura une case de liste par ligne, et dans cette case tu met un char **, comme sa tu pourra stoker chaque chaîne entre les virgules, et tu fait un next quand tu voie un '\0', tu malloc ton tab comme ceci :

Code :

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

tab = malloc(sizeof(char*)* 5)

et après tu malloc ton tab[0][case_a_malloc] de la taille de se que tu a lus jusque a ta virgule.
Je ne sais pas si je suis bien clair.

Cordialement,

Takago.

Je veux éviter les listes chainée.
Je veux bien utiliser les tableaux. c-à dire stocker les valeurs dans un tableau.
est-ce qu'il y a une solution?
merci

[takago]

Salut,

Si tu veux utiliser uniquement les tableaux tu vas devoir utiliser un char *** ... Se qu'y n'est pas forcement évident, pour moi passer par une liste chaînée est beaucoup plus simple, et tu pourra accédé a tes valeurs plus facilement.

Takago.

[stendhal666]

Ton fichier a l'air d'être au bon vieux format csv...

1. Une solution pourrait donc être d'utiliser une librairie pour parser ce format, je suis sûr qu'il en existe plein (mais, expert plus en c++ qu'en c, je te laisse chercher :-)
2. White_tentacle a écrit un très bon article sur la question pour le C++ mais la logique est là pour le C également: http://www.developpez.net/forums/d15...pp-faire-faut/
3. Si tu veux un tableau tu auras un type homogène: que des strings, pas un mix int/strings, sauf à faire d'abord une structure perso, comme struct Line { int pos; int len; char* s; } puis un tableau de structs
4. Après c'est selon la performance exigée, la volonté de gérer les erreurs, etc. Il faut un peu plus de renseignements pour te mettre sur la piste

[stendhal666]

Au passage je confirme que la logique C serait plutôt de faire une liste chaînée car la gestion de la mémoire sera assez cauchemardesque si tu ne connais pas le nombre de lignes au départ.
Ton désir de tableau s'accorderait mieux avec un vector du C++...

[mido1951]

est-ce que je peux créer un enregistrement et stocker les valeurs de chaque ligne dans une variable? parexemple:

Code :

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

enregistm{char *seqid,char *cid; int posid; int endid; char *ch; }

qu'est ce que vous pensez de cette approche?
en plus j'ai pas pu diviser chaque variable (séparé par un virgule) apart. comment faire ici?
Merci

[ternel]

que ca serait possible, a condition de faire des malloc sur chaque pointeurs avant. Donc de connaitre la taille à allouer.

[takago]

Avec cette méthode tu vas vite avoir des soucis ... Tu a 5 variables une par valeur que tu recup, jusque la si tu n'a qu'une ligne dans ton fichier tu aura pas de souci mais vue que tu en un nombre indéterminé, u ne peux pas faire une fonction avec les adresses de tes variables.
Si tu lis ligne pas ligne, a chaque nouvelle ligne tu vas perdre les valeurs précédemment recéperais, pas top comme système.

Je le redis la façon la plus simple pour moi reste les listes chaînées, je ne voie vraiment pas pourquoi tu ne veux pas les utiliser.

[stendhal666]

est-ce que je peux créer un enregistrement et stocker les valeurs de chaque ligne dans une variable? parexemple:

Code :

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

enregistm{char *seqid,char *cid; int posid; int endid; char *ch; }

qu'est ce que vous pensez de cette approche?
en plus j'ai pas pu diviser chaque variable (séparé par un virgule) apart. comment faire ici?
Merci

1) pour l'approche enregistrements/lignes: soit tu connais le nombre de lignes (ou bien tu traverses tout le fichier pour compter les retours à la ligne) et dans ce cas-là l'approche est valable; soit non, et tu vas devoir faire beaucoup de réallocations et de copies
2) pour remplir tes enregistrements, tu peux utiliser sscanf à partir d'une chaîne de caractères:

Code :

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

1
2
3
4
5
6
7
 
const char* test = "abcd,efgh,12,14,abcdefghijkl";
 
  int posid, endid;
  char *seqid = (char*) malloc(5*sizeof(char)), *sid = (char*) malloc(5*sizeof(char)), *ch = (char*) malloc(15*sizeof(char));
 
  sscanf(test, "%[^,],%[^,],%d,%d,%[^\n]", seqid, sid, &posid, &endid, ch);

[ternel]

Et prends garde, quand tu fais les mallocs, de compter une case pour le \0.

[mido1951]

1) pour l'approche enregistrements/lignes: soit tu connais le nombre de lignes (ou bien tu traverses tout le fichier pour compter les retours à la ligne) et dans ce cas-là l'approche est valable; soit non, et tu vas devoir faire beaucoup de réallocations et de copies
2) pour remplir tes enregistrements, tu peux utiliser sscanf à partir d'une chaîne de caractères:

Code :

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

1
2
3
4
5
6
7
 
const char* test = "abcd,efgh,12,14,abcdefghijkl";
 
  int posid, endid;
  char *seqid = (char*) malloc(5*sizeof(char)), *sid = (char*) malloc(5*sizeof(char)), *ch = (char*) malloc(15*sizeof(char));
 
  sscanf(test, "%[^,],%[^,],%d,%d,%[^\n]", seqid, sid, &posid, &endid, ch);

merci cette solution marche pour mes premier test (sans faire l'enregistrement) mais ça veut dire quoi les

Code :

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

%[^,]

?
Merci

[takago]

Man sscanf.

[stendhal666]

%[^,] ça veut dire: mange tout ce qui n'est pas une virgule.

[mido1951]

Code :

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

1
2
3
4
5
6
7
8
9
 
seq_id01,ch_idx,pos1,end1,GGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATTTTTTTTTTTTTTTTTCGACTACGCTACGACTCGATCACGATCC
seq_id01,ch_idy,pos2,end2,TTTTGGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATTTTTTCGACTACGCTACGGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATGATCC
seq_id01,ch_idd,pos3,end3,GCTAGCTACGACTACGACTACGCATAAAAAAAAAAAAAGACTACGCTACGACTCGATCACGATCC
seq_id02,ch_idv,pos1,end2,AAAAAAAAAAAAAAAACGATCACGACTACGATCGCATCAGCTAGCATTTTTTTTTTTTTTACGACTTTCGCGCTCAGCATCTGACTAC
seq_id02,ch_idu,pos2,end2,ACGACTAGCATCAGCATCTTTTTTTACGACGGGGGGGGGGGGGGCGCGCGCGCGAAAAAAAAAAAAAAAAAAAAAAAAAA
seq_id03,ch_idx,pos1,end1,TTTTTTCGATCGTATAAACGATCGACTCGCTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTCGACGATCACA
seq_id03,ch_idx,pos2,end2,AAAACATCAGCATCAGCTCGCCCCCCCCCCCCCCAGCATCAGCTAGCATCAGCTACGACTACGATCAGCTACGACTAAA
.......

en continuité avec ce problème, j'ai stocké les différentes valeurs en utilisant un enregistrement.
Mais mois je ne vais pas remplir les enregistrements avec toutes les lignes du fichier, je veux juste stocké dans un tableau d'enregistrement les lignes qui ont les mêmes seq_id.
par exemple, je veux prendre :

Code :

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

1
2
3
seq_id01,ch_idx,pos1,end1,GGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATTTTTTTTTTTTTTTTTCGACTACGCTACGACTCGATCACGATCC
seq_id01,ch_idy,pos2,end2,TTTTGGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATTTTTTCGACTACGCTACGGTGCTTCAAACGTTTTTTTTTTTACGACTAGCATGATCC
seq_id01,ch_idd,pos3,end3,GCTAGCTACGACTACGACTACGCATAAAAAAAAAAAAAGACTACGCTACGACTCGATCACGATCC

et stocké ces trois lignes dans un tableau d'enregistrement pour faire un certain traitement.
puis stocké les seq_id02 dans un tableau d'enregistrement (le même tableau en écrasant l'ancien) par exemple on obtient:

Code :

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

1
2
seq_id02,ch_idv,pos1,end2,AAAAAAAAAAAAAAAACGATCACGACTACGATCGCATCAGCTAGCATTTTTTTTTTTTTTACGACTTTCGCGCTCAGCATCTGACTAC
seq_id02,ch_idu,pos2,end2,ACGACTAGCATCAGCATCTTTTTTTACGACGGGGGGGGGGGGGGCGCGCGCGCGAAAAAAAAAAAAAAAAAAAAAAAAAA

et ainsi de suite...
est-ce que vous avez une idée?
Merci

[sben42]

Bonjour,

Pas vraiment d'idées désolé..
Par contre j'en profite de passer par là pour vous conseillez de bien vérifier le retour de malloc.

Celui-ci renvoi NULL en cas d’échec, ce qui provoque une erreur de segmentation lors du déréférencement.. (NULL n'étant pas une adresse valide ^^).

De plus (mais là c'est à prendre avec des pincettes, je ne suis pas sûr de moi, et l'avis de quelqu'un de plus expérimenté serait appréciable), il faut penser en cas d'erreur d'un malloc de free tous les malloc précédents ayant réussis.

Bon courage!

[Bktero]

De plus (mais là c'est à prendre avec des pincettes, je ne suis pas sûr de moi, et l'avis de quelqu'un de plus expérimenté serait appréciable), il faut penser en cas d'erreur d'un malloc de free tous les malloc précédents ayant réussis.

Et tu as raison.

[mido1951]

est-ce qu'il y a d'autres suggestions? ou d'autres approches?
Merci

[stendhal666]

Tu as deux approches: statique et dynamique.

Dans l'approche statique tu évites d'utiliser trop de pointeurs (cela devrait te faire plaisir si je ne me trompe pas!):

- voilà ton enregistrement:

Code :

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

1
2
3
4
5
6
struct Enregistrement{
  char seqId[20];
  char chId[20];
  int posid, endid;
  char ch[100];
} ;

- voilà ton tableau:

Code :

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

struct Enregistrement tableau[TAB_SIZE];

et voilà la logique générale:

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
 
  char *line, *precedent;
  size_t lus;
  int i, read;
 
  line = precedent = NULL;
  i = 0;
  while ( true ) {
 
      read = getline(&line, &lus, input); // on lit une ligne du fichier
      struct Enregistrement enr;
 
      if (read != -1) { // si on a bien lu une ligne (sinon getline renvoie -1)
        peuplerEnregistrement(line, &enr); // avec sscanf
      }
 
      if (read == -1 || // si on en a fini avec le fichier ou que... 
          precedent && strcmp(enr.seqId, precedent) != 0) { // il y a une ligne précédente et qu'elle est différente de la nouvelle ligne
          utliserLignesLues(tableau, i) // traiter les lignes du tableau de 0 à i
          i = 0; // et réinitialiser i
      }
 
      precedent = enr.seqId;
      tableau[i] = enr;
      free(line); line = NULL;
      lus = 0;
      ++i;
      if (read == -1) break; // si on est arrivés à la fin du fichier on quitte
  }

Avec l'approche statique, le problème est que tu dois être sûr de la longueur des différents éléments: caractères dans les strings, nombre de lignes dans le tableau.
Avec une approche dynamique tu alloues la mémoire, et si tu dépasses ton allocation initiale tu réalloues de la mémoire supplémentaire et surtout tu n'oublies pas de la libérer...