Quand est-ce que ofstream :: open échouera?

J'essaie try, catch, de jeter des déclarations en C++ pour la gestion des fichiers, et j'ai écrit un code factice de rattraper toutes les erreurs. Ma question est pour vérifier si j'ai eu ces droit, j'ai besoin d'une erreur. Maintenant, je peux facilement vérifier infile.fail() simplement pas la création d'un fichier de nom dans le répertoire. Mais comment vais-je être en mesure de vérifier la même chose pour outfile.fail() (outfile est ofstream où, comme infile est ifstream). Dans ce cas, la valeur pour outfile.fail() être vrai?

exemple de code [de commentaires sur unapersson réponse, simplifiée pour rendre la question plus claire -zack]:

#include <fstream>
using std::ofstream;

int main() 
{
    ofstream outfile;
    outfile.open("test.txt");
    if (outfile.fail()) 
        //do something...... 
    else 
        //do something else..... 
    return 0; 
}

source d'informationauteur Scranton

  1. 24

    La open(2) page de man Linux a environ 30 conditions. Certains intéressant sont:

    • Si le fichier existe et que vous n'avez pas la permission d'écrire.
    • Si le fichier n'existe pas, et vous n'avez pas la permission (sur la diretory) pour le créer.
    • Si vous n'avez pas la permission de recherche sur certains répertoire parent.
    • Si vous passez dans un bidon char* pour le nom de fichier.
    • Si, lors de l'ouverture d'un fichier de périphérique, vous appuyez sur CTRL-C.
    • Si le noyau a rencontré trop de liens symboliques, tandis que la résolution du nom.
    • Si vous essayez d'ouvrir un répertoire pour l'écriture.
    • Si le chemin est trop long.
    • Si votre processus a trop de fichiers ouverts déjà.
    • Si le système a trop de fichiers ouverts déjà.
    • Si le chemin d'accès fait référence à un fichier de périphérique, et il n'y a rien de tel dans le système.
    • Si le noyau est à court de mémoire.
    • Si le système de fichiers est plein.
    • Si un composant du chemin d'accès n'est pas un répertoire.
    • Si le fichier est sur un système en lecture seule.
    • Si le fichier est un fichier exécutable qui est actuellement en cours d'exécution.
  2. 6

    Par défaut, et de par sa conception, C++ flux ne jamais lancer des exceptions en cas d'erreur. Vous ne devriez pas essayer d'écrire un code qui suppose qu'ils font, même si il est possible de les obtenir. Au lieu de cela, dans la logique de l'application de vérifier chaque opération d'e/S pour une erreur et faire avec, éventuellement, lancer votre propre exception si cette erreur ne peut pas être traitée à l'endroit précis, il se produit dans votre code.

    La manière canonique de test des ruisseaux et des flux des opérations n'est pas de tester volet spécifique sur les drapeaux, sauf si vous avez. Au lieu de cela:

    ifstream ifs( "foo.txt" );

if ( ifs ) {
   //ifs is good
}
else {
   //ifs is bad - deal with it
}

    de même pour les opérations de lecture:

    int x;
while( cin >> x ) {
     //do something with x
}

//at this point test the stream (if you must)
if ( cin.eof() ) {
     //cool - what we expected
}
else {
     //bad 
}
  3. 4

    Pour obtenir ofstream::open à l'échec, vous devez vous arranger pour qu'il soit impossible de créer le nom de fichier. La meilleure façon de le faire est de créer un répertoire du même nom avant d'exécuter le programme. Voici un quasi-complète de démonstration du programme; organiser de manière fiable supprimer le répertoire de test si et seulement si vous l'avez créé, je laisse comme exercice.

    #include <iostream>
#include <fstream>
#include <sys/stat.h>
#include <cstring>
#include <cerrno>

using std::ofstream;
using std::strerror;
using std::cerr;

int main() 
{
    ofstream outfile;

    //set up conditions so outfile.open will fail:
    if (mkdir("test.txt", 0700)) {
        cerr << "mkdir failed: " << strerror(errno) << '\n';
        return 2;
    }

    outfile.open("test.txt");
    if (outfile.fail()) {
        cerr << "open failure as expected: " << strerror(errno) << '\n';
        return 0;
    } else {
        cerr << "open success, not as expected\n";
        return 1;
    }
}

    Il n'y a pas de bonne façon de s'assurer que écrit à un fstream échoue. Je serais probablement créer une maquette ostream qui ont échoué à l'écrit, si j'avais besoin de le tester.