map mit template struct

Mich würde folgendes intressieren:

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

SeppJ

Meinst du so?

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);
};

Sorry ich habe ausversehen die Klasse und die Struktur mit gleichen Namen benannt!

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.

SeppJ

Beobachter01 schrieb:

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.

Es war nur eine Frage ob so etwas möglich wäre. Im nachhinein könnte daraus ein Singleton erstellt werden um es als eine gemeinsame Speichercontainer zu verwenden.

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

krümelkacker

Beobachter01 schrieb:

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?

Es mir nur eingefallen und ich wollte es testen, aber ist nicht gelungen. Ich habe bis dato, einen großen Bogen von boost-lib gemacht und wollte gewisse Dinge mit C++-Standardbib. lösen.
Danke euch!

SeppJ

Beobachter01 schrieb:

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;
}