Здравствуйте Al-Ko, Вы писали:

AK>для BYTE* не будут, будут для TYPE*

А ну да, смутили БОЛЬШИЕ буквы и наложились друг на друга TYPE и BYTE. Исходя из этого, может лучше использовать довольно ясную конструкцию, говорящую о том, что ты освобождаешь ПРОСТО указатель, упрощая исходный может быть сложный указатель? Которая не приведёт к непоняткам при беглом взгляде на оператор.

    delete (void*) m_pData;

Но дело твоё, так тоже работать будет. Тут ты прав.

Здравствуйте SergH:

Еще вопрос, если не надоел.

template <class T> class IList{
    public:
    int Length;
    T *Items;            //Указатель на сам массив

    IList();
    ~IList();
    IList& operator = (const IList&);
    T operator [](int);
    void Add(const T&);        //Добавить элемент к массиву
    void Add();            //Добавить пустой элемент к массиву
    void Del(int);            //Удалить элемент из массива
    void Clear();            //Отчискта массива
    private:
    };
template <class T> T IList<T>::operator [](int i){
    return Items[i];
    }

Ilist<IList <int> > a;
a.Items[i].Items[i] — работает хорошо
a[i][i] — работает очень плохо
где ошибка?

Здравствуйте Idler, Вы писали:

I>Здравствуйте SergH:

I>Еще вопрос, если не надоел.

I>

I>template <class T> class IList{
I>    public:
I>    T *Items;            //Указатель на сам массив
I>    T operator [](int);
I>    };
I>

I>Ilist<IList <int> > a;
I>a.Items[i].Items[i] — работает хорошо
I>a[i][i] — работает очень плохо
I>где ошибка?


В типе возвращаемого значения: при вызове operator[] возвращаемое значение скопируется. Более правильный прототип таков:

template<class T>
const T& IList::operator [](int) const;

template<class T>
T& IList::operator [](int);

кстати, лучше его еще и перегрузить для константных и неконстантных объектов.

Здравствуйте m.a.g.
Что такое "перегрузить для константных и неконстантных объектов".

Здравствуйте Idler, Вы писали:

I>Здравствуйте m.a.g.
I>Что такое "перегрузить для константных и неконстантных объектов".

Он уже написал это в своём сообщении

template<class T> 
const T& IList::operator [](int) const; 

template<class T> 
T& IList::operator [](int);

Первый оператор можно вызывать для константных объектов, второй нельзя. Без определения первого оператора такой код не скомпилится:

void function(const IList<int>& list)
{
    int a = list[22]; // ошибка - вызов неконстантного оператора для константного объекта
}

А если у тебя определены оба оператора, всё будет хорошо.