Comment détecter si un PTR fait toujours référence à une référence valide après que cette référence est hors de portée

Question

Je suis en train de jouer avec des flux et je n'arrive pas à comprendre ce qui suit.

Ici, nous avons un ostream ptr de base qui est mis à différents flux de sortie, que ce soit cout, cerr ou file.

// ostream ptr 
std::ostream* outstream; 

// set output ostream 
void setOutput(std::ostream & os) 
{ 
    outstream = &os; 
} 

// write message to ostream 
void writeData(const std::string & msg) 
{  
    *outstream << msg << '\n'; 
} 

int main (int argc, char * const argv[]) 
{ 
    // init to std out 
    setOutput(std::cout); 
    writeData("message to cout"); 

    setOutput(std::cerr); 
    writeData("message to cerr"); 

    std::ofstream fileout("test.txt", std::ofstream::out | std::ofstream::app); 
    setOutput(fileout); 
    writeData("message to file"); 
    //fileout.close(); 

    setOutput(std::cout); 
    writeData("message2 to cout"); 

    return 0; 
} 

Ce qui précède fonctionne parfaitement et montre la force de la mise en œuvre de l'iostream C++. Parfait.

Cependant, puisque le setOutput est défini par référence, l'objet référencé doit rester dans la portée. C'est là que le problème émerge. Je veux trouver un moyen de mettre par défaut la sortie à std::cout si l'ofstream ou tout autre ostream est invalidé. Autrement dit, l'objet référencé est ou est sorti de la portée.

Par exemple:

// write message to ostream 
void writeData(const std::string & msg) 
{ 
    if (/*stream or memory is invalid*/) 
    setOutput(std::cout); 

    *outstream << msg << '\n'; 
} 
// local fileout goes out of scope 
void foo() 
{ 
    std::ofstream fileout("test.txt", std::ofstream::out | std::ofstream::app); 
    setOutput(fileout); 
    writeData("message to file"); 
} 

int main (int argc, char * const argv[]) 
{ 
    setOutput(std::cout); 
    writeData("message to cout"); 

    foo(); 
    /* problem the local fileout is no longer referenced by the ostream ptr*/ 
    /* the following should be redirected to std::cout cuz of default*/ 
    writeData("message2 to cout"); 

    return 0; 
} 

Ce qui précède est bien jusqu'à ce que les foo() revient à la fonction principale. Là, il va horrible mal parce que le ofstream localement défini n'est plus accessible.

De toute évidence, ce n'est pas conseillé et l'utilisateur devrait s'en rendre compte. Cependant, je veux emballer tout cela dans une classe de journalisation et ainsi garder l'état de l'objet valide même si cette mauvaise utilisation pourrait se produire. Cela entraînera une violation d'accès invalide qui peut être difficile à trouver.

Question concrète. Existe-t-il un moyen de déterminer si un ostream ptr ou un ptr fait toujours référence à un objet valide ou à un emplacement mémoire?

ps: je pourrais utiliser la mémoire du tas et faire quelque chose avec des pointeurs intelligents, mais franchement je veux continuer comme ça si possible

Answer 1

question concrète. Existe-t-il un moyen de déterminer si un ostream ptr ou un ptr fait toujours référence à un objet valide ou à un emplacement mémoire?

Non. Il n'y a aucun moyen de comprendre cela avec des pointeurs bruts. Pas en standard C++ au moins.

Vous devrez vous assurer que l'objet pointu reste en vie tant qu'il est pointé vers.

Un motif commun utilisé pour fournir cette garantie est RAII, comme détaillé dans d'autres réponses. Une autre approche pour garantir la validité d'un pointeur consiste à utiliser un pointeur intelligent au lieu d'un pointeur brut. Cependant, ceux-ci ne sont pas compatibles avec les variables automatiques.

Il serait bon de continuer à pointer vers des objets morts tant que vous pourriez garantir que le pointeur n'est pas déréférencé. Ce qui est souvent difficile à garantir car, comme déjà dit, il n'y a aucun moyen de tester si l'objet pointé existe.

