C++lire un fichier string dans un tableau ...

Tu m'as dit qu'un programme était d'autant plus optimisé qu'il était facile à comprendre; très bien je suis d'accord mieux on le comprend, plus il vas vite.

Non ce n'est pas ce que j'ai dit du tout. J'ai parlé de complexité algorithmique, si tu regardes le lien que je t'ai donné tu verras que ce n'est pas ça.

Mais quand tu mes: des "size(n)...ou [++j] et des bazars pareil, pour réécrire dans le fichier par exemple, je trouve ça complexe à comprendre.

Si tu regardes la doc de la STL tu verras que la méthode size() appliquée à un vector n'a rien de sorcier... ça récupère juste le nombre d'éléments :
https://community.hpe.com/t5/custom/page/page-id/HPPSocialUserSignonPage?redirectreason=permissiondenied&referer=https%3A%2F%2Fcommunity.hpe.com%2Ft5%2FServers-Systems-The-Right%2FSGI-com-Tech-Archive-Resources-now-retired%2Fba-p%2F6992583

L'opération ++j ne sert qu'à incrémenter j, en d'autres termes ça fait "j = j +1".

Mais je débute aussi je suis sûr quand allant voir tes liens je finirai par comprendre et à trouver cela logique

Je te le souhaite, d'autant plus que char sniper semble lui aussi prêt à t'aider ;-) Mais dans l'immédiat prends le temps de lire les liens que je t'ai indiqué, c'est à mon avis la prochaine étape pour que tu puisses progresser.

Au départ je ne pensais pas que quelqu'un viendrait s'emmerder à venir aider un débutant.

Pour moi char sniper n'aurait pas dû répondre si ça l'emmerdait. Car ça ne te permet pas d'avancer et c'est le principal objectif du fil de discussion.

En contrepartie, il ne faut pas que tu perdes de vue que les contributeurs du forum CCM passent leur temps libre à aider gratuitement les personnes qui postent sur CCM. C'est donc la moindre des choses de prendre le temps de comprendre et de lire ce qu'ils écrivent, car tout le temps qu'ils te consacrent, c'est du temps qu'ils ne consacrent pas aux autres.

Cependant je ne te jette pas spécialement la pierre. Le C++ n'est pas forcément simple à appréhender donc il faut prendre le temps de s'en imprégner.

Je me suis en effet grandement inspiré de ton code, mamiemando mais je l'ai un peu remanier à ma façon.

Pas de problème c'est fait pour. J'ai écrit quelque chose qui me paraît bien codé mais je conçois tout à fait que tu veuilles arranger le code à ton idée si ça correspond plus à ton besoin ou que ça te permet de mieux le comprendre. Attention toutefois à ne pas faire des modifications qui engendrent une diminution des performances, la manière dont je l'ai écrit ne sort pas du chapeau ;-)

C'est à dire que j'ai beaucoup appris sur le site du zéro et je trouve leur manière de coder très facile à comprendre.

Tout à fait c'est un excellent site pour démarrer. Toutefois la vocation du site du zéro, c'est de permettre de démarrer aux débutants en leur donnant un excellent aperçu d'une technologie. Dès que tu devras aborder des notions plus pointues, il faudra sans doute te référer à d'autres sources.

dans le site du zéros il font ça ou alors j'ai rêvé et c'est une mauvaise habitude que j'ai prise désolé.

En fait la seule chose importante c'est que tu comprennes parfaitement ce que tu écris (ou ce qu'on a pu écrire dans les codes que char sniper et moi-même t'avons proposé). C'est ce qui te permettra de progresser et d'appréhender pleinement ce langage.

Ainsi, si certains points de code sont encore un peu obscurs, n'hésite pas à poser des questions. Je t'invite également à prendre le temps de lire le lien que je t'ai donné auparavant sur la STL.
http://www.commentcamarche.net/faq/sujet 11255 introduction a la stl en c standard template library#les iterators

C'est un tutoriel que j'ai pris le temps d'écrire pour les gens qui comme toi découvrent la STL. On y aborde les différents containers de la STL, leurs avantages et inconvénient et comment les manipuler.

