Das ist die Klasse:

template<class T>
class TemplateClass
{
   vector<T>var;   
   //...
};

Und so definiere ich mir einen entsprechenden Vektor für die Pointer:

vector<TemplateClass*>vec;

Im Laufe der Zeit sollen dann Objekte erstellt und die Pointer daraufhin in diesem Vektor gespeichert werden.

Das Problem ist aber, dass der DEV-C++ bereits bei der Definierung des Vektors angegeben haben will, welchen Typ ich verwende. Das kann ich aber erst bei der eigentlichen Erstellung des Objektes sagen.

Kann ich die Angabe des Typs jetzt irgendwie "herauszögern", sodass ich ihn erst wirklich beim Erstellen des Objektes angeben muss.

Ooooder liege ich jetzt ganz falsch und interpretiere diese Fehlermeldung sogar verkehrt ôO:

template argument 1 is invalid
template argument 2 is invalid
ISO C++ forbids declaration of `vec' with no type

Ich hoffe ihr habt mich eingermaßen verstanden

MfG

template<typename T>
class item
{
    std::vector<T> m_data;
};

template<typename T>
class container
{
    std::vector<item<T>* > m_items;
};

wenn du verschiedene Datentypen in den Vector packen willst, brauchst du boost::any ...

class Base
{
public:
  virtual ~Base() {}; // wichtig: virtueller Destruktor

  virtual void func(); // deine virtuellen Methoden
  // ...
};

template<class T>
class TemplateClass : public Base
{
   vector<T> var;
   //...
};

vector<Base*> vec;

vec.push_back(new TemplateClass<int>());
vec.push_back(new TemplateClass<string>());

vec[0]->func(); // rufe func für TemplateClass<int> auf
vec[1]->func(); // rufe func für TemplateClass<string> auf

Nicht vergessen, die Elemente beim Entfernen auch wieder zu löschen (mittels delete).

Du müßtest eine abstrakte Basisklasse erstellen, von der dann deine Template-Klasse ableitet. Dann kannst du Zeiger darauf in den Container stecken und mittels Polymorphie auf die Inhalte der einzelnen Elemente zugreifen.

class Base
{
public:
  virtual ~Base() {}; // wichtig: virtueller Destruktor

  virtual void func(); // deine virtuellen Methoden
  // ...
};

template<class T>
class TemplateClass : public Base
{
   vector<T> var;
   //...
};

vector<Base*> vec;

vec.push_back(new TemplateClass<int>());
vec.push_back(new TemplateClass<string>());

vec[0]->func(); // rufe func für TemplateClass<int> auf
vec[1]->func(); // rufe func für TemplateClass<string> auf

Nicht vergessen, die Elemente beim Entfernen auch wieder zu löschen (mittels delete).

Hmmm...gute Idee. Aber ich habe in meiner Template-Klasse ein paar Funktionen, die T als Übergabeparameter, als auch welche die T als Rückgabewert haben. Die kann ich dann ja nicht so ohne weiteres in die Basisklasse packen... Oder gibt's da vll. doch ne Möglichkeit?

@(D)Evil: Hmmm....da werd ich wohl mal ne Weile nach boost:: googeln müssen. Die Methode von Th wäre mir aber lieber, da sie auch noch das ein oder andere Problemchen mehr lösen würde...

Die kann ich dann ja nicht so ohne weiteres in die Basisklasse packen... Oder gibt's da vll. doch ne Möglichkeit?

Lol, nein. Wie stellst du dir das vor?
C++ ist statisch typisiert, da geht sowas nicht.
In Python o.ä. kein Problem, in C++ unmöglich.
Es gibt zwar einge Abscheulichkeiten wie boost::any, aber mit sowas sollte man IMO nicht arbeiten solange nicht feststeht dass es keinen anderen, besseren Weg gibt.

class Base {
public:
  explicit virtual double      foo(double x)      {throw std::bad_cast;}
  explicit virtual int         foo(int x)         {throw std::bad_cast;}
  explicit virtual std::string foo(std::string x) {throw std::bad_cast;}
  explicit virtual char        foo(char x)        {throw std::bad_cast;}

  ~Base() {} =0; //pure virtual dtor 
};

template<class T>
class MyClass : public Base {
public:
  virtual T foo(T x) { myvec.push_back(x);}
  ~MyClass() {};
private:
  std::vector<T> myvec;
};

Und in der Verwendung dann wie gehabt einen vector<Base*> in den du Pointer auf die MyClass<T>'s steckst. Was passiert ist folgendes: du kannst foo fuer jede beliebige Instantiierung von MyClass aufrufen, ueber Base pointer aber nur die, die du dort auch deklariert hast (das explicit verhindert, das implizite Konvertierungen z.B. von short int nach int stattfinden). Bsp:

class A {};

int main() {
  A a;
  char b;
  int c;

  MyClass<A> xa;
  MyClass<char> xb;
  MyClass<int> xc;
  Base* pa = &xa;
  Base* pb = &xb;
  Base* pc = &xc;

  xa.foo(a); //funktioniert
  xb.foo(b); //tuts auch
  xc.foo(c); //kein problem
  xc.foo(b); //!implizite konvertierung von char nach int!

  pa->foo(a); //FEHLER, Base::foo(A) gibts nicht!
  pb->foo(b); //geht
  pc->foo(c); //geht auch

  pc->foo(b); //wird ausgefuehrt und fuehrt zu einem std::bad_cast,
              //weil MyClass<int> nur foo(int) ueberladen hat, es wird aber foo(char) aufgerufen!

}

template <class T> class MyClass; //forward-deklaration

class Base {
public:
  virtual void bar() = 0; //typunabhaengig
  template<class T>
  T foo(ccnst T& x);             //typabhaengige methode

  virtual ~Base() = 0;
private: 
  template<class T>
  MyClass<T>* TemplateIs(const T& /*t*/ = T());
};

template<class T>
class MyClass {
public:
  virtual void bar() {/* machwas */}
  T foo(const T& x) {/* mach was mit T */}
  virtual ~Base() {};
}

template<class T>
MyClass<T>* Base::TemplateIs(const T& /*t*/) { 
  return dynamic_cast<T>(this); 
}

template<class T>
T Base::foo(const T& x) {
  if (MyClass<T>* pt = TemplateIs<T>()) {
    return pt->foo(x);
  }
  else throw std::bad_cast;
}

/* alternativ:
 *
 * template<class T>
 * T Base::foo(const T& x) {
 *   return TemplateIs<T>->foo(x);
 * }
 */

alternativ kann man die Sicherheitsabfrage aus foo weglassen und es dem Client ueberlassen, den richtigen Typ zu mittels TemplateIs() pruefen und entsprechend zu reagieren. In jedem Fall muss man aber voher schon wissen, auf welche Instantiierung von MyClass ein Base-pointer zeigt, wenn man die entsprechenden Operationen ausfuehren will (die typunabhaengigen gehn immer)

class B {};
int main() {
  MyClass<int> xa;
  MyClass<B> xb;
  MyClass<char> xc;

  Base* pa = &xa;
  Base* pb = &xb;

  char c;
  std::vector<Base*> vec;

  vec.push_back(&xa);
  vec.push_back(&xb);
  vec.push_back(&xc);

  for(std::vector<Base*>::iterator it = vec.begin(), it != vec.end(), ++it)
    it->bar();

  cout << xc.foo(c) <<endl; 
  cout << pa->foo(c) << endl;  //wirft std::bad_cast wenn wie oben implementiert, sonst segfault wenn Alternative (Zugriff ueber nullpointer)
  if(pb->TemplateIs(c))  //liefert nullpointer == false
    cout << pb->foo(c);
}