Datei als global deklarieren

Laula

Hallo,

ich habe mehrere Quellcodedateien. Außerdem eine Headerdatei, in der alle globalen Variablen gelistet sind.

Nun möchte ich eine Datei ausgabe.txt öffnen, die in allen Quellcodedateien beschreibbar sein soll, also die ganze Zeit während des Programmdurchlaufs geöffnet sein soll und mit 'ausgabe' angesprochen werden soll.
In main habe ich #include <fstream> eingebunden. Dann habe ich in der header-Datei die Variable 'ausgabe' angelegt:

#ifndef GLOBALEV_H_
#define GLOBALEV_H_

ofstream ausgabe;

#endif /* GLOBALEV_H_ */

In jeder Quellcodedatei, in der ich diese Datei beschreiben möchte, habe ich anfangs geschrieben:

extern ofstream ausgabe;

Und dabei kommt das erste Problem. ofstream ist als Variablentyp unbekannt, solang sie außerhalb von Funktionen deklariert ist. Hingegen in den Funktionen in den Quellcodedateien ist sie bekannt. Wie auch immer, es funktionier nicht!

und in main() öffne ich die Datei:

ausgabe.open("E:\\...\\Ausgabe.txt");

So, das war meine Idee. Kann mir jemand sagen, wie ich es günstiger mache? Zuerst habe ich die Datei immer in den Funktionen aufgerufen, d.h. jedes Mal geöffnet und wieder geschlossen. Da ich dies aber 1000x und mehr machen will, dachte ich mir, ist es evtl. ziemlich zeitaufwändig. Oder?

Ich danke,
Laula

_matze

Wenn ofstream ganz oben nicht bekannt ist, in den Funktionen darunter aber schon, dann hast du die Deklaration vermutlich vor das Einbinden von <fstream> gepackt. Richtig?

Desweiteren solltest du von allzu vielen globalen Variablen absehen. Auf diese kann man in den meisten Fällen verzichten (es hört sich so an, als hättest du relativ viele Globale).

Du könntest deinen stream in der main öffnen und einen Zeiger darauf an alle Funktionen weitergeben, die ihn benötigen. Vielleicht ist auch eine Singleton-Klasse eine Möglichkeit.

It0101

Wobei das aber eigentlich keine schöne Lösung ist. Vermutlich gibts bessere Varianten als eine globale Variable zu nutzen.

_matze

Laula schrieb:

Zuerst habe ich die Datei immer in den Funktionen aufgerufen, d.h. jedes Mal geöffnet und wieder geschlossen. Da ich dies aber 1000x und mehr machen will, dachte ich mir, ist es evtl. ziemlich zeitaufwändig. Oder?

Von wievielen Funktionen sprechen wir denn hier, die alle in die Datei schreiben wollen? Normalerweise würde ich ja eher vermuten, dass es eine Funktion ist, die in einer Schleife x mal was schreibt (dann wäre die Lösung ja klar). Bei dir hört es sich so an, als ob jede Funktion mal dran ist mit dem Schreiben.

Tyrdal

Naja, letztlich sind cout, cin etc ja auch global.

_matze

Tyrdal schrieb:

Naja, letztlich sind cout, cin etc ja auch global.

Kein Grund, das auf die Spitze zu treiben.

Laula

_matze schrieb:

Wenn ofstream ganz oben nicht bekannt ist, in den Funktionen darunter aber schon, dann hast du die Deklaration vermutlich vor das Einbinden von <fstream> gepackt. Richtig?

Ich habe in main.cpp:

#include <iostream>
#include <fstream>
#include <cmath>
#include "globaleV.h"
#include "***.h" //weitere header- Dateien

erst im Hauptprogramm werden die weiteren Funktionen aufgerufen, die die ausgabe.txt zum Beschreiben benutzen. Selbst wenn ich fstream in den anderen Quellcodedateien includiere ( selbstverständlich bevor ich die Variable des Typs ofstream deklariere), ist ofstream als Typ unbekannt. Woran liegt das?

_matze schrieb:

