surcharge de l'opérateur

Question

Comment puis-je surcharger l'opérateur < < (cout) afin qu'il puisse être écrit dans un fichier. Chaque fois que < < se produit, il doit être ajouté au fichier, c'est-à-dire au lieu d'être affiché sur l'écran, il doit être écrit dans le fichier.

puis-je obtenir un code pour cela ... Je suis nouveau à C++ et le code écrit par moi ne fonctionne pas ..

Answer 1

Normalement vous fournir std::ostream& operator<<(std::ostream&, const YourClass&) pour votre classe et écrire à un flux de fichier comme suit:

std::ofstream ofs("out"); 
ofs << yourObject; 

où yourObject est un objet de YourClass.

Answer 2

Cette surcharge est déjà effectuée pour le flux de fichier C++. Le nom cout signifie sortir de la console et l'esprit est, il sortira à la console. Une chose que vous pouvez faire est d'utiliser freopen(), pour rediriger toutes les sorties vers un fichier.

Answer 3

Votre opérateur << surchargé ne devrait pas se préoccuper du type de flux de sortie vers lequel il va ou s'il est ajouté ou écrasé. Il prend un std::ostream& et écrit à lui. S'il est utilisé avec cout, il est écrit sur la console. S'il est utilisé avec un std::ofstream, il écrit dans un fichier. Si ce std::ofstream a été ouvert pour remplacer, il écrase. S'il a été ouvert pour ajouter, alors il ajoute.

Tout ce que votre opérateur surchargé << doit prendre en compte, c'est qu'il écrit dans un flux de sortie. Ce que ce flux représente est sans importance.

Answer 4

Si vous voulez simplement envoyer du texte à un fichier plutôt qu'à la console, alors std::ofstream est votre ami. Comme cout, votre instance de ofstream partage le comportement de ostream qui a déjà un <<operator approprié pour les chaînes et peut être utilisé exactement comme cout. Voici un exemple:

#include <fstream> 

int main() 
{ 
    std::ofstream fout("somefile.txt"); 

    fout << "Some text" << std::endl; 

    return EXIT_SUCCESS; 
} 

compiler et exécuter et vous verrez que vous avez un nouveau fichier dans le répertoire de travail courant:

% cat somefile.txt 
Some text 

---

Si vous avez besoin de diffuser un objet qui doesn « t ont operator << surchargé pour std::ostream, alors vous vous devez surcharger l'opérateur, comme ceci:

std::ostream& operator <<(std::ostream& os, const SomeClass& instance) 
{ 
    instance.print(os); 
    return os; 
} 

Vous aurez besoin de void SomeClass::print(std::ostream& os) défini pour envoyer ses données privées à os (cela vous évite de créer le << un friend de votre classe).

---

Avez-vous parlé à propos purement cout, alors ce n'est pas « surcharge d'opérateur », c'est la redirection de flux. Mais, oui, il est possible (aussi) en définissant le tampon de flux associé en utilisant std::basic_ios::rdbuf().

est ici my solution de "Redirecting in C++":

#include <iostream> 
#include <fstream> 

class scoped_cout_redirector 
{ 
public: 
    scoped_cout_redirector(const std::string& filename) 
     :backup_(std::cout.rdbuf()) 
     ,filestr_(filename.c_str()) 
     ,sbuf_(filestr_.rdbuf()) 
    { 
     std::cout.rdbuf(sbuf_); 
    } 

    ~scoped_cout_redirector() 
    { 
     std::cout.rdbuf(backup_); 
    } 

private: 
    scoped_cout_redirector(); 
    scoped_cout_redirector(const scoped_cout_redirector& copy); 
    scoped_cout_redirector& operator =(const scoped_cout_redirector& assign); 

    std::streambuf* backup_; 
    std::ofstream filestr_; 
    std::streambuf* sbuf_; 
}; 


int main() 
{ 
    { 
     scoped_cout_redirector file1("file1.txt"); 
     std::cout << "This is written to the first file." << std::endl; 
    } 

    std::cout << "This is written to stdout." << std::endl; 

    { 
     scoped_cout_redirector file2("file2.txt"); 
     std::cout << "This is written to the second file." << std::endl; 
    } 

    return 0; 
}