class mapStruct{
private:
   template<class T>
   struct mapStruct{
      double a;
      T b;
      value* next};
   std::map<int,mapStruct> mapB;
public:
   template<class T>
   setValue(int key,int a,T b);
   template<class T>
   T getValue();
}

Kann man so etwas irgendwie machen? Dies soll dann in einer map eine verkette Liste darstellen

template <class T> class mapStruct
{
private:
 struct mapStructNode
 {
   T b;
   T* next
 };
 std::map<int,mapStructNode> mapB;
public:
  setValue(int key, T b);
  T getValue(int key);
};

class mapClass{
private:
   template<class T>
   struct mapStruct{
      double a;
      T b;
      value* next};
   std::map<int,mapStruct> mapB;
public:
   template<class T>
   setValue(int key,int a,T b);
   template<class T>
   T getValue();
}

So wie du es geschrieben hast, muss ich beim aufrufen immer mapClass<int>::setValue(...) schreiben, das ich aber vermeiden möchte! Es soll später ein Singleton darstellen.

So wie du es geschrieben hast, muss ich beim aufrufen immer mapClass<int>::setValue(...) schreiben,

Typedef.

Außerdem wäre es gut, alle Informationen rauszurücken. Singleton ist ja schon einmal eine ganz neue Information. Das ganze Design kommt mir nämlich äußerst merkwürdig vor.

Sorry die Frage wird dumm sein aber, wo soll ich den typedef ansetzen?

class mapClass{
private:
   template<class T>
   struct mapStruct{
      double a;
      T b;
      value* next};
   std::map<int,mapStruct> mapB;
public:
   template<class T>
   setValue(int key,int a,T b);
   template<class T>
   T getValue();
}

Kann man so etwas irgendwie machen?

"so etwas irgendwie" ist bei diesem Beispiel von ungültigem C++ nicht gerade besonders präzise.

Beobachter01 schrieb:

Dies soll dann in einer map eine verkette Liste darstellen

Aha.

Gefällt Dir das?

struct dings {
  double a;
  boost::any o;
  dings* next;
};

map<int,dings> zuordnung;

oder das?

struct dings_base {
  virtual ~dings_base() = 0;
  double a;
  dings_base* next;
};

dings_base::~dings_base() {}

template<class T>
struct dings_mit_T : dings_base {
  T obj;
  ...
};

boost::ptr_map<int,dings_base> zuordnung;

Beobachter01 schrieb:

Es war nur eine Frage ob so etwas möglich wäre. [...] als eine gemeinsame Speichercontainer zu verwenden.

Wozu? Was soll das bringen? Welches Problem willst Du damit lösen?

Sorry die Frage wird dumm sein aber, wo soll ich den typedef ansetzen?

Noch nirgendwo, weil du noch gar keine statischen Memberfunktionen hast. Aber wenn du den Klassennamen brauchst und nicht immer die Templateargumente ausschreiben möchtest, dann machst du eben einen typedef:

template<typename T> struct stupid_global_variable
{
 static int data;
};

typedef stupid_global_variable<int> my_int;

template<> int my_int::data = 0;

int main()
{
  my_int::data = 5;
}