Comment implémenter l'opérateur [] pour un tableau dynamique?

Question

J'ai besoin de mettre en œuvre un tableau dynamique par moi-même pour l'utiliser dans un simple gestionnaire de mémoire.

struct Block {  
    int* offset; 
    bool used; 
    int size; 
    Block(int* off=NULL, bool isUsed=false, int sz=0): offset(off), used(isUsed), size(sz) {} 
    Block(const Block& b): offset(b.offset), used(b.used), size(b.size) {} 
}; 

class BlockList { 
    Block* first; 
    int size; 
public: 
    BlockList(): first(NULL), size(0) {} 
    void PushBack(const Block&); 
    void DeleteBack(); 
    void PushMiddle(int, const Block&); 
    void DeleteMiddle(int); 
    int Size() const { return size; } 
    void show(); 
    Block& operator[](int); 
    Block* GetElem(int); 
    void SetElem(int, const Block&); 
    ~BlockList(); 
}; 

Je dois surcharger operator[].

Block& BlockList::operator\[\](int index) { 
    try { 
     if (index >= size) 
      throw out_of_range("index out of range"); 
     else 
      return (first[sizeof(Block)*index]); 
    } 
    catch(exception& e) { 
     cerr << e.what() << endl; 
    } 
} 

void BlockList::PushBack(const Block& b) { 
    if(!size) 
     first = new Block(b); 
    else { 
     Block* temp = new Block[size + 1]; 
     int i = 0; 
     for (i = 0; i < size; i++) 
      temp[sizeof(Block)*i] = this->operator[](i); 
     delete []first; 
     temp += sizeof(Block); 
     temp->offset = b.offset; 
     temp->size = b.size; 
     temp->used = b.used; 
     first = temp; 
    } 
    size++; 
} 

Lorsque j'utilise PushBack pour pousser le premier élément, il fonctionne bien, mais quand il vient au deuxième, troisième, ..., le programme n'a pas écrasé, mais il montre juste les résultats que je didn` Je ne m'attends pas à voir.

Voici comment je reçois le contenu de mon tableau:

void BlockList::show() { 
    for (int i = 0; i < size; i++) { 
     Block current(operator[](i)); 
     cout << "off: " << current.offset << " size: " << current.size << endl; 
    } 
} 

Answer 1

premier est un bloc pointeur de sorte que vous ne devez passer index.

Bloc * en premier; ...

first[0] //returns the first element 
first[1] //returns the second element 

Dans votre exemple, vous passez trop élevé d'une valeur d'index lors de l'indexation d'abord parce que vous utilisez sizeof à l'intérieur.

code corrigé:

Block& BlockList::operator[](int index) { 
    try { 
     if (index >= size) 
      throw out_of_range("index out of range"); 
     else 
      return (first[index]);//<--- fix was here 
    } 
    catch(exception& e) { 
     cerr << e.what() << endl; 
    } 
} 

Answer 2

Un tableau sait la taille de ses éléments sont, de sorte que vous ne devez pas faire le calcul avec sizeof(Block). Utilisez simplement i comme index. Sur une note connexe, le C++ FAQ Lite a une grande section sur la surcharge de l'opérateur qui couvre toutes sortes de choses utiles.