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

bool is_readable( const std::string & file ) 
{ 
    std::ifstream fichier( file.c_str() ); 
    return !fichier.fail(); 
} 

void Exemple()
{
    using std::cout;
    if ( is_readable( "fichier.txt" ) ) 
    { 
        cout << "Fichier existant et lisible.\n"; 
    } 
    else 
    { 
        cout << "Fichier inexistant ou non lisible.\n"; 
    } 
}

void test_lecture()
{
    ifstream file( "fichier.txt" );
    if ( !file )
    {
        cerr << "Erreur d'ouverture\n";
        return;
    }

    string line;
    if ( ! ( file >> line ) )
    {
        cerr << "Erreur de lecture\n";
        return;
    }
    cout << "Ligne lue : " << line;
}

void test_ecriture()
{
    ofstream file( "fichier.txt" );
    if ( !file )
    {
        cerr << "Erreur de création\n";
        return;
    }

    file << "Une ligne\n";
    if ( ! file )
    {
        cerr << "Erreur d'écriture\n";
        return;
    }
    cout << "L'écriture a réussi\n";
}

#include <fstream>

void AjouterUneLigne()
{
    // std::ios_base::out est automatiquement ajouté par le
    // constructeur de std::ofstream
    std::ofstream file( "fichier.txt", std::ios_base::app );
    file << "Une ligne\n";
}

int main()
{
    // création du fichier et écriture d'une ligne
    AjouterUneLigne();
    // ouverture du fichier existant et rajout d'une nouvelle ligne
    AjouterUneLigne();
    // "fichier.txt" contient 2 lignes
}

ifstream file( "fichier.txt" );

// compter le nombre de lignes
int count = 0;
while ( ! file.eof() )
{
    string line;
    file >> line;
   ++count;
} 

ifstream file( "fichier.txt" );

// compter le nombre de lignes
int count = 0;
while ( true )
{
    string line;
    getline( file, line );
    if ( file.eof() )
    {
         break;   
    }    
    ++count;
} 

ifstream file( "fichier.txt" );

// compter le nombre de lignes
int count = 0;

string line;
while ( getline( file, line ) )
{
    ++count;
}

long GetFileSize( std::ifstream & Fichier )
{
    // sauvegarder la position courante
    long pos = Fichier.tellg();
    // se placer en fin de fichier
    Fichier.seekg( 0 , std::ios_base::end );
    // récupérer la nouvelle position = la taille du fichier
    long size = Fichier.tellg() ;
    // restaurer la position initiale du fichier
    Fichier.seekg( pos,  std::ios_base::beg ) ;
    return size ;
}

std::ifstream fichier( "fichier.txt" ); // ou n'importe quel objet dérivant de std::ios
if ( fichier ) // ce test échoue si le fichier n'est pas ouvert
{
    // OK
}

operator void*( ) const;

std::ifstream fichier( "fichier.txt" ); // ou n'importe quel objet dérivant de std::ios
if ( fichier.operator void*() != 0 ) // ce test échoue si le fichier n'est pas ouvert
{
    // OK
}

std::ifstream fichier( "fichier.txt" ); // ou n'importe quel objet dérivant de std::ios
if ( !fichier ) // ce test est vrai si l'ouverture échoue
{
    // ERREUR
}

bool operator!() const;

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

int main()
{
    // le constructeur de ifstream permet d'ouvrir un fichier en lecture
    std::ifstream fichier( "fichier.txt" );

    if ( fichier ) // ce test échoue si le fichier n'est pas ouvert
    {
        std::string ligne; // variable contenant chaque ligne lue

        // cette boucle s'arrête dès qu'une erreur de lecture survient
        while ( std::getline( fichier, ligne ) )
        {
            // afficher la ligne à l'écran
            std::cout << ligne << std::endl;
        }
    }
}

#include <fstream>
#include <iostream>
#include <sstream>

int main()
{
    // le constructeur de ifstream permet d'ouvrir un fichier en lecture
    std::ifstream fichier( "fichier.txt" );

    if ( fichier ) // ce test échoue si le fichier n'est pas ouvert
    {
        std::stringstream buffer; // variable contenant l'intégralité du fichier
        // copier l'intégralité du fichier dans le buffer
        buffer << fichier.rdbuf();
        // nous n'avons plus besoin du fichier !
        fichier.close();
        // manipulations du buffer...
        std::cout << "Taille du buffer : " << buffer.str().size() << '\n';
    }
}

// utiliser ignore
#include <fstream>
#include <limits>

int main()
{
    std::ifstream file( "fichier.txt" ); 
    if ( file )
    {
        int lines = 0; 
        while ( file.ignore( std::numeric_limits<int>::max(), '\n' ) ) 
        { 
            ++lines; 
        } 
    }
}

// utiliser std::count et std::istreambuf_iterator
#include <fstream>
#include <algorithm>

int main()
{
    std::ifstream file( "fichier.txt" ); 

    if ( file )
    {
        int lines = std::count(
            std::istreambuf_iterator<char>( file ),
            std::istreambuf_iterator<char>(),
            '\n' );
    }
}

#include <fstream> 

using namespace std; 

int main() 
{ 
    ofstream file_txt( "fichier_txt.txt" ); 
    file_txt << "a\n" "b\n" "c\n";    
    ofstream file_bin( "fichier_bin.txt", ios_base::binary ); 
    file_bin << "a\n" "b\n" "c\n";    
} 

#include <fstream>
#include <iostream>

std::ofstream FileOut("Toto.txt", std::ios_base::binary);
int xout = 24;
FileOut.write(reinterpret_cast<const char*>(&xout), sizeof(int));
FileOut.close();

std::ifstream FileIn("Toto.txt", std::ios_base::binary);
int xin;
FileIn.read(reinterpret_cast<char*>(&xin), sizeof(int));
FileIn.close();

std::cout << xin << std::endl; // Affiche "24";

template<typename T>
std::ostream& write(std::ostream& os, const T& value)
{
    return os.write(reinterpret_cast<const char*>(&value), sizeof(T));
}

template<typename T>
std::istream & read(std::istream& is, T& value)
{
    return is.read(reinterpret_cast<char*>(&value), sizeof(T));
}

// Nos appels deviennent donc
write(FileOut, xout);
read(FileIn, xin);