#include "namspc.h"

auf verschiedene Klassen include

Es kommt ein "already defined in" Fehler.

wie schaffe ich es eine universelle namespace auf verschieden Klassen zu übertragen?

Übertragen? Sowas gibts nicht. Du kannst höchtens Klassen in einem namespace definieren.

Ich bekomme immer einen Linker Fehler wenn ich

#include "namspc.h"

auf verschiedene Klassen include

Es kommt ein "already defined in" Fehler.

Dann liefere uns doch mal den kompletten Linkerfehler und ein wenig Code, um dein Problem zu verdeutlichen. Am Besten minimalen Code, der genau diesen Linkerfehler erzeugt. Wir können mit deinen bisherigen Angaben nur ins Blaue raten, und das führt zu nichts.

Das ist der Fehler!

Ich wollte diese namespace von allen Klassen nutzbar machen. Aber wenn ich die Header-Datei mehr als einmal irgendwo include bekomme ich diesen Fehler!

Wie kann ich sonst so einen "Universellen" Speicher zu Verfügung stellen? Eine statische Klasse vielleicht? ich weiss es einfach nicht.

Lösung 1: in den header sollte nur die Deklaration der Funktionen, nicht die Definition. Die Definition muss dagegen in eine eigene .cpp
Lösung 2: Wenn es auf keinen Fall eine .cpp geben soll (z.B. weil du ein Header-only Framework schreibst), definiere die Funktionen als inline. Ich tippe mal, dass die Bedingung für Lösung 2 nicht zutrifft.

btw: Das hat mit dem namespace nichts zu tun. Wäre auch passiert, wenn du die Funktionen ohne umschließenden Namespace im header definiert hättet.

//ist di namesp.h
std::list<std::string> liste
template<typename T>
void setValue(double t, int i, T wert);

//namesp.cpp
template<typename T>
void setValue(double t, int i, T wert)
{
std::stringstream ss;
ss<<t<<"\n"<<i<<"\n"<<wert<<"\n";
liste.push_front(ss.str());
}

Bei Templates ists übrigens genau andersrum, die musst du komplett im Header definieren, das geht auch ohne inline, da bei Templates die ODR nicht greift.

//ist di namesp.h
namespace bla{
std::list<std::string> liste
std::list<std::string>::iterator listIt
template<typename T>
void setValue(double t, int i, T wert);
std::string getValue();
}
//namesp.cpp
template<typename T>
void bla::setValue(double t, int i, T wert)
{
std::stringstream ss;
ss<<t<<"\n"<<i<<"\n"<<wert<<"\n";
liste.push_front(ss.str());
}

std::string bla::dataPool::getValue(){
	listIt = listenWerte.begin();
	std::string wert = *listIt;
	return wert;
}

listenWerte entspricht liste, listenWerteIt entspricht listIt

Warum zeigst du nicht per Copy&Paste den wirklichen Code, den du hast? (Natürlich aufs Wesentliche reduziert)

Das ist der vollständige Code mehr habe ich auch nicht. Ich habe die Sachen genauso wie oben.

#include "dataPool.h"

und in Target auch

#include "dataPool.h"

Das ist der vollständige Code mehr habe ich auch nicht. Ich habe die Sachen genauso wie oben.

Warum nicht gleich.

Also:

1. getValue() hatte das beschriebene Problem, das dürfte jetzt nichtmehr auftreten.
2. listenWerte und litenWerteIt haben das selbe Problem, nur dass es eben Variablen sind. Die gehören so oder so nicht im header definiert (höchstens deklariert), am Besten garkeine globalen/namespace scope variablen.
3. setValue hat das Problem, dass die Template-Definition im Header stehen muss.

alles zusammen sieht mir danach aus, als ob du das Ganze in eine Klasse packen und ein Singleton oder was ähnliches draus machen solltest.

Die beiden haben im Prinzip keine Beziehung zueinander. Wie ich schon erwähnt habe, soll mir die namespace als eine Art Zwischenspeicher für alle Objekte dienen.

1. der namespace (Namensraum)
2. Ein namespace ist kein Objekt, sondern nur ein Mittel zur Code-Organisation. Du kannst in einem namespace nichts speichern.

Das Ziel soll sein, dass alle Objekte (andere Klassen) in die Liste etwas einfügen und auch entfernen können sollen.

Soll ich alles in eine Klasse packen und die einzelnen Methoden bzw. Liste auch als static definieren?

Wäre eine Möglichkeit. Den Iterator brauchst du sowieso nicht dauerhaft halten, der reicht funktionslokal völlig aus.

ich bekomme jetzt so einen Fehler:

error c2011: 'dataPool' : 'class' type redefinition -> see declaration of dataPool

Ich könnte .....! Namespace wurde als eine statische Klasse mit statischen variabeln und Methoden implementiert. Ich habe versucht die Header-Datei wieder in 2 verschiedenen Klassen eingebunden. Wie bekomme ich das hin, dass nur einmal die Klasse definiert wird und alle Zugriff darauf haben?

falls ich IncludeGuards hinzufüge bekomme ich einen Linker-fehler der mir sagt, dass er auf die statische methode von dataPool nicht zugreifen kann. Wie kann ich dies beheben. Ich wollte eine statische Klasse bereitstellen auf der alle anderen zugreifen können. Werte löschen, ändern hinzufügen usw...

Sag mal den genauen Fehler an. Und (hoffentlich) dumme Frage: Die Methode existiert auch irgendwo, oder?

module1.obj : error LNK2019: unresolved external symbol "public: static void __cdecl dataPool::setValue<double>(double,int,double)" (??$setValue@N@dataPool@@SAXNHN@Z) referenced in function "public: void __thiscall module1::run(void)" (?run@module1@@QAEXXZ)

Das ist dazugehörige Klasse:

//dataPool.h
class dataPool{
private:
    static std::list<std::string> listenWerte;
public:
    template<typename T>
    static void setValue(double t, int i, T wert);
    static std::string getValue();
}
//dataPool.cpp
std::list<std::string> dataPool::listenWerte

template<typename T>
void dataPool::setValue(double t, int i, T wert)
{
    std::stringstream ss;
    ss<<t<<"\n"<<i<<"\n"<<wert<<"\n";
    listenWerte.push_front(ss.str());
}

std::string dataPool::getValue(){
    std::list<std::string>::iterator listenWerteIt;
    listenWerteIt = listenWerte.begin();
    std::string wert = *listenWerteIt;
    return wert;
}

Semikoli im Header (richtige Plural ?).

Ich glaube es heißt "Semikola".