Версия для печати темы Нажмите сюда для просмотра этой темы в оригинальном формате

Форум программистов > C/C++: Общие вопросы > operator+ и.т.п

Автор: kkkggg 15.6.2006, 09:32

Я не могу понять как, описать operator+. #include <iostream.h> class complex  { public:     int r,i;     complex(int re, int im):r(re),i(im) {}     complex operator+(complex); }; complex complex::operator+(complex a) { //    Что сдесь нужно писать? } int main() { complex a = complex(1,3); complex b = complex(6,8); complex c = a + b; return 0; } Помогитье довести данный пример до ума...

Автор: Daevaorn 15.6.2006, 09:55

Код #include <iostream.h> class complex  { public:     int r,i;     complex(int re, int im):r(re),i(im) {}     complex& operator+(const complex&); //!!! }; complex& complex::operator+( const complex& a ) {    r += a.r;    i += a.i;    return *this; } int main() { complex a = complex(1,3); complex b = complex(6,8); complex c = a + b; return 0; } Для справки: есть std::complex

Автор: kkkggg 15.6.2006, 10:50

Теперь довайте разбираться    complex& operator+(const complex&); Что означает "&" ? Я помню что это раздел "Указатели", и называется он амперсент. Простой пример его использования:  char c = 'a'; char *p = &c; // Теперь *р хранит адрес переменной с. Я непойму зачем он ставится после типа в нашем примере?

Автор: Daevaorn 15.6.2006, 11:10

kkkggg, да, ты прав - это амперсанд. Открой раздел ссылки

Автор: Prehistorik 15.6.2006, 11:12

Код complex& operator+(const complex&); В списке параметров он ставится для того, чтобы не забивать стек. А вот после возращаемого типа для тогго же.... Код complex& complex::operator+( const complex& a ) {    r += a.r;    i += a.i;    return *this; } А вот это не совсем верно. Потому как в примере Код complex a = complex(1,3); complex b = complex(6,8); complex c = a + b; переменная "a" теперь содержит значение (7,11)... по мне, так надо вот так.... Код complex& complex::operator+( const complex& a ) {    return complex(r + a.r, i + a.i); }

Автор: Daevaorn 15.6.2006, 11:34

Цитата(Prehistorik @  15.6.2006,  12:12 ) А вот это не совсем верно. Потому как в примере Точно. Вместо operator+ написал operator+=. Каюсь

Автор: Void 15.6.2006, 16:41

Цитата(Prehistorik @  15.6.2006,  13:12 ) по мне, так надо вот так.... Код complex& complex::operator+( const complex& a ) {    return complex(r + a.r, i + a.i); } А теперь подумай, на что ты возвращаешь ссылку, и почему это работать не будет.

Автор: Earnest 15.6.2006, 18:14

Правильный оператор "+" должен возвращать не ссылку, а значение. И быть константным. Или вообще реализовываться вне класса. И, конечно, не менять значений своих аргументов. Таким как написано выше должен быть оператор += Код complex& complex::operator+=( const complex& a ) {    r += a.r;    i += a.i;    return *this; }

Автор: AlanG 15.6.2006, 18:44

Логика operator+. следующая: Действия производимые над объектами типа + (сложение),  например:  complex c = a + b; вызывают этот оператор(можно сказать функция). Поисходит следующее: объект a генерирует вызов operator+( const complex b), при этом втророй объект (b) посылается в эту функцию в качестве аргумента: complex c = a + b; Код #include <iostream.h> class complex  { public:     int r,i;     complex(int re, int im):r(re),i(im) {}     complex operator+(complex); }; complex* complex::operator+(complex b) {    //Что-то нужно сделать?  //Можно сделать что угодно но сейчас ты указал в обявлении этого оператора, что возвратишь   //ссылку на объект с типом complex  //В принципе сдесь делай что угодно, но эта "функция" возбудится когда ты попытаешся "сложить" два объекта       return *this; //this указывает на объект а, объект который сгенерировал вызов } int main() { complex a = complex(1,3); complex b = complex(6,8); complex *c = a + b; //Первый аргумент сгенерирует operator+,  результатом всего является присвоение ссылки на объект с типом complex, имя ему ты дал [B]c[/B]. return 0; }

Автор: Earnest 15.6.2006, 18:52

AlanG, это ты написал, как не надо делать, я надеюсь? Не говоря уж о том, что код компилироваться не будет (путаешь ссылки с указателями). А еще, в С++ функции редко "возбуждаются", это делают все больше исключения.