Ce que tu dois conserver à l'esprit, c'est que les performances d'un programme découlent de sa complexité (au sens complexité algorithmique, par exemple O(n) pour un algorithme qui croit en temps linéaire). Un programme est d'autant plus performant que sa complexité est faible (comprendre : plus la complexité est faible, moins l'ordinateur à de calculs à effectuer pour trouver le résultat).

Par exemple dans un std::vector, l'accès à la nième case est en O(1) (accès immédiat), alors que dans une liste, il est en O(n) (car il faut parcourir n éléments avant d'y accéder). Ainsi un vector est plus efficace à l'accès. Pour supprimer une case ou un maillon, dans un vector il faut décaler toute les cases qui suivent (complexité en O(n)), alors que dans un liste, il faut juste corriger le maillage de la liste (complexité O(1) si on connaît la position du maillon en question).

Si ces notions sont un peu obscures pour toi je t'invite vivement à lire :
https://fr.wikipedia.org/wiki/Complexit%C3%A9_algorithmique

Ainsi dans ton cas les deux approches sont a peu près équivalentes (O(n) dans les deux cas). L'avantage de la liste, c'est qu'en mémoire ce n'est pas un espace continue contrairement à un vector. Or il est plus difficile de de disposer d'un bloc de 1 000 000 éléments placés les uns à la suite des autres qu'un peu partout en mémoire. C'est pour cette raison que je te disais que si les fichiers ne sont pas trop gros on peut s'en sortir avec des vectors, mais sinon il est préférable d'utiliser des lists.

En espérant que tout ceci est plus clair pour toi,
Bonne chance

j'ai enfin compris ce que tu voulais dire Char Sniper à propos du string ligne

dans le site du zéros il font ça ou alors j'ai rêvé et c'est une mauvaise habitude que j'ai prise désolé.

Un peu de calme tout les deux, ou je sévis.

Philipal, je te propose de regarder à tête reposée la solution que je t'ai proposé. Si certains points t'échappent, n'hésite pas à me le dire et j'essaierai de détailler. Je précise que dans mes réponses tu as environ 95% du code final que tu cherches à écrire (et les 5% restants sont triviaux à écrire).

Ce que tu dois retenir, c'est que ton programme est très simple à écrire si tu es familier de la STL. Comme tu sembles découvrir les différentes classes (std::ifstream, std::ofstream, std::list, std::vector....) la première étape est de te familiariser avec. Tu peux en particulier retrouver les méthodes disponibles pour chacune de ces classes ici :
https://community.hpe.com/t5/custom/page/page-id/HPPSocialUserSignonPage?redirectreason=permissiondenied&referer=https%3A%2F%2Fcommunity.hpe.com%2Ft5%2FServers-Systems-The-Right%2FSGI-com-Tech-Archive-Resources-now-retired%2Fba-p%2F6992583

Char Sniper, le mieux serait de laisser le temps à Philipal pour qu'il intègre ce qu'on lui a expliqué. La STL n'est pas forcément simple à appréhender, il est donc normal qu'il soit un peu perdu. Je compte sur toi pour faire preuve de patience par la suite. Pour apporter une aide efficace, il faut non seulement être clair/compétent/pédagogue, mais aussi et surtout patient et diplomate.

Bonne continuation à tout les deux.

he o du calm

vous etes tellement compliquer que j'avais rien compris et g pas fait attention a la fonction

pour l'argument ligne tu as raison i sert a rien lol

je sais que il fo bcp de patience ac les gens qui débute mais c pas une raison pour devnir injurieux

J'ai l'impression de parler dans le vide.
A quoi te sert ton putain d'argument ligne ? ???? non seulement tu ne l'utilise pas, mais en plus tu entre en conflit plus loin ! (4ème fois que je le répète)
Sort moi cette putain de merde liste de la porté du if !! comment veux tu t'en servir autrement (3ème fois que je le répète)
Utilise les balise de code pour mettre le C++ (3ème fois que je le répète).
"cin >> ; //je sais pas ce que je dois mettre comme variable; "
On s'en fout, mets ce que tu veux.
"//je sais pas comment on supprime avec les vector; "
Mamiemando a déjà donné la solution.
Je crois que je ne vais plus répondre tant que tu n'aura pas pris en compte tout ça.

c bon g trouver qqun de sympas sur un autre forum qui a montré une fonction pour supprimer une ligne dans un vector

