#include <iostream>
using namespace std;

template <class T>
class CustomVector
{
public:
        T *var;

        CustomVector( T p );
        ~CustomVector();

};

template <class T>
CustomVector<T>::CustomVector( T p ) : var( new T [p] )
{

}

template <class T>
CustomVector<T> ::~CustomVector()
{
       delete []var;
}

int main(int argc, char* argv[])
{
CustomVector<char>vec(3);

vec.var[2]='A';
cout<<vec.var[2];

// vec[2]='A';  <-- So ein Schreibweise will ich benutzen können^^

return 0;
}

Wie wurde der Vector implementiert das man sowas schreiben darf wie:

vec[2]='A';
Ich muss bei mir ja immer schreiben: vec.var[..]=...;

Oder ist diese andere Schreibweise im Standart festgelegt?

Hier die Lösung.(Vielleicht kann wer anderes damit auch noch was anfangen)

template <class T>
T &CustomVector<T> ::operator[] ( int index )
{
        return var[index];
}

[...] int index )

Für Speichergrößen verwendet man in der Regel std::size_t .

Für Speichergrößen verwendet man in der Regel std::size_t .

Auch xy::size_type , unsigned int oder std::ptrdiff_t (unter Anderem).

std::size_t wird vielleicht am häufigsten verwendet, aber nicht einmal die Standardbibliothek ist diesbezezüglich konsistent.

Auch xy::size_type , unsigned int oder std::ptrdiff_t (unter Anderem).

Da gibt es aber feine Unterschiede zwischen dem, was diese Datentypen/typedefs bedeuten.

std::size_t wird vielleicht am häufigsten verwendet, aber nicht einmal die Standardbibliothek ist diesbezezüglich konsistent.

Wo denn nicht?

std::istream& stream = ...;
std::vector<char> data = ...;

stream.read(&data[0], data.size()); // std::size_t -> std::streamsize

Auch ist die Bedeutung nicht immer exakt die gleiche. std::size_t steht zwar für irgendeine Grösse, kann aber sowohl Anzahl Elemente als auch Anzahl Bytes bedeuten.

Von Member-Typedefs wie size_type oder difference_type will ich gar nicht erst anfangen. Gibt es eigentlich Leute, welche diese konsequent im Programm nutzen?

Von Member-Typedefs wie size_type oder difference_type will ich gar nicht erst anfangen. Gibt es eigentlich Leute, welche diese konsequent im Programm nutzen?

size_type ja, difference_type nie.

Swordfish schrieb:

Für Speichergrößen verwendet man in der Regel std::size_t .

Auch xy::size_type , unsigned int oder std::ptrdiff_t (unter Anderem).

unsigned int ? Wo steht das? IMHO garantiert der Standard, daß Speichermengen immer in std::size_t passen - bei unsigned int ist das ein Ratespiel.

Nexus schrieb:

std::size_t wird vielleicht am häufigsten verwendet, aber nicht einmal die Standardbibliothek ist diesbezezüglich konsistent.

Wenn eine Implementierung der STL an entsprechenden Stellen nicht std::size_t , container::size_type bzw. entsprechende verwendet, ist sie kaputt.

streams sind keine Container, insbesondere können entsprechende Files ja ohne weiteres größer sein, als durch size_t (32-bit System) darstellbar. Logischerweise ist hier size_t nicht angebracht.

size_type stammt vom verwendeten Allokator. Und der default allocator muss hierfür size_t benutzen.

Und wieder was gelernt...

Allerdings drückt es die Intention wieder besser aus, finde ich - was aber schnell zu einem kryptischen typename -Gefrickel werden kann.

unsigned int ?

Einige Bibliotheken benutzen int oder unsigned int , um Objekte zu zählen -- also auch Speichergrösse, wenn letztere sich in Containern befinden. Das ist übrigens auch, was mir nicht gefällt: Korrekterweise müsste man ständig std::size_t weiterreichen, auch wenn in einem High-Level-Kontext andere Datentypen verwendet werden (und Container Implementierungsdetails sind).

Swordfish schrieb:

IMHO garantiert der Standard, daß Speichermengen immer in std::size_t passen - bei unsigned int ist das ein Ratespiel.

Das stimmt (sollte auf heutigen Plattformen aber erst bei Grössen ab 2^32 relevant werden).

camper schrieb:

size_type stammt vom verwendeten Allokator. Und der default allocator muss hierfür size_t benutzen.

Ja. Die Typedefs existieren doch, um andere Typen zu ermöglichen... Nutzt das jemand?

camper schrieb:

streams sind keine Container, insbesondere können entsprechende Files ja ohne weiteres größer sein, als durch size_t (32-bit System) darstellbar. Logischerweise ist hier size_t nicht angebracht.

Danke für die Erklärung. Bedeutet das, dass ein std::size_t immer problemlos in einen std::streamsize konvertierbar ist (kompatibler Typ, kein Datenverlust)?

27.5.2 Types [stream.types]
typedef implementation-defined streamoff;
1 The type streamoff is a synonym for one of the signed basic integral types of sufficient size to represent
the maximum possible file size for the operating system.296
typedef implementation-defined streamsize;
2 The type streamsize is a synonym for one of the signed basic integral types. It is used to represent
the number of characters transferred in an I/O operation, or the size of I/O buffers.297

297. streamsize is used in most places where ISO C would use size_t. Most of the uses of streamsize could use size_t,
     except for the strstreambuf constructors, which require negative values. It should probably be the signed type corresponding
     to size_t (which is what Posix.2 calls ssize_t).