Автор: AlanG 15.6.2006, 18:55

Дополню: В функцию неявно передается сылка на вызываемый объект, т.е. а в данном случае, к этому объекту и к его членам, например в твоем классе complex ты указал переменные r и i, к этим членам можно обратится на "прямую", не указываея объект. Код class complex  { public:     int r,i;     complex(int re, int im){r=re; i=im;}     complex operator+(complex); }; complex* complex::operator+(complex b) {     r=i*b.i; //Перемножим переменные i из разных объектов, и присвоим итог переменной i     //Заметь, что сдесь использовались две переменные, одня из "текущего" объекта,  а другая из b    return *this; //this указывает на объект а, объект который сгенерировал вызов } int main() { complex a = complex(1,3); complex b = complex(6,8); complex *c = a + b; //Первый аргумент сгенерирует operator+,  результатом всего является присвоение ссылки на объект с типом complex, имя ему ты дал [B]c[/B]. return 0; От себя: Лично мне нравится логика operator, она очень проста в понимании, и может пригодится в повседневной работе программисат. Добавлено @ 18:58  Цитата AlanG, это ты написал, как не надо делать, я надеюсь? Я не смотрю на код, я простопытаюсь логику выделить   Может код ошибочный но не в этом суть.

Автор: Earnest 15.6.2006, 19:58

AlanG, ты извини, но такими объяснениями ты новичка вообще запутаешь.  kkkggg,  правильный оператор + должен быть таким (2 варианта): Код // 1 версия: оператор-член класса  const complex complex::operator+(const complex& rhs) const {    complex res;    res.r = r+rhs.r;    res.i = i +rhs.i;    return res; } // 2 версия: внешний оператор  const complex operator+(const complex& lhs,const complex& rhs) {    complex res;    res.r = lhs.r+rhs.r;    res.i = lhs.i +rhs.i;    return res; } Второй вариант лучше, т.к. позволяет компилятору выполнить преобразование левого операнда (скажем из ... тьфу, только сейчас заметила, что у тебя реальная и мнимая части представлены как целые   ... ну да ладно).

Автор: MAKCim 15.6.2006, 20:52

все равно operator+ лучше реализовывать через operator+= тем более, что его, имхо, обязательно нужно реализовывать (тем более в случае complex)

Автор: Earnest 16.6.2006, 07:18

Никто и не спорит.

Автор: AlanG 16.6.2006, 09:01

Цитата Второй вариант лучше, т.к. позволяет компилятору выполнить преобразование левого операнда (скажем из ... тьфу, только сейчас заметила, что у тебя реальная и мнимая части представлены как целые   ... ну да ладно).  Можно по подробнее про реальную и мнимую часи  ? И про преобразование левого операнда.

Автор: Earnest 16.6.2006, 10:08

Да вот же код класса с интами в качестве реальной и мнимой частей: Код class complex  { public:     int r,i;     complex(int re, int im):r(re),i(im) {}     complex operator+(complex); }; Цитата(AlanG @  16.6.2006,  10:01 ) И про преобразование левого операнда. Если определено преобразование из double в complex (например, не explicit конструктор с один аргументом double), то в таком случае: Код double a = ...; complex b = ...; complex с = a + b;   // будет работать только при внешнем операторе + complex d = b + a;   // будет работать в любом случае компилятор сможет использовать оператор сложения комплексных чисел только в том случае, если он определен как внешний. А с точки зрения математики такая запись вполне естественна и не должна зависеть от порядка аргументов.

Автор: AlanG 16.6.2006, 12:32

Цитата Да вот же код класса с интами в качестве реальной и мнимой частей: Реальное здесь переменные r и i, а мнимое, их инициализация  (:r(re),i(im) {} )что ли?  Чет не вкурю логику  . Цитата Если определено преобразование из double в complex (например, не explicit конструктор с один аргументом double), то в таком случае: Определено программой или пользователем? Если пользователем, то как? Цитата complex с = a + b;   // будет работать только при внешнем операторе + А я считал что будет работать из-за того что второй аргумент является типом[ B]complex[/B], Оператор ветдь принимает тип complex. Или я ошибаюсь  ??? Можно по подробнее описывать, а то я моло что понимаю  , все-таки начинающий.

Автор: MAKCim 16.6.2006, 13:18

Цитата Определено программой или пользователем? Если пользователем, то как? программу пишет программист    Код struct A {     A(int) {} }; struct B {     explicit B(int) {} }; void F(A a) {} void G(B b) {} int main() {     F(12); // OK     G(12); // Error     return 0; }

Автор: Earnest 16.6.2006, 18:00

Цитата(AlanG @  16.6.2006,  13:32 ) А я считал что будет работать из-за того что второй аргумент является типом[ B]complex[/B],  Если сложение реализовано как метод класса complex, то преобразовать a (которое у нас double)  в комплекс, а потом вызвать для него operator + компилятор не догадается. А для double оператора + (complex) нет. То, как компилятор разрешает перегруженные имена, называется поиском Кенига. Во многих книгах по C++ это описано, почитай, весьма полезно. Вкратце, компилятор начинает с поиска подходящего метода класса. Если не нашел, ищет глобальный оператор в данной области действия (scope). И т.д. Важно то, что при поиске методов класса компилятор использует точный тип левого операнда. Т.е. методы класса complex вообще проверяться не будут, т.к. левый операнд у нас double.

Автор: MAKCim 16.6.2006, 21:08

Цитата То, как компилятор разрешает перегруженные имена, называется поиском Кенига. Я полагаю поиск Кенига - это поиск имен в пространстве имен аргумента Т. е если параметр принадлежит какому-то пространству имен и вызывается функция с этим параметром в качестве аргумента, то перегрузка идет с учетом поиска этой функции в этом пространстве имен

Автор: UnrealMan 17.6.2006, 12:35

Цитата(MAKCim @  15.6.2006,  20:52 ) все равно operator+ лучше реализовывать через operator+= В общем случае такой подход, как мне кажется, не очень-то хорош. Если требуется безопасный в отношении исключений код (в данной задаче это неактуально), то в operator+= появятся накладные расходы по сохранению старого значения, которые совершенно незачем переносить в operator+. Если же делать наоборот (operator+= реализовывать через operator+), то в данной задаче имеем лишнее копирование в operator+=. Так что если хочется общности, то лучше использовать стороннюю функцию и выражать оба оператора через неё: Код static complex &Addition(complex &dst, const complex &src) {     dst.r += src.r;     dst.i += src.i;     return dst; } friend complex operator +(complex a, const complex &b) {     return Addition(a, b); } complex &operator +=(const complex &c) {     return Addition(*this, c); /* примерный код для обеспечения безопасности (если бы таковая потребовалась):     complex tmp = *this;     swap(Addition(tmp, c));     return *this; */ } void swap(complex &c) {     std::swap(r, c.r);     std::swap(i, c.i); }

Автор: UnrealMan 17.6.2006, 13:17

Цитата(Earnest @  15.6.2006,  18:14 ) Правильный оператор "+" должен возвращать не ссылку, а значение. И быть константным.  Насколько строго должно выполняться требование константности?

Автор: AlanG 17.6.2006, 13:43

Цитата . А для double оператора + (complex) нет. И все таки: Определение operator + () в классе предполагает (нужна для) обработку при соответствующих действиях (типа + (сложение) или / (деление)) над объектами соответствующего класса??? При чем вызываются эти операторы обычно  левым оператором (вернее operatorу() неявно передается ссылка на этот объект), при бинарной операции? Т.е. это как команда для компилятора, что нужно совершить те действия которые объявлены в теле operato+().

Автор: UnrealMan 17.6.2006, 15:17

Цитата(AlanG @  17.6.2006,  13:43 ) При чем вызываются эти операторы обычно  левым оператором (вернее operatorу() неявно передается ссылка на этот объект), при бинарной операции?  Что ещё за левый оператор такой? :-) Наверно, ты имел в виду левый операнд, но тогда не понятно, как это операнд может вызывать оператор :-) Для данного найденного в коде плюсика ищется соответствующий (наиболее подходящий – исходя из количества операндов, а также их типов) operator+. А вообще да будет http://www.infortech.ru/solutions/articles/programm/art1/chap7.shtml тебе в помощь.

