Bonjour

Je dispose d'un fichier .txt dans lequel j'ai écris, à la base, la phrase suivante :

Bonjour, je suis une phrase ecrite dans un fichier.

J'aimerai déplacer le curseur entre "Bonjour" et la virgule pour y écrire " tout le monde". En testant le code suivant, comme prévu, la console indique que le curseur se retrouve après le 7 ème caractère :

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

using namespace std;

int main()
{
    string const nomFichier("C:/Users/User/Documents/programme code blocks/programme en C++/modification_et_lecture_de_fichiers/scores.txt");
    /*Déclaration d'un flux permettant d'écrire
    dans le fichier sans écrasement*/
    ofstream monFlux(nomFichier.c_str(),ios::app);

    int position = monFlux.tellp(); //On récupère la position
    cout << "Nous nous situons au " << position << "eme caractere du fichier." << endl;

    monFlux.seekp(7, ios::beg);
    position = monFlux.tellp(); //On récupère la position
    cout << "Nous nous situons maintenant a son " << position << "eme caractere." << endl;
    monFlux << " tout le monde";

    return 0;
}

Le problème est qu'au lieu d'écrire le bout de phrase entre "Bonjour" et le virgule dans la phrase, le code va au bout de la phrase, et reviens à la ligne avant de l'écrire. Voici le fichier txt après avoir compilé deux fois :

Il semblerait donc qu'il manque une instruction pour empêcher ce comportement et compléter ce code. Quelqu'un connaîtrait-il une instruction qui permet cela ?

Cordialement

-
Edité par 1Stark 8 juin 2023 à 9:54:11

Hm j'ai pas + d'infos que ça, mais avec mes maigres connaissances:

std::ios::app va écrire à partir de la fin du fichier, peu importe la "position" du caractère que tu lis. Peut être qu'il existe une manière de manipuler monflux ? Personnellement, avec ce que je sais, je stockerai le contenu du fichier dans une variable et je le manipulerai avec les outils fournis avec std::string, pour ensuite le réécrire dans le fichier.

Mais si quelqu'un a mieux .. 😶

Un flux n'est pas un "tampon texte" d'une interface utilisateur, où ce que l'on tape s'insère à l'endroit du curseur (si on est en mode insertion)

Y a pas de mode insertion. Le texte qu'on envoie se dépose à partir de l'endroit indiqué, en effaçant ce qui y est déjà.

PS et la documentation https://cplusplus.com/reference/fstream/ofstream/ofstream/  dit, à propos des modes

Flags describing the requested input/output mode for the file.
This is an object of the bitmask member type<samp>openmode</samp>that consists of a combination of the following member constants:

Vérifions :

• on envoie une série de trucs dans le flux de sortie
•  on se positionne dedans
• on envoie une chaine
• on regarde

void ecriture() {
    const string nomFichier = "sortie.txt";
    ofstream sortie{nomFichier, ios_base::app}; // C++11

    sortie << "0123456789";
    sortie.seekp(ios_base::beg + 2);
    sortie << "COUCOU";
    sortie.close();
}

$ ./prog ; cat sortie.txt
0123456789COUCOU

$ ./prog ; cat sortie.txt
0123456789COUCOU0123456789COUCOU

$ ./prog ; cat sortie.txt
0123456789COUCOU0123456789COUCOU0123456789COUCOU

$ ./prog ; cat sortie.txt
01COUCOU89

le seekp est effectif et permet de revenir en arrière. Mais ça n'insère pas.

-
Edité par michelbillaud 8 juin 2023 à 21:35:19

La solution de facilité est d'utiliser un std::string pour le tampon en mémoire, vu qu'il y a des fonctions insert, replace etc.

Mais si on en fait un usage intensif avec des gros tampons, ça va pas être idéal comme performances. Insérer ou remplacer, à tous les coups ça déménage tout ce qu'il y a dans le tampon après le point d'insertion.

Si ça pose un problème, il faut se creuser pour trouver une structure de données plus adaptée.

Autrefois, on faisait des trucs comme ça :  un grand tableau qui contient

• au début du tableau : le début du contenu, jusqu'au point d'insertion
• à la fin : la suite

Pas certain de te suivre michelbillaud.

Je lis tout le fichier d'un seul bloc.

Je saisis le texte à inséérer dans un autre "bloc" (string).

J'écris le début jusqu'au point d'insertion, puis la partie saisie, puis la partie après le point d'insertion.

Je n'ai rien inséré ni déplacé en mémoire.

Bien sûr, je suis obligé de lire le fichier au complet et d'en écrire un autre au complet.

En lecture écriture sur le même fichier :

#include <fstream>
#include <sstream>
#include <string>

int main()
{
    constexpr int pos = 7;
    std::fstream file("scores.txt", std::ios::in | std::ios::out);
    file.seekp(pos);
    std::stringstream stream;
    stream << file.rdbuf();
    file.seekp(pos);
    file << " tout le monde";
    file << stream.rdbuf();

    return 0;
}

-
Edité par rouIoude 9 juin 2023 à 21:00:43

PierrotLeFou a écrit:

Pas certain de te suivre michelbillaud.

Je saisis le texte à inséérer dans un autre "bloc" (string).

J'écris le début jusqu'au point d'insertion, puis la partie saisie, puis la partie après le point d'insertion.

Je n'ai rien inséré ni déplacé en mémoire.

Tu n'inseres pas dans une structure de donnees existante. Tu construis une autre structure, une copie, a partir de début du texte, du truc à ajouter et de la suite.

Si c'est pour mettre le résultat dans le fichier que tu as lu, ça va tout copier.

De mon côté, je parlais des tampons pour lesquels l'opération fréquente  (privilegiée) est d'insérer à l'endroit du "curseur"

Salut,

Avec les fichiers, il n'y pas 36 solutions, et sauf si ton fichiers fait des centaines de Mo, le plus simple est encore de monter toutes tes données en mémoire, les mettre à jour, et les réécrire.

Point d'attention:
Si la quantité de données à réécrire est inférieur à la quantité lue, il te faudra:
1) Fermer le fichier (de toutes façons, garder un fichier ouvert trop longtemps n'est pas une bonne idée).
2) Supprimer le fichier.
3) Le réécrire.
Et ce pour la simple raison que l'on ne sais pas "diminuer" la taille d'un fichier.

• des tampons en mémoire
• des intervalles du fichier d'origine.