voici donc ma fonction supprimer, déstiner a tt ceux qui comme moi galere en c++ et ce font agresser par des programmeurs qui on oublier ce que c que d'apprendre

et ceux qui aime pas les fautes d'orthographe dans les forum, nos message ne sont pas des rédaction destiner au ministres j'estime donc que si les gens veulent ecrire en phonetique dans un forum pour aller plus vite c leur droit. en plus on est des programeur pas des prof de français

void salles::suppr(string ligne,int i)
{
vector<string> v;
//lecture du fichier et mise des lignes dans le vecteur
ifstream fichier("salles.txt", ios::in);
if(fichier)
{
string ligne;
int i;
while(getline(fichier, ligne))
{
v.push_back(ligne);
}
fichier.close();
}
else // sinon
{
cerr << "Erreur à l'ouverture !" << endl;
}

//suppression d'une ligne au choix de l'utilisateur
cout << "Veuillez indiquer la ligne que vous voulez effacer:" << "\n" << endl;
cin >> i;
v.erase(v.begin() + i);<------voici la fonction la plus improtante sans elle vous effacer rien du tout

//ecriture du vecteur dans le fichier
ofstream file("salles.txt", ios::out);
if(file)
{
size_t n = v.size();
for(size_t i=0;i<n;++i) file << v[i] << std::endl;
}
else
{
cerr << "Erreur à l'ouverture !" << endl;
}
}

et pour terminer voici le site sur lequelle g trouver la fonction miracle merci a lui:
https://openclassrooms.com/forum/sujet/supprimer-des-cases-d-un-std-vector-23504

slt a tous

tt le monde appren a un moment donné

j'essay de comprendre mais c pas evident

j'ai refais le code si tu savais le regarder et me dire comment supprimer avec les vector

ça serai cool je cherche de mon coter aussi

void salles::suppr(string ligne)
{
//lecture du fichier et mise des lignes dans le vecteur
ifstream fichier("salles.txt", ios::in);
if(fichier)
{
vector<string> v;
string ligne;
while(getline(fichier, ligne))
{
v.push_back(ligne);
}
fichier.close();
}
else // sinon
{
cerr << "Erreur à l'ouverture !" << endl;
}

//suppression d'une ligne au choix de l'utilisateur
cout << "Veuillez indiquer la ligne que vous voulez effacer:" << "\n" << endl;
cin >> ; //je sais pas ce que je dois mettre comme variable;
//je sais pas comment on supprime avec les vector;

//ecriture du vecteur dans le fichier
ofstream file("salles.txt", ios::out | ios::app);
if(file)
{
size_t n = v.size();
for(size_t i=0;i<n;++i) file << v[i] << std::endl;
}
else
{
cerr << "Erreur à l'ouverture !" << endl;
}
}

Là tu m'énerves !
tes erreurs sont dues à ce que je te répète depuis un moment (porté).
perdu ? efface tout et recommence.

slt

mamiemando ma dit de suivre ces instruction si non ca marcherai pas

maitenant chui encore plus perdu qu'avan

Ton code n'est pa très compréhensble, utilise les balises de code pour mettre le source.
Comme je t'ai dit : attention au problèmes de conflit et de porté, ce n'est pas du fortran, pas besoin de redéfinir les variables passées en paramètre.
tu as string line en paramètre, et plus loin tu redéfini une variable line !
écris nous un code plus propre prenant en compte toutes les remarques faites ici et ailleurs.

je viens de compiler

voici mon code avec les erreurs marquées avec les "<--------------------"

pour la 2e erreurs v est il un entier ou un string? ou autre chose?

la 1ere erreur je sais pas du tout de quoi il s'agit.

