class STORAGE
{
public:
        int pos;
        string name;
        STORAGE(int p, string n) : pos(p),name(n) {}
};
vector<STORAGE>Box;

Ich hab schon etwas rumprobiert aber ich kenne hier nicht die Syntax.

Ich dachte erst es könnte so gehen:

template <class T>
class STORAGE
{
public:
        int pos;
        string name;
        STORAGE(int p, string n) : pos(p),name(n) {}
};
template <class T>
STORAGE<T>::vector<STORAGE>Box;

Aber da sagt der Compiler: Deklaration nicht abgeschlossen.

wenn du eine klasse hast und darauf ein klassentemplate machen willst (sprich diese klasse parametrisieren) dann schreibst du einfach einfach anstelle von

class Foo
{
// ...
};

das hier

template <typename T>
class Foo
{
// ...
};

ob du dieses template dan auch verwendest ist ne andere sache.
und mit nem vector hat das auch erstmal nichts zu tun.
denn benutzen kannst du diese klasse wie gewohnt.

template <typename T>
class Foo
{
// ...
};

...

int main()
{
    std::vector< Foo<double> > vec;
    // ...
    return 0x0;
}

aber wenn ich ganz ehrlich bin verstehe ich deine frage nicht wirklich, bzw dein anliegen

Du nutzt T ja nicht mal in deiner Klasse!

Das Stimmt, ich habe T da auch noch nicht benutzt da ich Schritt für Schritt an die Sache rangegangen bin.

Das hier wollte ich aus Spass mit templates basteln:

#include <iostream>
#include <vector>
using namespace std;

class STORAGE
{
public:
        int pos;
        string name;
         STORAGE(int p, string n) : pos(p),name(n) {}
};
vector<STORAGE>Box;

class GET : STORAGE
{
public:
       GET( int p, string n) : STORAGE(p,n) {}
       void SetName(int p, string n);
       string GetName(int p);
};

void GET :: SetName(int p, string n)
{
       Box.push_back( STORAGE(p,n) );
}

string GET :: GetName(int p)
{
unsigned i=0;
        for( ; i<Box.size();i++)
        {
                if ( Box[i].pos == p )
                {
                   break;
                }
        }
return Box[i].name;
}

int main()
{
GET g(0,"0");

g.SetName(1,"abc");
g.SetName(2,"def");
g.SetName(3,"ghi");

cout << "Name: " << g.GetName ( 1 ) << "\n";
cout << "Name: " << g.GetName ( 2 ) << "\n";
cout << "Name: " << g.GetName ( 3 ) << "\n";

return 0;
}

Das hier wollte ich aus Spass mit templates basteln:

Und was verstehst du unter "mit templates basteln"?
Was willst du erreichen?

Ich habe mir vor einiger Zeit diesen Artikel durchgelesen: http://www.cplusplus.com/doc/tutorial/templates/

Und jetzt experimentiere ich halt selber etwas rum.

So funktioniert es schon mal:

#include <iostream>
#include <vector>
using namespace std;

template<class T>
class STORAGE
{
public:
        T pos;
        T name;
         STORAGE(T p, T n) : pos(p),name(n) {}
};
vector<STORAGE<int> >Box;

int main()
{

Box.push_back( STORAGE<int>(8,99) );

cout << Box[0].pos << endl;
cout << Box[0].name << endl;

return 0;
}

Aber ich will das so haben:

#include <iostream>
#include <vector>
using namespace std;

template<class T, class Z>
class STORAGE
{
public:
        T pos;
        T name;
         STORAGE(T p, T n) : pos(p),name(n) {}
};
vector<STORAGE<int,string> >Box;

int main()
{

Box.push_back( STORAGE<int,string>(8,"abc") );

cout << Box[0].pos << endl;
cout << Box[0].name << endl;

return 0;
}

Keine Übereinstimmung für 'STORAGE<int,string>::STORAGE(int,char *)' gefunden

Was mach ich da falsch?

Habs jetzt ^^ Danke für eure Hilfe:

#include <iostream>
#include <vector>
using namespace std;

template<class T, class Z>
class STORAGE
{
public:
         T pos;
         Z name;
          STORAGE(T p, Z n) : pos(p),name(n) {}
};
 vector<STORAGE<int,string> >Box;

int main()
{

 Box.push_back( STORAGE<int,string>(8,"abc") );

 cout << Box[0].pos << endl;
 cout << Box[0].name << endl;

return 0;
}

Angenommen ich habe folgendes:

template<class T>
class FOO
{
public:
        void print_para(T a);
        void SayHello();
};

template<class T> void FOO<T> :: print_para ( T a )
{

}

template<class T> void FOO<T>:: SayHello()
{
        cout<<"Hello";
}

Um eine Funktion aus der Klasse aufzurufen muss ich ja hier jetzt diesen template Kram immer schreiben.

Meine Memberfunktion SayHello verwendet hier ja keinerlei Parameter.

Aber damit ich diese ausführen kann muss ich ja schreiben:

template<class T> void FOO<T>:: SayHello()
{
        cout<<"Hello";
}

Gibts auch irgendwie eine möglichkeit in meiner Klasse Templates verwenden zu können und trotzdem einfach diese Schreibweise einzuhalten?

void FOO :: SayHello()
{
        cout<<"Hello";
}