Ich moechte folgendes machen

namespace AB
{
typedef std::vector Vector;
}

Wie ihr euch denken koennt, funktioniert das so nicht. Wie mache ich es richtig? Geht sowas ueberhaupt? Ich habe schon diverse Moeglichkeiten (mit typename und template und ...) ausprobiert. Vergeblich.

Danke.

haste mal using versucht?

namespace AB
{
using std::vector;
}

Ich will es ja so nicht haben. Ich will es als Vector und nicht vector haben (Ich habe einen Grund dafuer aber bitte nicht danach fragen).

Es scheint wohl in der Tat nicht zu gehen: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndeepc/html/deep08032000.asp. Schade.

template <typename T>
class Vector : public std::vector<T>
{
    // alle benötigten Konstruktoren implementieren
};

template <typename T>
class Vector : public std::vector<T>
{
    // alle benötigten Konstruktoren implementieren
};

int main()
{
    Vector* v = new Vector<int>;

    delete v; // destructor von std::vector wird nicht aufgerufen da nicht virtual

    return 0;
}

Das ist keine praktikable Loesung.

In the first alternative (delete object), if the static type of the operand is different from its dynamic type, the
static type shall be a base class of the operand’s dynamic type and the static type shall have a virtual
destructor or the behavior is undefined.

Gruß

Quark, der Destructor von Basisklassen wird immer aufgerufen. Virtual ist für die andere Richtung verantwortlich.

class Base 
{
};

class Derieved : public Base
{
};

int main()
{
    Base* b = new Base();

    delete b; // hier soll der destructor von derieved aufgerufen werden? :open_mouth: 

    return 0;
}

Derived *d = new Derived()

und da geht das.

#include <vector>
namespace Foo {
template <class T>
struct VectorT {
    typedef std::vector<T> type;
};

// und später
void func() {
    VectorT<int>::type v;

}

}