void salles::suppr(string line,int j)
{
//lecture du fichier et mise des lignes dans le vecteur
const char *filename = "salles.txt";
ifstream ifs(filename);
if(!ifs)
{
std::cerr << "can't read " << filename << std::endl;
return;
}
else // sinon
{
std::vector<std::string> v;
std::string line;
while(std::getline(ifs, line))
{
v.push_back(line);
}
ifs.close();
}

//suppression d'une ligne au choix de l'utilisateur
cout << "Veuillez indiquer la ligne que vous voulez effacer:" << "\n" << endl;
cin >> j; // est ce la bonne variable?
void remove_line(std::vector<std::string> & v,std::size_t no_line)
{//<-----------------------------------------------------------------------------error: a fonction-definition is not allowed here before '{' token
std::size_t n = v.size();
for(std::size_t j=no_line+1;j<n;++j) v[j] = v[j+1];
v.resize(n-1);
}

//ecriture du vecteur dans le fichier
const char *filename_out = "salles.txt";
std::ofstream ofs(filename_out);
if(!ofs)
{
std::cerr << "can't write " << filename_out << std::endl;
return;
}
else
{
std::size_t n = v.size();//<-------------------------------------------------error: 'v' was not declared in this scope
for(std::size_t i=0;i<n;++i) ofs << v[i] << std::endl;
}
}

mais il y a le problème de suppression qui n'est pas évident.

Cher char sniper... si c'est simple et voici comment faire :
http://www.commentcamarche.net/forum/affich 11989094 c lire un fichier string dans un tableau?#17

Pas besoin de QT pour un programme aussi simple pourquoi pas une bombe nucléaire ;-) Avec le recul la meilleure solution c'est les listes comme j'ai indiqué dans mon message précédent, mais si le fichier est de taille raisonnable, on s'embête pas et on peut directement faire un vector.

voila le code que j'ai réussi à faire selon tes indications

1. dois-je rajouter quelque choses dans l'entête de ma fonction "suppr"? je parle de ce qu'il y a entre ( )

2. puis-je supprimer les "std::" qu'il y a un peu partout sachant qu'au début de mon programme j'ai écris:
"using namespace std" ?

3. je ne comprend pas bien quand il s'agit de supprimer une ligne. Après que j'ai poser la question à l'utilisateur:"quelle ligne voulez-cous supprimer" juste en-dessous je met un "cin >>...." . quelle variable dois-je mettre pour qu'il prenne en compte le numéro de la ligne à supprimer?

void salles::suppr(string line)
{
//lecture du fichier et mise des lignes dans le vecteur
const char *filename = "salles.txt";
ifstream ifs(filename);
if(!ifs)
{
std::cerr << "can't read " << filename << std::endl;
return 1;
}
else // sinon
{
std::vector<std::string> v;
std::string line;
while(std::getline(ifs, line))
{
v.push_back(line);
}
ifs.close();
}

//suppression d'une ligne au choix de l'utilisateur
cout << "Veuillez indiquer la ligne que vous voulez effacer:" << "\n" << endl;
cin >> //je sais pas ce que je dois mettre comme variable;
void remove_line(std::vector<std::string> & v,std::size_t no_line)
{
std::size_t n = v.size();
for(std::size_t j=no_line+1;j<n;++j) v[j] = v[j+1];
v.resize(n-1);
}

//ecriture du vecteur dans le fichier
const char *filename_out = "salles.txt";
std::ofstream ofs(filename_out);
if(!ofs)
{
std::cerr << "can't write " << filename_out << std::endl;
return 2;
}
else
{
std::size_t n = v.size();
for(std::size_t i=0;i<n;++i) ofs << v[i] << std::endl;
}
}

désolé pour les fautes plus haut.
n'hésite pas à me communiquer les erreurs de mon code

merci

J'avais bien pensé à vector, mais il y a le problème de suppression qui n'est pas évident.
L'idéale serait d'avoir un conteneur vector où l'on puisse faire v.erase(i).
Le problème de list c'est qu'on n'y accède pas facilement avec un index.Bref, rien de parfait.
L'idéal serait un QStringList

Comme tu préfères mais là c'est déjà presque cuit avec le code que je t'ai donné. Merci de soigner l'orthographe dans tes messages.

Bonne chance