Автор: Earnest 17.6.2006, 17:26

Цитата(UnrealMan @  17.6.2006,  14:17 ) Насколько строго должно выполняться требование константности?   Это общепринятая идиома: оператор + не изменяет своих операндов - т.е. является константным, если определяется как метод. Цитата(MAKCim @  16.6.2006,  22:08 ) Я полагаю поиск Кенига - это поиск имен в пространстве имен аргумента Насколько я помню, это принцип поиска имен в С++ вообще, в том числе и то, что ты сказал.

Автор: UnrealMan 17.6.2006, 18:07

Цитата(Earnest @  17.6.2006,  17:26 ) Это общепринятая идиома: оператор + не изменяет своих операндов  Я про другую константность подумал: возвращаемого значения.

Автор: MAKCim 17.6.2006, 19:51

Цитата Насколько я помню, это принцип поиска имен в С++ вообще, в том числе и то, что ты сказал. Поиск Кенига понятие более конкретное в отличие от просто "поиск"

Автор: Earnest 19.6.2006, 06:28

Цитата(UnrealMan @  17.6.2006,  19:07 ) Я про другую константность подумал: возвращаемого значения.   Возвращаемое значение делают константным, чтобы ему нельзя было присваивать, т.е. компилятор ругался на конструкции типа a+b = f; С моей точки зрения это из разряда "святее папы римского", т.е. не слишком обязательно.

