Цитата

Угу. Кроме того зачем нужны лишние расходы на копирование, если можно их избежать?

не совсем... я думал привести этот аргумент...
тут есть одна тонкость: если поле вычисляемое, в любом случае надо создавать объект, который будет хранить результаты
в случае возврата ссылки единственный способ - создать объект в куче и вернуть ссылку на него (потому как возвращать ссылку на временный объект - просто ужасно), это приведет к путаннице с вопросом "кто и когда должен его удалять, чтобы не было утечки памяти"
в случае вычислимых полей вариант без ссылки действительно лучше...

пожалуй многие согласятся с тем, что кучу перегруженных operator [] лучше заменить на пару:
operator SomeType*(void)
и
operator const SomeType*(void)

просто подумайте, на сколько это удобно
somestor_cl[someindex] - работает
(somestor_cl + someindex)->SomeField - работает
и не надо лишнее писать:return somestor[index]

Ещё один плюс (на мой взгляд - наиболее значимый): в операторе [] - шаблонный класс не сможет выдать подсказку после ".", или "->" при нажатии Ctrl+Space, а в SomeType*(void) - сможет

Цитата(maxim1000 @ 14.10.2005, 17:22)

не совсем... я думал привести этот аргумент... тут есть одна тонкость: если поле вычисляемое, в любом случае надо создавать объект, который будет хранить результаты в случае возврата ссылки единственный способ - создать объект в куче и вернуть ссылку на него (потому как возвращать ссылку на временный объект - просто ужасно), это приведет к путаннице с вопросом "кто и когда должен его удалять, чтобы не было утечки памяти" в случае вычислимых полей вариант без ссылки действительно лучше...

Я не очень понял что такое "вычислимые поля", а также почему "в любом случае надо создавать объект". Но проблемы никакой тут нет и копировать ничего не надо. И вообще что ты имел в виду
Добавлено @ 17:35

Цитата(GremlinProg @ 14.10.2005, 17:24)

пожалуй многие согласятся с тем, что кучу перегруженных operator [] лучше заменить на пару

Я не соглашусь. В этом случае класс SomeType будет участвовать и в других контекстах как указатель. Нет причин отказываться от оператора[].

Цитата

пожалуй многие согласятся с тем, что кучу перегруженных operator [] лучше заменить на пару: operator SomeType*(void) и operator const SomeType*(void)

и что они будут возвращать?
для этого придется гарантировать, что все объекты контейнера идут по порядку, а это - далеко не самый частый случай...

Цитата

Ещё один плюс (на мой взгляд - наиболее значимый): в операторе [] - шаблонный класс не сможет выдать подсказку после ".", или "->" при нажатии Ctrl+Space, а в SomeType*(void) - сможет

