Comment ouvrez-vous un fichier en C++?

, Vous devez utiliser un ifstream si vous voulez juste pour lire (utilisation d'un ofstream pour é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 "binaire" pavillon.

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.

Pour ouvrir et lire un fichier texte ligne par ligne, vous pouvez utiliser la syntaxe suivante:

// 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);

Pour ce faire, vous devrez #include l'en-tête: <iostream>

#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......
}

#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;
}

Suivez les étapes,

1. incluez les fichiers D'en-tête ou l'espace de nom pour accéder à la classe de fichier.
2. créez un objet de classe de fichier en fonction de votre plate-forme IDE ( c'est-à-dire, CFile, QFile, fstream).
3. Maintenant, vous pouvez facilement trouver cette méthode de classe pour ouvrir / lire / fermer / getline ou autre de n'importe quel fichier.

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

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

#include <fstream>

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

Fstream sont géniaux mais je vais aller un peu plus loin et vous parler de RAII .

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

Update : semble que std:: fstream implémente déjà RAII donc le code ci-dessous est inutile. Je vais le garder 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 sauver des maux de tête et des bugs majeurs de gestion de la mémoire.