FAQ C++Consultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#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";  
    }  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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"; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#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 
}

1
2
3
4
5
6
7
8
9
10
ifstream file( "fichier.txt" ); 
  
// compter le nombre de lignes 
int count = 0; 
while ( ! file.eof() ) 
{ 
    string line; 
    file >> line; 
   ++count; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ifstream file( "fichier.txt" ); 
  
// compter le nombre de lignes 
int count = 0; 
while ( true ) 
{ 
    string line; 
    getline( file, line ); 
    if ( file.eof() ) 
    { 
         break;    
    }     
    ++count; 
}

1
2
3
4
5
6
7
8
9
10
ifstream file( "fichier.txt" ); 
  
// compter le nombre de lignes 
int count = 0; 
  
string line; 
while ( getline( file, line ) ) 
{ 
    ++count; 
}

1
2
3
4
5
6
7
8
9
10
11
12
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 ; 
}

1
2
3
4
5
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;

1
2
3
4
5
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 
}

1
2
3
4
5
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;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#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; 
        } 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#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'; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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;  
        }  
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 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' ); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
#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";     
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#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";

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include <string> 
#include <iostream> 
  
int main() 
{ 
    using namespace std; 
  
    string file_name = "fichier.txt"; 
  
    size_t ext_pos = file_name.find_last_of( '.' ); 
    if ( ext_pos != string::npos ) 
    { 
        // 3 manières d'extraire l'entension 
        string ext1 = file_name.substr( ext_pos ); 
        string ext2( file_name, ext_pos ); 
        string ext3; 
        ext3.assign( file_name, ext_pos, file_name.size() - ext_pos ); 
  
        // 3 manières d'extraire le nom 
        string name1 = file_name.substr( 0, ext_pos ); 
        string name2( file_name, 0, ext_pos ); 
        string name3 = file_name; 
        name3.resize( ext_pos ); 
  
        // remplacer le nom 
        string file_name2 = file_name; // copie pour préserver l'original 
        file_name2.replace( 0, ext_pos, "remplace" ); 
  
        // remplacer l'extension 
        string file_name3 = file_name; // copie pour préserver l'original 
        file_name3.replace( ext_pos + 1, file_name3.size() - 1, "dat" ); 
  
        // insérer un mot entre le nom du fichier et son extension 
        string file_name4 = file_name; // copie pour préserver l'original 
        file_name4.insert( ext_pos, "-modif" ); 
  
        // afficher les résultats 
        cout << ext1 << '\n'; // ".txt" 
        cout << ext2 << '\n'; // ".txt" 
        cout << ext3 << '\n'; // ".txt" 
        cout << name1 << '\n'; // "fichier" 
        cout << name2 << '\n'; // "fichier" 
        cout << name3 << '\n'; // "fichier" 
        cout << file_name2 << '\n'; // "remplace.txt" 
        cout << file_name3 << '\n'; // "fichier.dat" 
        cout << file_name4 << '\n'; // "fichier-modif.txt" 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <fstream> 
#include <iostream> 
#include <limits> 
  
int CountLines(std::ifstream& File) 
{ 
    int Count = 0; 
    while (File.ignore(std::numeric_limits<int>::max(), '\n'))  
        ++Count;  
  
    return Count; 
} 
  
int main() 
{ 
    std::ifstream File("fichier.txt"); 
  
    std::cout << CountLines(File) << std::endl; 
  
    File.clear(); 
    File.seekg(0, std::ios::beg); 
  
    std::cout << CountLines(File) << std::endl; 
  
    return 0; 
}