Desweiteren solltest du von allzu vielen globalen Variablen absehen. Auf diese kann man in den meisten Fällen verzichten (es hört sich so an, als hättest du relativ viele Globale).

Das ist mir bekannt, ich habe bisher auch nur eine weitere.

_matze schrieb:

Du könntest deinen stream in der main öffnen und einen Zeiger darauf an alle Funktionen weitergeben, die ihn benötigen.

Das werde ich dann mal so machen, wenn es nicht global geht. Global wäre mir ja schon lieber... Warum wäre das hier konkret ungünstig?

Danke... bis zum nächsten Problem...

Laula

_matze schrieb:

Von wievielen Funktionen sprechen wir denn hier, die alle in die Datei schreiben wollen? ... Bei dir hört es sich so an, als ob jede Funktion mal dran ist mit dem Schreiben.

Im Prinzip habe ich bisher 2 Funktionen, die je nach Status des Objektes durchlaufen werden und dann etwas in die Datei schreiben sollen. Da ich aber erst am Anfang bin, sollen noch weitere hinzukommen. Und nun will ich das von Anfang an ordentlich machen.

_matze schrieb:

Normalerweise würde ich ja eher vermuten, dass es eine Funktion ist, die in einer Schleife x mal was schreibt (dann wäre die Lösung ja klar).

Es ist so, dass die Funktion, die was in die Datei schreibt, x-mal in einer Schleife aufgerufen wird. Und bei jedem Aufruf wird etwas in die txt-Datei geschrieben werden. Ist dann die Lösung immer noch klar?

_matze

Deklarier deine Globale (ofstream) nicht im Header (das kann sowieso böse enden wegen doppelter Implementation usw.)! Deklarier sie in der main.cpp (unter #include <fstream> natürlich), und in allen anderen Übersetzungseinheiten deklarierst du sie halt mit extern. Das sollte schon klappen.

_matze

Laula schrieb:

Es ist so, dass die Funktion, die was in die Datei schreibt, x-mal in einer Schleife aufgerufen wird. Und bei jedem Aufruf wird etwas in die txt-Datei geschrieben werden. Ist dann die Lösung immer noch klar?

In dem Fall ist die Lösung auf andere Art und Weise klar. Du könntest doch einfach vor der Schleife deinen ofstream öffnen, eine Referenz oder einen Zeiger an die Funktion in der Schleife übergeben, und ihn nach der Schleife wieder schließen.

Wenn du es global machen willst, mach es wie im letzten Post vorgeschlagen. Das sollte funktionieren.

Laula

_matze schrieb:

Deklarier deine Globale (ofstream) nicht im Header (das kann sowieso böse enden wegen doppelter Implementation usw.)! Deklarier sie in der main.cpp (unter #include <fstream> natürlich), und in allen anderen Übersetzungseinheiten deklarierst du sie halt mit extern. Das sollte schon klappen.

Genau das hatte ich ja auch schon einmal. Aber beim Kompilierversuch wurde mir gesagt, dass 'ofstream' als Typ nicht bekannt sei.
Okay, jetzt habe ich es: Ich musste

using namespace std;

auch davor setzen.

Danke...

Here we go...

theta

besser als using namespace wäre std::ofstream zu schreiben.

varginator

Hallo,

du könntest auch std::streambuf nehmen:

std::streambuf* old_stream;
old_stream = clog.rdbuf();
std::ofstream of("DATEINAME");
clog.rdbuf(of.rdbuf());

Dann kannst du überall so drauf zu greifen

clog<<"Text der in die Datei soll"<<endl;

Und wenn du fertig bist, dann schließt du die Datei und schreibst du den alten stream wieder zurück

of.close();
clog.rdbuf(old_stream);

Gruß Simon

It0101

varginator schrieb:

Dann kannst du überall so drauf zu greifen
clog<<"Text der in die Datei soll"<<endl;

Und wo ist jetzt genau der Vorteil gegenüber einem ofstream?

varginator

Es gibt eigentlich nur den Vorteil, dass man nicht überall den ofstream declarieren muss, sonst eigentlich nichts ...