Cout einem Variablennamen zuweisen

Question

Wie kann ich in ANSI C++ den Cout-Stream einem Variablennamen zuweisen? Was ich tun möchte, ist, wenn der Benutzer einen Ausgabedateinamen angegeben hat, sende ich dort eine Ausgabe, andernfalls sende ich ihn an den Bildschirm. So etwas wie:

ofstream outFile; 
if (outFileRequested) 
    outFile.open("foo.txt", ios::out); 
else 
    outFile = cout; // Will not compile because outFile does not have an 
        // assignment operator 

outFile << "whatever" << endl; 

habe ich versucht, dies als eine Makro-Funktion zu tun, wie gut:

#define OUTPUT outFileRequested?outFile:cout 

OUTPUT << "whatever" << endl; 

Aber das gab mir auch einen Compiler-Fehler.

Ich dachte, ich könnte entweder einen IF-THEN-Block für jeden Ausgang verwenden, aber ich würde das gerne vermeiden, wenn ich könnte. Irgendwelche Ideen?

Answer 1

Verwenden Sie einen Verweis. Beachten Sie, dass die Referenz vom Typ std::ostream, nicht std::ofstream sein muss, da std::cout eine std::ostream ist, daher müssen Sie den kleinsten gemeinsamen Nenner verwenden.

std::ofstream realOutFile; 

if(outFileRequested) 
    realOutFile.open("foo.txt", std::ios::out); 

std::ostream & outFile = (outFileRequested ? realOutFile : std::cout); 

Answer 2

Sie eine sehr detaillierte Erklärung, wie dies zu tun, finden Sie hier: http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81?pli=1

Hoffentlich wird jemand dies deutlicher für Stapelüberlauf aufzuschreiben, die Punkte zu nehmen ...

Answer 3

Ich denke Adams auf dem richtigen Weg, aber ich glaube nicht, dass Sie Referenzen zuweisen können - Sie müssen stattdessen einen Zeiger verwenden:

std::ofstream realOutFile; 
std::ostream * poutFile; 

if(outFileRequested) 
{ 
    realOutFile.open("foo.txt", std::ios::out); 
    poutFile = &realOutFile; 
} 
else 
    poutFile = &std::cout; 

Sie dann eine Referenz definieren könnte der Wert sein des Zeigers, aber es wäre nicht global sein

std::ostream & outFile = *poutFile; 

Answer 4

ich bin nicht sicher, dass Sie cout auf eine Variable vom Typ ofstream zuweisen können. cout ist ein Objekt vom Typ ostream (während cin vom Typ istream ist) und ich bin mir nicht sicher, ob man von dem anderen erbt. Also, vielleicht etwas prüfen, um zu sehen, ob eine Datei gegeben wurde/existiert und den entsprechenden Stream-Typ zu erstellen, wäre ein besserer Ansatz.

Answer 5

Nach Adam Rosenfield ‚s Spuren, aber die Referenz Initialisierungsproblem mit ternären und Komma Operatoren Befestigung:

bool outFileRequested = false; 

std::ofstream realOutFile; 
std::ostream & outFile = outFileRequested 
    ? realOutFile.open("foo.txt", std::ios::out), realOutFile 
    : std::cout; 

outFile << "some witty remark"; 

(Geprüft VS)

Answer 6

ich Ihr Programm übernehmen verhält sich wie Standard-Unix-Tools , wenn eine Datei nicht angegeben wird, wird sie in die Standardausgabe geschrieben, und wenn eine Datei angegeben wird, wird sie in diese Datei geschrieben. Sie können umleiten, um in einen anderen Stream-Puffer zu schreiben. Solange Ihre Weiterleitung aktiv ist, wird alles, was an cout geschrieben wurde, transparent an das von Ihnen angegebene Ziel geschrieben. Sobald die Umleitung Objekt den Gültigkeitsbereich verlässt, wird der ursprüngliche Strom gesetzt und Ausgang wieder auf den Bildschirm schreiben:

struct CoutRedirect { 
    std::streambuf * old; 
    CoutRedirect():old(0) { 
     // empty 
    } 

    ~CoutRedirect() { 
     if(old != 0) { 
      std::cout.rdbuf(old); 
     } 
    } 

    void redirect(std::streambuf * to) { 
     old = std::cout.rdbuf(to); 
    } 
} 

int main() { 
    std::filebuf file; 
    CoutRedirect pipe; 
    if(outFileRequested) { 
     file.open("foo.txt", std::ios_base::out); 
     pipe.redirect(&file); 
    } 
} 

Nun wird cout in die Datei umgeleitet, solange das Rohr in Haupt am Leben ist. Sie können es "produktionsfertig" machen, indem Sie es nicht kopierbar machen, da es nicht kopierbereit ist: Wenn die Kopie den Gültigkeitsbereich verlässt, wird der ursprüngliche Stream bereits wiederhergestellt.

Answer 7

Das dauerte ungefähr zwei Stunden. Grundsätzlich habe ich eine externe Klasse, die eine Testsuite ausführt. Ich sende einen Delegaten ein, um die Tests zu starten. Um Zugriff auf die Ausgabe zu haben, muss ich einen Ausgabestream senden.Ich denke, ich hätte pro Test einen anderen Stream machen können. Wie auch immer, ich wollte den Offstream weitergeben, um später benutzt zu werden.

// Main code to create Test Suite Object 
ofstream debugFile("debug.txt"); 
TestSuiteObject* myTestSuite = new TestSuiteObject(&debugFile); 

// Test Suite Object 
class TestSuiteObject: public Test::Suite 
{ 
public: 
TestSuiteObject(std::ofstream* debug) : m_debug(*debug) 
{ 
    m_debug << "some witty remark" << std::endl; 
    TEST_ADD(TestSuiteObject::test1); 
    TEST_ADD(TestSuiteObject::test2); 
    TEST_ADD(TestSuiteObject::test3); 

} 

void test1(); 
void test2(); 
void test3(); 

private: 
std::ofstream& m_debug; 
};