Comment ouvrir un fichier en C++ ?

Question

Je souhaite ouvrir un fichier en lecture, à la manière C++.Je dois pouvoir le faire pour :

• fichiers texte, qui impliqueraient une sorte de fonction de lecture de ligne.

• fichiers binaires, qui fourniraient un moyen de lire des données brutes dans un char* tampon.

Answer 1

Il existe trois façons de procéder, en fonction de vos besoins.Vous pouvez utiliser la méthode C à l'ancienne et appeler fopen/fread/fclose, ou vous pouvez utiliser les fonctionnalités fstream C++ (ifstream/ofstream), ou si vous utilisez MFC, utiliser la classe CFile, qui fournit des fonctions pour accomplir des tâches réelles. opérations sur les fichiers.

Tous ces éléments conviennent à la fois au texte et au binaire, bien qu'aucun n'ait une fonctionnalité de lecture spécifique.Ce que vous feriez probablement à la place dans ce cas est d'utiliser les classes fstream (fstream.h) et d'utiliser les opérateurs de flux (<< et >>) ou la fonction read pour lire/écrire des blocs de texte :

int nsize = 10;
char *somedata;
ifstream myfile;
myfile.open("<path to file>");
myfile.read(somedata,nsize);
myfile.close();

Notez que si vous utilisez Visual Studio 2005 ou une version ultérieure, le fstream traditionnel peut ne pas être disponible (il existe une nouvelle implémentation Microsoft, légèrement différente, mais qui accomplit la même chose).

Answer 2

Vous devez utiliser un ifstream si vous voulez juste lire (utilisez un ofstream écrire, ou un fstream pour les deux).

Pour ouvrir un fichier en mode texte, procédez comme suit :

ifstream in("filename.ext", ios_base::in); // the in flag is optional

Pour ouvrir un fichier en mode binaire, il suffit d'ajouter le flag "binary".

ifstream in2("filename2.ext", ios_base::in | ios_base::binary ); 

Utilisez le ifstream.read() fonction pour lire un bloc de caractères (en mode binaire ou texte).Utilisez le getline() fonction (c'est global) pour lire une ligne entière.

Answer 3

Pour ouvrir et lire un fichier texte ligne par ligne, vous pouvez utiliser ce qui suit :

// define your file name
string file_name = "data.txt";

// attach an input stream to the wanted file
ifstream input_stream(file_name);

// check stream status
if (!input_stream) cerr << "Can't open input file!";

// file contents  
vector<string> text;

// one line
string line;

// extract all the text from the input file
while (getline(input_stream, line)) {

    // store each line in the vector
    text.push_back(line);
}

Pour ouvrir et lire un fichier binaire, vous devez déclarer explicitement que le format de lecture de votre flux d'entrée est binaire et lire la mémoire qui n'a pas d'interprétation explicite à l'aide de la fonction membre du flux. read():

// define your file name
string file_name = "binary_data.bin";

// attach an input stream to the wanted file
ifstream input_stream(file_name, ios::binary);

// check stream status
if (!input_stream) cerr << "Can't open input file!";

// use function that explicitly specifies the amount of block memory read 
int memory_size = 10;

// allocate 10 bytes of memory on heap
char* dynamic_buffer = new char[memory_size];

// read 10 bytes and store in dynamic_buffer
file_name.read(dynamic_buffer, memory_size);

En faisant cela, vous devrez #include l'en-tête : <iostream>

Answer 4

#include <iostream>
#include <fstream>
using namespace std;

int main () {
  ofstream file;
  file.open ("codebind.txt");
  file << "Please writr this text to a file.\n this text is written using C++\n";
  file.close();
  return 0;
}

Answer 5

#include <iostream>
#include <fstream>
using namespace std;

void main()
{
    ifstream in_stream; // fstream command to initiate "in_stream" as a command.
    char filename[31]; // variable for "filename".
    cout << "Enter file name to open :: "; // asks user for input for "filename".
    cin.getline(filename, 30); // this gets the line from input for "filename".
    in_stream.open(filename); // this in_stream (fstream) the "filename" to open.
    if (in_stream.fail())
    {
        cout << "Could not open file to read.""\n"; // if the open file fails.
        return;
    }
    //.....the rest of the text goes beneath......
}

Answer 6

Suis les étapes,

1. Incluez les fichiers d'en-tête ou l'espace de nom pour accéder à la classe File.
2. En fonction de votre plate-forme IDE (c’est-à-dire CFile,QFile,fstream).
3. Maintenant, vous pouvez facilement trouver ces méthodes de classe pour ouvrir/lire/fermer/getline ou bien n’importe quel fichier.

CFile/QFile/ifstream m_file;
m_file.Open(path,Other parameter/mood to open file);

Pour lire un fichier, vous devez créer un tampon ou une chaîne pour enregistrer les données et vous pouvez transmettre cette variable dans la méthode read().

Answer 7

**#include<fstream> //to use file
#include<string>  //to use getline
using namespace std;
int main(){
ifstream file;
string str;
file.open("path the file" , ios::binary | ios::in);
while(true){
   getline(file , str);
   if(file.fail())
       break;
   cout<<str;
}
}**

Answer 8

#include <fstream>

ifstream infile;
infile.open(**file path**);
while(!infile.eof())
{
   getline(infile,data);
}
infile.close();

Answer 9

fstream est génial mais je vais aller un peu plus loin et vous en parler RAII.

Le problème avec un exemple classique est que vous êtes obligé de fermer le fichier vous-même, ce qui signifie que vous devrez adapter votre architecture à ce besoin.RAII utilise l'appel de destructeur automatique en C++ pour fermer le fichier pour vous.

Mise à jour:il semble que std::fstream implémente déjà RAII donc le code ci-dessous est inutile.Je le garderai ici pour la postérité et comme exemple de RAII.

class FileOpener
{
public:
    FileOpener(std::fstream& file, const char* fileName): m_file(file)
    { 
        m_file.open(fileName); 
    }
    ~FileOpeneer()
    { 
        file.close(); 
    }

private:
    std::fstream& m_file;
};

Vous pouvez maintenant utiliser cette classe dans votre code comme ceci :

int nsize = 10;
char *somedata;
ifstream myfile;
FileOpener opener(myfile, "<path to file>");
myfile.read(somedata,nsize);
// myfile is closed automatically when opener destructor is called

Apprendre comment fonctionne RAII peut vous éviter quelques maux de tête et quelques bugs majeurs de gestion de la mémoire.