сможет...(тестировал в Builder'е, VC под рукой нету)

Цитата

Я не очень понял что такое "вычислимые поля"

пример:
пусть мы сделали класс векторов, у которых координаты образуют арифметическую прогрессию (при создании указывается начало и шаг), при этом нам очень хотелось бы, чтобы была возможность писать cout<<v[6];
все бы хорошо, но хранить все эти значения просто расточительно
для такого вектора длиной 100 нужно будет 100 чисел, хотя можно было бы обойтись двумя (начальным элементом и шагом)
тогда можно написать такой оператор:

Код

double operator[] (int index) const {   return a0+index*step; };

в этом случае ссылку возвращать попросту не на что...

Цитата

В этом случае класс SomeType будет участвовать и в других контекстах как указатель

поясни, не понял
Добавлено @ 17:46

Цитата

для этого придется гарантировать, что все объекты контейнера идут по порядку

ну и на сколько часто в коде встречается арифметическая прогрессия? Если чаще всего нужен просто УДОБНЫЙ ВЕКТОР.

Цитата

сможет...(тестировал в Builder'е, VC под рукой нету)

Вот и зря, что нету, "а какие же в билдере богатые шаблоны..." просто так, к слову.

Цитата(maxim1000 @ 14.10.2005, 17:38)

пример: пусть мы сделали класс векторов, у которых координаты образуют арифметическую прогрессию (при создании указывается начало и шаг), при этом нам очень хотелось бы, чтобы была возможность писать cout<<v[6]; все бы хорошо, но хранить все эти значения просто расточительно для такого вектора длиной 100 нужно будет 100 чисел, хотя можно было бы обойтись двумя (начальным элементом и шагом) тогда можно написать такой оператор:

Ну ты загнул Это очень нестандартный пример использования оператора []. Я имел в виду случай когда возврат по значению и по ссылке на константу по смыслу равнозначны.

Цитата(GremlinProg @ 14.10.2005, 17:41)

поясни, не понял

Во-первых ты наверное имел в виду не оператор преобразования к SomeType* , а к типу указателя на встроенный тип.

Цитата(LPBOY @ 14.10.2005, 17:29)

В этом случае класс SomeType будет участвовать и в других контекстах как указатель.

Это я имел в виду что теперь объекты SomeType можно
- разыменовывать
- складывать с целыми числами
- осуществлять неявное преобразование к bool и void*
- передавать в функцию, если на самом деле она ждет указатель и т.д.
Эти побочные эффекты явно ни к чему.

Это сообщение отредактировал(а) LPBOY - 14.10.2005, 17:55

Честно говоря, класс, который в операторе [] возвращает элемент, по арифметической прогрессии мне не вселил бы уверенности, т.к. его логика непонятна. Оператор [] изначально подразумевает ВЕКТОР. Не вижу логики, зачем прятать элементарную формулу в контейнере, когда можно( и нужно! ) повесить независимый класс на индекс. Повторюсь, не вижу логики, мы ведь должны облегчить читаемость кода, а не скомпоновать всё и вся

Цитата(LPBOY @ 15.10.2005, 01:51)

Это я имел в виду что теперь объекты SomeType можно - разыменовывать - складывать с целыми числами - осуществлять неявное преобразование к bool и void* - передавать в функцию, если на самом деле она ждет указатель и т.д. Эти побочные эффекты явно ни к чему.

А если ещё и не увлекаться explicit конструкторами, то поведение программы может стать непредсказуемым.

LPBOY
похоже, ты не понял

Код

template<typename T> class X{   T*  lpvector; public:   operator T*(){return lpvector;}   operator const T*()const{return lpvector;} }

пример:

Код

X<int> x; x[2] = x[3]+x[8]

это я и имел ввиду!

здесь не создаются промежуточные экземпляры, оператор T* ведёт себя, как встроенный оператор []

Это сообщение отредактировал(а) GremlinProg - 14.10.2005, 18:00

Цитата

ну и на сколько часто в коде встречается арифметическая прогрессия?

это был всего лишь пример на вычислимые поля

Цитата

Если чаще всего нужен просто УДОБНЫЙ ВЕКТОР

пример: частоиспользуемый страндартный контейнер map
или, например, динамический список с добавленной операцией доступа по номеру...

Цитата

Вот и зря, что нету, "а какие же в билдере богатые шаблоны..." просто так, к слову.

сильно подозреваю, что и в VC сможет
operator[] не очень-то от функции отличается, так что сложность определения, что выдавать при нажатии "." после значения известного типа (а тип известен) не сильно зависит от того, оператор там стоит или функция...
Добавлено @ 18:03

Цитата

Ну ты загнул  Это очень нестандартный пример использования оператора []. Я имел в виду случай когда возврат по значению и по ссылке на константу по смыслу равнозначны

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

Цитата(GremlinProg @ 14.10.2005, 17:58)

это я и имел ввиду!

Я понял. Я просто говорю про побочные эффекты... Чем тебе оператор [] не нравится?

Цитата(srd @ 14.10.2005, 17:56)

А если ещё и не увлекаться explicit конструкторами, то поведение программы может стать непредсказуемым.

Просто вариант с оператором преобразования не такой чистый и понятный как с оператором [].

хорошо, что есть map, а то я и не знал. Вот только нотификации о изменении базы вектора я что-то там не наблюдаю. А ведь это огромный минус и как быть. Понимаешь, не всё можно найти в stl и ей подобных, иногда нужно и свои мозги включать!

Цитата

Честно говоря, класс, который в операторе [] возвращает элемент, по арифметической прогрессии мне не вселил бы уверенности, т.к. его логика непонятна

почему непонятна?
просто этот класс представляет собой вектора с указанным ограничением
никто не запрещает хранить их в классическом виде, но "маскирование" оператора [] позволяет:
1. сократить затраты памяти
2. не заставлять пользователей класса менять свой код

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

такие вектора можно использовать при построении разреженных матриц, а это - вообще отдельная тема в численных методах...
Добавлено @ 18:08

Цитата

Вот только нотификации о изменении базы вектора я что-то там не наблюдаю

честно говоря, не понял, что имелось в виду...

Код

Просто вариант с оператором преобразования не такой чистый и понятный как с оператором [].

ты и вправду так думаешь?

class X{
public:
X(int){}
};

class Y{

public:
X operator[](unsigned id){
if(id < length){
X null;
return null
}
return lpvector[id];
}
};
допустим, Y - шаблон, а X - параметр шаблона, как в предыдущем варианте, что будет?

Цитата(GremlinProg @ 14.10.2005, 18:13)

допустим, Y - шаблон, а X - параметр шаблона, как в предыдущем варианте, что будет?

Просвети...