Автор: AlanG 19.6.2006, 08:55

Цитата Для данного найденного в коде плюсика ищется соответствующий (наиболее подходящий – исходя из количества операндов, а также их типов) operator+. Ну это понятно.    Цитата А вообще да будет Страуструп тебе в помощь.   Уже помогает, купил >1000 страниц логического счястья

Автор: takedo 19.6.2006, 12:28

UnrealMan, ставлю плюсик, но по моему не освещён вопрос о том, что плюс может быть в выражении с = (а+б+с)*в+..., то есть когда в формуле участвуют несколько операторов

Автор: UnrealMan 19.6.2006, 22:37

Цитата(takedo @  19.6.2006,  12:28 ) но по моему не освещён вопрос о том, что плюс может быть в выражении с = (а+б+с)*в+..., то есть когда в формуле участвуют несколько операторов  http://www.infortech.ru/solutions/articles/programm/art1/chap3.shtml#operrep Там, правда, есть небольшая ошибочка в приоритетах: постфиксные инкремент и декремент на самом деле имеют тот же приоритет, что и [] (а также другие операторы в этой группе), а sizeof expr, напротив, имеет меньший приоритет (такой же, как у префиксного инкремента и т.д.)

Автор: kkkggg 28.6.2006, 05:36

Код #include <iostream.h> class complex  { public: double r,i; complex (double re,double im) {r=re; i=im;} complex& operator+(const complex&); }; complex& complex::operator+(const complex& ARG) {     complex temp = complex(0,0);     temp.r = r + ARG.r;     temp.i = i + ARG.i;     return temp; } int main () { complex a = complex(3,5); complex b = complex(3,5); complex c = complex(2,4); complex d = a+b+c;                                 //!! cout << a.r << "  " << a.i << endl; cout << b.r << "  " << b.i << endl; cout << c.r << "  " << c.i << endl; cout << d.r << "  " << d.i << endl; return 0; } Проблема в вычислениях, когда d = a+b всё ок, а когда d = a+b+c, вот тут проблема. Посмотрите что не так, может оператор я не доконца определил?

Автор: AlanG 28.6.2006, 07:53

Цитата Проблема в вычислениях, когда d = a+b всё ок, а когда d = a+b+c, вот тут проблема. Посмотрите что не так, может оператор я не доконца определил?   Наверно так, думаю что надо еще один аргумент определить в операторе, если ты конечно хочешь принимать два аргумента. Кстати напомню, что в оператор кроме аргументов передается еще и ссылка на вызывающий объект, т.е. в данном случае это объект d, он передается не явно, и ссылатся на него можно с помощъю this в  теле оператора. Код complex& complex::operator+(const complex& ARG, const complex& ARG2) Все таки у тебя он  определен один, с принимающими аргументами в одном кол-ве (const complex& ARG). Можно в принципе определить несколько, с разным кол-вом аргументов, и тогда компилятор сам выберет самый подходящий оператор: Код complex& complex::operator+(const complex& ARG)  //Оператор принимает один аргумент {     complex temp = complex(0,0);     temp.r = r + ARG.r;     temp.i = i + ARG.i;     return temp; }  complex& complex::operator+(const complex& ARG, const complex& ARG2)  //Оператор !один аргумент {     complex temp = complex(1,1);     temp.r = r + ARG.r;     temp.i = i + ARG2.i;     return temp; }

Powered by Invision Power Board (http://www.invisionboard.com)
© Invision Power Services (http://www.invisionpower.com)