Si tu ne suis pas mes indications ça ne peut pas marcher. Ouvre le fait que tu continues à trimballer des flags pour ouvrir tes fichiers (ce qui ne sert à rien si tu fais comme je t'ai indiqué), la structure de liste ne convient pas car les lignes ne sont pas indexées. Du coup pour supprimer le ième maillon tu es obligé de parcourir la liste (soit i itérations pour trouver le maillon) au lieu d'y accéder immédiatement comme avec un vector.

A la limite pourquoi pas, c'est moins pas forcément plus coûteux que de décaler les cases d'un vecteur. Cependant, il faut alors que chaque maillon de la liste soit un std::pair<unsigned,std::string>, c'est-à-dire un couple (numéro de ligne, contenu de la ligne) qu'il faudra réindexer à chaque suppression de ligne.

Si tu ne connais pas les iterators lis au préalable :
http://www.commentcamarche.net/faq/sujet 11255 introduction a la stl en c standard template library#les iterators

Ainsi, la liste en question se construit comme suit :

std::list<std::pair<unsigned,std::string> > l;
std::string line;
for(unsigned no_line = 0;std::getline(ifs, line);++no_line){
  l.push_back(std::make_pair(no_line,line));
}

... et la suppression :

void remove_line(std::list<std::pair<unsigned,std::string> > & l,std::size_t no_line){
  unsigned j;
  std::list<std::pair<unsigned,std::string> >::iterator
    lerase(l.begin()),
    lit   (l.begin()),
    lend  (l.end());
  for(std::size_t j=0;lit!=lend;++j,++lit){
    if(j == no_line){
      lerase = lit;
    }else if(j > no_line){
      --(lit->first); // on décrémente l'index des maillons situé après
    }
  }
  l.erase(lerase);
}

Le principal intérêt de la std::list est que tu pourras traiter de très gros fichiers car ta structure ne sera pas allouée sur une plage mémoire continue.

Je passe sur les "mauvaises" habitudes qui consiste à omettre le std:: via un using namespace std; ou l'utilisation de headers antiques de la STL (genre <list.h> au lieu de <list>). En fait le seul cas où tu peux utiliser un using namespace std; "proprement" est dans un fichier .cpp. En tout cas, il ne faut jamais le faire dans un header (.hpp).

Le principal défaut de ton ton programme est qu'il utilise un tableau alloué statiquement avec N cases, or le jour ou ce N est inférieur au nombre de ligne du fichier, ça ne marche plus. Si au contraire tu utilises des push_back, tu peux t'affranchir.

Bonne chance

Il y a beaucoup plus simple.

1) Au niveau de l'ouverture du fichier déjà :

a) pour ouvrir un fichier en lecture :

#include <fstream>
#include <iostream>

int main(){
  const char *filename = "plop.txt";
  std::ifstream ifs(filename);
  if(!ifs){
    std::cerr << "can't read " << filename << std::endl;
    return 1;
  }

  // ...

  ifs.close();

  // ...

  return 0;
}

b) Pour ouvrir un fichier en écriture, même chose avec un std::ofstream

2) Pour stocker ton fichier, il suffit d'utiliser une std::vector<std::string> ou éventuellement une std::map<unsigned,std::string> qui associe à chaque numéro de ligne le contenu de la ligne. Lorsque tu lis ton fichier ligne par ligne il suffit juste d'utiliser la méthode push_back si tu utilises un vector et directement l'opérateur [] si tu utilises une map.

std::vector<std::string> v;
std::string line;
while(std::getline(ifs, line)){
  v.push_back(line);
}

A présent v[i] contient bien la ligne i (ou 0 désigne la première ligne du fichier). Pour supprimer une ligne il suffit donc d'écrire pour j allant de i+1 à v.size()-1 la case [j+1] dans la case j et de redimensionner le std::vector avec la méthode resize :

void remove_line(std::vector<std::string> & v,std::size_t no_line){
  std::size_t n = v.size();
  for(std::size_t j=no_line+1;j<n;++j) v[j] = v[j+1];
  v.resize(n-1);
}

Pour écrire ton fichier il ne reste plus qu'à ouvrir un std::ofstream et écrire le contenu du vector dedans :

int main(){

  //...

  // Ouvrir le fichier en écriture
  const char *filename_out = "plop2.txt";
  std::ofstream ofs(filename_out);
  if(!ofs){
    std::cerr << "can't write " << filename_out << std::endl;
    return 2;
  }

  // Écrire le fichier
  {
    std::size_t n = v.size();
    for(std::size_t i=0;i<n;++i) ofs << v[i] << std::endl;
  }

  return 0;
}

Bonne chance

je pense avoir compris.
Ta fonction a comme argument "string tab", et ensuite, on redéfini une variable tableau du nom de tab -> conflit.
En plus, il faut sortir "string tab[100]" de la porté du if, sinon il risque d'y avoir des soucis aussi.