В неком классе на основе некого массива есть такой оператор:

Код

class SomeClass { //****************************** SomeType *somestor; SomeType operator[](unsigned long index){return somestor[index]}; //****************************** };

Испытываю проблемы при компиляции... ругается на вот такое:

Код

//*******************Где-то в методе чужого класса... //*********somestor_cl - обьект класса SomeClass somestor_cl[someindex].SomeMemb = SomeValue; //*****

Говорит, что значение может присвоенно быть только переменной, это я и без него знаю(lvalue must be left!) Вот только непонятно почему я не могу присвоить SomeMemb находящемуся в некоторой структуре SomeType значение SomeValue, как надо обращаться в подобных случаях ?

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

Точно!!!
Вот она ошибка...
Добавлено @ 11:22
somestor_cl[someindex]->SomeMemb - это во вторых, а
SomeType operator[](unsigned long index){return somestor[index]};
меняем на SomeType* operator[](unsigned long index){return &somestor[index]};

А может вместо
SomeType* operator[](unsigned long index){return &somestor[index]};
лучше будет
SomeType& operator[](unsigned long index){return somestor[index]};
и писать потом
somestor_cl[someindex].SomeMemb

srd
У меня к ссылкам какое-то врожденное недоверие...


Добавлено @ 15:20
по мне так лучше возвращать указатель( это из области наглядности, которую мы кстати уже в одной теме обсуждали)

Цитата(En_t_end @ 13.10.2005, 23:18)

У меня к ссылкам какое-то врожденное недоверие...

В противном случае ты нарушаешь семантику оператора []. Оператор [], возвращающий указатель на объект вместо ссылки, это как оператор +, который вместо сложения операндов их перемножает.

Цитата

У меня к ссылкам какое-то врожденное недоверие...

ПОЧЕМУ????(ИМХО) ЭТО ОЧЕНЬ ОЧЕНЬ УДОБНЫЙ ИНСТРУМЕНТ.

Цитата(srd @ 13.10.2005, 11:27)

А может вместо SomeType* operator[](unsigned long index){return &somestor[index]}; лучше будет SomeType& operator[](unsigned long index){return somestor[index]};

И еще в пару к нему

SomeType operator[](unsigned long index) const {return somestor[index]};

Чтобы совсем было правильно. Это чтобы с константными объектами правильно работалось. И брось на тему ссылок заморачиваться.

Цитата

SomeType operator[](unsigned long index) const {return somestor[index]};

а почему не так:
const SomeType &operator[](unsigned long index) const {return somestor[index]};
?
просто я представил ситуацию:
const SomeType *f(const SomeClass &qqq)
{
return &qqq[1];
}
void g(const SomeClass &qqq)
{
print(*f(qqq));
}

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

Можно и так (если объект большой и его не очень хочется возвращать по значению).

А вот твой пример - это не аргумент. Это в равной степени относится к любым стандартным контейнерам STL. И вообще к любой функции, которая возвращает значение, а не ссылку.
Пример:

Код

double getFive() { return 5.0; } double* very_stupid_func() {    return & getFive(); }

Ну и ?

Такие функции просто не надо писать.
Не надо забывать, что C++ дает возможность писать безопасный код, а вовсе не гарантирует безопасность - как бы программист не выделывался.

Я так полагаю, что maxim1000 имел в виду другую проблему:

Код

class S { public:     S(void)         : a(0)     {}             int operator[](size_t index) const {return a[index];}     int& operator[](size_t index) {return a[index];} private:     int* a; }; void func(const int* a) {     // ... } int main(void) {     int a[5];     func(&a[0]);          S s1;     func(&s1[0]);     const S s2;     // Если константый оператор [] возвращает копию, то получаем ошибку компиляции.     // Заменяем возвращаемое значение оператора на константную ссылку (const int&) и всё ок.     func(&s2[0]);     return 0; }

Кошерные оператор [] должен возвращать ссылку, а константынй оператор [] - константную ссылку.

Не согласна, это пример из той же серии.
Ведь в зависимости от реализации, объект может просто не существовать в памяти, а скажем вычисляться, или еще как-то хитро выковыриваться. Константный опаратор [] должен вызывать нечто, что может быть rvalue, и не обязано иметь адрес. А "кошерный" код не должен закладываться на реализацию. Сегодня я использую массив в памяти (внутри класса), а завтра захочу усложнить реализацию, и все буду хранить, ну не знаю, на соседней машине. Попробуй скажи, что не имею права! И полетит твой код ко всем чертям.
Еще раз повторяю - такие функции просто нельз я писать.

вот с чем я тут полностью соглашусь, так это с тем, что и та, и та форма может оказаться правильным решением в конкретной ситуации

просто я стараюсь придерживаться того, чтобы при переопределении какого бы то ни было оператора его семантика менялась как можно меньше, и если информации о ситуации недостаточно, я придерживаюсь этого принципа
а взятие адреса поддреживается стандартным []

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

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

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

Цитата(maxim1000 @ 14.10.2005, 16:57)

просто я стараюсь придерживаться того, чтобы при переопределении какого бы то ни было оператора его семантика менялась как можно меньше, и если информации о ситуации недостаточно, я придерживаюсь этого принципа а взятие адреса поддреживается стандартным []

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

Ну что ж, оператор[], качающий данные с соседней машины - это суровый аргумент Впрочем, я остаюсь при своём мнении - поведение перегруженного оператора должно быть максимально похоже на поведение встроенного.