Перегрузка операторов

[Nich2000]

Доброго времени суток!
У меня не получается корректно перегрузить некоторые операторы.

Если использовать как хотелось бы:

arr = tmp;
arr[0] = 123;
cout << arr;

Не работает.

А если использую так:

arr->operator=(tmp);
arr->operator[](0) = 123;
operator<<(cout, arr);

То, все нормально.

Вот, описание класса

template<typename T>
class TArray
{
  private:
    size_t size;
    T* array;
  public:
    //----------------------------------------------------------------
    // Конструктор по умолчанию
    TArray(){size = 0; array = new T[size];};
    //----------------------------------------------------------------
    // Конструктор с размером
    TArray(const size_t sz){size = sz; array = new T[size];};
    //----------------------------------------------------------------
    // Конструктор копий
    TArray(const TArray *a)
      {
        size = a->size;

        array = new T(size);

        for(size_t i = 0; i < size; i++)
          array[i] = a->array[i];
      };
    //----------------------------------------------------------------
    // Деструктор
    ~TArray(){delete []array;};
    //----------------------------------------------------------------
    // Размер
    size_t Size(){return size;};
    //----------------------------------------------------------------
    // Заполняем случайно
    void FillRandom(size_t range)
    {
      for(size_t j = 0; j < size; j++)
        array[j] = random(range);
    };
    //----------------------------------------------------------------
    // Оператор []
    T& operator[](const size_t i){return array[i];};
    //----------------------------------------------------------------
    // Оператор вывода
    friend ostream& operator<<(ostream& os, const TArray<T>& a);
    //----------------------------------------------------------------
    // Оператор =
    TArray* operator=(const TArray<T>* a)
      {
        if(this == a) return this;

        size = a->size;
        array = new T(size);
        
        for(size_t i = 0; i < size; i++)
          array[i] = a->array[i];

        return this;
      };
    //----------------------------------------------------------------
};
//--------------------------------------------------------------------

Перегрузка <<

template<typename T>
ostream& operator<<(ostream& os, const TArray<T>& a)
{
  for(size_t i = 0; i < a.size; i++)
    os << a.array[i] << "  ";
  os << endl;
  return os;
};

Подскажите, в чем может быть загвоздка.

[Airhand]

И не будет работать так как вам хочется: тут уже вторгаются операторы из глобальной области видимости. Попробуйте (если есть класс, мне лень разбираться) указать класс, потом двоеточие, потом оператор (так компилятор будет знать какой класс).

[Nich2000]

Сообщение от Airhand

тут уже вторгаются операторы из глобальной области видимости.

Да, я думал об этом. В случае с cout в принципе логично.
Меня больше смущает это:

arr[0] = 123; // Не работает
arr->operator[](0) = 123; // Работает

Как правильно сделать, ума не приложу.
Я программист на Delphi, и не могу перестроить свой мозг для таких трюков.

[Airhand]

Потаму, что в 1 случае использется глобальный оператор, поэтому и не пашет, а во втором случае явно указано, что должен вызываться оператор, описанный для класса, поэтому и пашет.

[Nich2000]

Как правильно вызвать перегруженный оператор []?

[Airhand]

УжО ж мнУ написал, как во втором случае. Можно ещё исхитриться и указать класс или засунуть всё в пространство имён, а потом написать:
{
using namespace ...;

}
Главное в фигурных скобках опять не написать первый вариант (хотя в этом не уверен).