Answer 2

Une approche possible est de créer une classe RAII qui enveloppe le flux avant en le passant dans setOutput. Cette classe doit être conçue pour fonctionner comme shared_ptr de telle sorte qu'elle conserve un nombre de ref partagé. writeData vérifie ensuite si elle possède la seule référence restante et, si tel est le cas, détruit l'ostream et utilise par défaut cout.

Answer 3

Cela ressemble à un excellent cas d'utilisation pour RAII.

Ecrivez une classe qui prend un nom de fichier et un std::ostream** comme paramètres de son constructeur. Dans le constructeur de la classe, construisez le ofstream (en tant que membre) et définissez le pointeur sur le flux. Dans le destructeur, revenez à stdout.

Ensuite, remplacez les deux premières lignes de la fonction suivante par une déclaration de la nouvelle classe.

void foo() 
{ 
    std::ofstream fileout("test.txt", std::ofstream::out | std::ofstream::app); 
    setOutput(fileout); 
    writeData("message to file"); 
} 

Answer 4

Vous devez utiliser RAII pour forcer la définition correcte du flux, puis revenir à std :: cout si l'objet est détruit.

class OutputStream 
{ 
    protected: 
     static std::ostream*& internalGlobalStateOfOutputStream() 
     { 
      static std::ostream* out = &std::cout; 
      return out; 
     } 
    public: 
     static std::ostream& getOutputStream() 
     { 
      return *internalGlobalStateOfOutputStream(); 
     } 
}; 
template<typename T> 
class OutputStreamOwner: public OutputStream 
{ 
    T ownedStream; 
    public: 
     OutputStreamOwner(T&& obj) 
      : ownedStream(std::move(obj)) 
     { 
      internalGlobalStateOfOutputStream() = &ownedStream; 
     } 
     template<typename... Args> 
     OutputStreamOwner(Args... args) 
      : ownedStream(args...) 
     { 
      internalGlobalStateOfOutputStream() = &ownedStream; 
     } 
     ~OutputStreamOwner() 
     { 
      internalGlobalStateOfOutputStream() = & std::cout; 
     } 
     // Delete copy 
     OutputStreamOwner(OutputStreamOwner const&)   = delete; 
     OutputStreamOwner& operator(OutputStreamOwner const&) = delete; 
}; 

L'utilisation est:

void foo() 
{ 
    OutputStreamOwner<std::ofstream> output("test.txt", std::ofstream::out | std::ofstream::app); 

    writeData("message to file"); 
} 

Answer 5

question concrète. Y at-il un moyen de déterminer si un ostream ptr ou tout ptr d'ailleurs fait toujours référence à un objet valide ou emplacement de mémoire?

ps: je pouvais utiliser la mémoire de tas et faire quelque chose avec des pointeurs intelligents mais franchement je veux continuer comme ça si possible

Non, il n'y a aucun moyen standard pour tester si un pointeur brut ou référence fait toujours référence à un objet valide. RAII est la solution standard C++ pour ce type de problème, donc vous devriez regarder des pointeurs intelligents, à mon avis. Je ne connais aucun pointeur intelligent fourni par une bibliothèque qui résoudrait ce problème particulier, mais une solution RAII basée sur la propriété partagée semble la meilleure solution ici.

Answer 6

Vous pouvez éviter ces complications avec une fonction qui prend le flux en entrée.

void writeData(std::ostream& os, const std::string & msg) 
{  
    os << msg << '\n'; 
} 

Vous pouvez affiner en retournant le flux, pour permettre un aux appels de la chaîne à elle:

std::ostream& os writeLine(std::ostream& os, const std::string & msg) 
{  
    os << msg << '\n'; 
    return os; 
} 

// declare stream 
stream << writeLine(stream, "Foo") << writeLine(stream, "Bar"); 

En fait, cette fonction est plus agréable et plus facile à entretenir, comme vous n'avez pas se rappeler quel flux est défini à un moment donné. Pour les grands programmes, c'est une qualité importante.