Ich habe eine Header-File in der ich 2 Globale Objekte definiert habe die ich in mehrer Sourcefiles benutzen möchte:

#ifndef __GLOBALOBJECTS_H__
#define __GLOBALOBJECTS_H__

#include <vector>
#include <string>

std::string         curProcName;
std::vector<DWORD>  procList;

#endif // __GLOBALOBJECTS_H__

Nun ja, dachte mir es wäre eine gute Idee das so in ein Headerfile zu packen und in meinen Sourcefiles zu includen. Pustekuchen:

class std::vector<unsigned long,class std::allocator<unsigned long> > procList" (?procList@@3V?$vector@KV?$allocator@K@std@@@std@@A) ist bereits in NavigatormainFrame.obj definiert.

Mein funktionierender Ansatz war es die Objekte in eine .cpp file zu stecken und Funktionen zu definieren die die Objekte zurückgeben, zb.

std::vector<DWORD> getProcList()
{
    return procList;
}

Aber naja, ich werde wohl noch deutlich mehr Objekte haben und für jedes Objekt eine Funktion zu schreiben scheint mir ein dreckiges Workaround zu sein.

Also, welchen groben Designfehler mache ich und wie gehts besser?

Danke !

Grüße

Also, welchen groben Designfehler mache ich und wie gehts besser?

Du benutzt globale Variablen. Benutze keine globalen Variablen.

Ansonsten schreib ein extern dazu, schreib zum Header eine *.cpp und definiere dort die Variablen.

// Headerfile
extern int globalInteger;
extern std::vector<int> globalIntegerVector;
// usw.

// Sourcefile
#include "globalheader.hpp"

int globalInteger;
std::vector<int> globalIntegerVector;

Alle inkludieren nur die Deklaration und durch das extern weiss der Linker, dass die Variablen in einem Objectfile irgendwo definiert sind, sucht danach und findet sie dann in diesem einen.

Grüssli

Du benutzt globale Variablen. Benutze keine globalen Variablen.

Warum denn nicht wenn ich Daten im ganzen Programm brauche ?

Warum denn nicht wenn ich Daten im ganzen Programm brauche ?

Weil es für die Übersicht nicht förderlich ist. Man sollte Variablen als Funktionsargumente weitergeben, so weiss man immer, was woher kommt und wo verändert wurde. Du kannst Veränderungen deutlich einfacher nachvollziehen.

Ein einfaches Beispiel:

#include <iostream>

int* g_integer;

void create();
void use();
void destroy();

int main()
{
  create(); // Was denn?

  use(); // Was?

  destroy(); // Was wird zerstört?

  use(); // BUMMM, wieso???
}

void create()
{
  g_integer = new int(3);
}

void use()
{
  std::cout << *g_integer << std::endl;
}

void destroy()
{
  delete g_integer;
  g_integer = 0;
}

Es ist ein einfaches Beispiel, hier könnte man noch mitkommen. Wenn aber alles über duzende von Files verteilt ist, dann hast du keine Ahnung mehr, was passiert. Die Funktionen verändern plötzlich Variablen und Einstellungen und es ist dir gar nicht klar. Wenn es dagegen so aufgebaut ist, dann ist es viel verständlicher.

#include <iostream>

int* create();
void use(int* v);
void destroy(int* v);

int main()
{
  int* p = create(); // Klar, wir haben nun einen Integer erstellt.

  use(p); // Klar, wir verwenden p, also den Integer.

  destroy(p); // Klar, wir zerstören p, also den Integer.

  use(p); // BUMM, logisch, p wurde ja zerstört.
}

// ich spare mir jetzt die Implementation der Funktionen. Es sollte klar sein,
// wie diese aussehen.

Meistens erfordert dies auch ein etwas anderes Design, als wenn man es über globale Variablen löst. Aber in den meistens Fällen kann man sie umgehen und es ist sehr zu empfehlen.
Falls man trotzdem mal ein paar Daten global braucht und nur einmal angelegt haben möchte, gibt es noch die Singleton Möglichkeit. Wobei ich aber klar sagen möchte, dass sie kein Ersetzung von globalen Variablen darstellen und man sie auch nicht im Überfluss benutzen sollte.

Grüssli