Quellcode teilen und globale Variablen

rona

Jo habs hinbekommen.

Leider ist das mit den globalen Vars nicht ganz vermeidbar. Ich muss dazu sagen ich bin relativ neu unterwegs mit C/C++. Ich arbeite mit Threads ohne irgendwelchen MFC oder sowas. Um mir halt das Grundverständnis mehr oder weniger selber beizubringen.
Den Threads kann ich aber nur nen pointer übergegeben und das ist schon eoner auf ne Struktur, die schon groß genug ist. Gewisse Einstellungen werden dabei halt über gobale Variablen gemacht, die nicht wirklich mit in die Struktur sollen. Außerdm bestehen viele Änderungsmöglichkeiten der Variablen in meinem Programm und jedesmal übergeben und zurückgeben habsch auch keine Lust. Hat ja alles schon ohne Probleme funktioniert, als es noch in einer Datei war.

THX @all für sehr schnell Antworten

@ ness
Das Beispiel hat wirklich zum Verständnis geholfen.

ness

Wiebtte? Du bist neu ei c++, aber wir fangen gleich mal mit threads an, ja, schon klar.

rona

mir wurde empfohlen bei meinem Programm (Proxy-Switch) mit threads zu arbeiten. Hab auch ne weile gebraucht eh ich da durchgestiegen bin.

Naja ganz neu nu auch net. Hab im 3.Semester das letzte mal mit C++ Dinge fürs Studium programmiert. Bin jetzt aber im 9 Semester und hab mich in der Zwischenzeit überhaupt nicht mit der Materie auseinandergesetzt.

und Quellcode hab ich bisher auch immernur in eine Datei gepackt.
Trennen ging net (siehe Linker-Fehler), deswegen habsch gefragt.

Ringding

Threads und globale Variablen sind prinzipiell eine sehr ungesunde Mischung.

rona

ja ich weiß. nur ich hab jetzt keine Lust alles nochmal zu ändern, da es funktioniert. Die globalen Variablen werden auch in den Threads nicht geändert. Lediglich geschaut ob diese Variable einen bestimmten Wert hat und danach das Verhalten des Threads gesteuert.

if*Flo*

Ich möchte gerne eine Klasse auslagern. Allerdings bin ich mir nun nicht sicher was ich in den Header schreiben muss und was in die ausgelagerte Datei.

Bisheriger Versuch:

logfile.h :

#ifndef LOGFILE_H
#define LOGFILE_H
class TLog;
#endif

logfile.cpp :

#include <fstream>
#include "logfile.h"
using namespace std;

class TLog
{
  private:
    ofstream Datei;
  public:
    void Write(char* Text);
    TLog();
};

TLog::TLog()
{
    Datei.open("LogFile.txt",ios::out | ios::trunc);
    Datei << "Log File 2" << endl;
    Datei << "--------------" << endl;
    Datei.close();
}

void TLog::Write(char* Text)
{
    Datei.open("LogFile.txt",ios::out | ios::app);
    Datei << Text << endl;
    Datei.close();
}

main.cpp :

#include "logfile.h"

TLog Log

/* ... */
Log.Write("Dies ist ein Test");
Log.Write("Zeile 2");
/* ... */

Allerdings erhalte ich dann die Fehlermeldungen:

C:\Dev-Cpp\Projekte\LogTest\main.cpp
aggregate `TLog Log' has incomplete type and cannot be defined
C:\Dev-Cpp\Projekte\LogTest\main.cpp
storage size of `Log' isn't known

Neben einer Antwort würde ich es auch gut finden, wenn die Frage "Wie lagere ich Quelltext aus" ins FAQ übernommen wird.

MfG
if(Flo)

groovemaster

In "logfile.h" hast du lediglich die Deklaration von TLog, nicht die Definition selbst. Deshalb kannst du in "main.cpp" auch keine Instanz davon erstellen, geschweige denn Member aufrufen, da dort eben die Definition nicht bekannt ist. Lösung? Du definierst die Klasse einfach im Header.

rona schrieb:

ja ich weiß. nur ich hab jetzt keine Lust alles nochmal zu ändern, da es funktioniert. Die globalen Variablen werden auch in den Threads nicht geändert. Lediglich geschaut ob diese Variable einen bestimmten Wert hat und danach das Verhalten des Threads gesteuert.

Du glaubst das es funktioniert, weil das in deinen Tests bisher so war.
Wenn du bei deiner "Prüfung" der globalen Variablen keine Synchronisation
verwendest, hast du dir schon eine Problem eingehandelt.

Unix-Tom

Mal ein Bsp.
Dein Hauptthread schreibt in die Globale Variable. Mit dem schreiben wird er aber nicht ganz fertig und da bekommt der Workthread das Zeitfenster. Dieser holt sich nun ais der Globalen Var den Wert der aber noch nicht fertig geschrieben ist. Was machst Du dann?

Dies ist auch das einzige Pproblem wenn einer schreibt und andere lesen.
Wen mehrere schreiben gibt es andere Probleme.

Bashar

Dann nimmst du Variablen vom Typ volatile sig_atomic_t (das ist ein typedef auf irgendeinen Integer-Typ), von dem garantiert ist, dass er atomar geschrieben wird. Dann passiert sowas nicht.

Jester

Abgesehen davon ist der Thread vom November letzten Jahres. Derjenige der ihn rausgeholt hat scheint ein anderes Problem zu haben.

if*Flo*

Jetzt funktioniert es. Danke!

Hier nochmal der Quelltext in ausgebesserter Form:
logfile.h:

#ifndef LOGFILE_H
#define LOGFILE_H

#include <fstream>
using namespace std;

class TLog
{
  private:
    ofstream Datei;
  public:
    void Write(char* Text);
    TLog();
};
#endif

logfile.cpp:

#include "logfile.h"

TLog::TLog()
{
    Datei.open("LogFile.txt",ios::out | ios::trunc);
    Datei << "Log File 2" << endl;
    Datei << "--------------" << endl;
    Datei.close();
}

void TLog::Write(char* Text)
{
    Datei.open("LogFile.txt",ios::out | ios::app);
    Datei << Text << endl;
    Datei.close();
}

main.cpp

#include "logfile.h"
  /* ... */
  Log.Write("Dies ist ein Test");
  Log.Write("Zeile 2");
  /* ... */

MfG
Flo