Есть класс:

class A{
public:
    int k;

    A(int v)
    {
        k = v;
    }
    A(B &b)
    {
                printf("Yes %d", &b);
    }
    void pr()
    {
        printf("Yes");
    }
    virtual ~A()
    {
        printf("\nDestr A %d", k);
    }

    A &operator=(const A &a) 
    {
        k = a.k;
        return *this;
    }

    A &operator+(const A &a) const
    {   
        A s(k + a.k);
        s.pr();
        return s;
    }
};

Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения? И если не правильно, то как сделать правильно? через static?

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


INR>Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения? И если не правильно, то как сделать правильно? через static?

правильно, объяснять почему воздержусь, может что-то не то ляпну

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

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


INR>>Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения? И если не правильно, то как сделать правильно? через static?

I>правильно, объяснять почему воздержусь, может что-то не то ляпну

Вроде не правильный, надо наверное так A operator+(const A &a) const

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

I>

I> class A{
I> public:

I>  . . .

I>  A &operator+(const A &a) const
I>  {
I>   A s(k + a.k);
I>   s.pr();
I>   return s;
I>  }
I> };
I>

I> Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения?

Верно.

I> И если не правильно, то как сделать правильно? через static?

Нет, не через static. Через возврат по значению:

    A operator+(const A &a) const
    {
        A s(k + a.k);
        s.pr();
        return s;
    }

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

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

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


INR>>>Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения? И если не правильно, то как сделать правильно? через static?

I>>правильно, объяснять почему воздержусь, может что-то не то ляпну

INR>Вроде не правильный, надо наверное так A operator+(const A &a) const

я написал так птому, что у меня в таком виде нормально все шло, поэтому от объяснений воздержался,
точно не знаю, что скажет Павел Кузнецов?

Здравствуйте, Павел Кузнецов, Вы писали:

ПК>

ПК>    A operator+(const A &a) const
ПК>

В книге просто опечатка

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

INR>Здравствуйте, Павел Кузнецов, Вы писали:

ПК>>

ПК>>    A operator+(const A &a) const
ПК>>

INR>В книге просто опечатка

А если следовать принципу "семантика перегруженных операторов должна соответсвовать семантике встроенных", то еще лучше так:

const A operator+(const A &a) const

ПК>

ПК>    A operator+(const A &a) const
ПК>    {
ПК>        A s(k + a.k);
ПК>        s.pr();
ПК>        return s;
ПК>    }
ПК>

А как происходит всё это? Создаётся объект после return s, на который берётся ссылка, и объект уничтожется после завершения оператора = ?

INsideR wrote:

I> Есть класс:
I>

I>  A operator+(const A &a) const
I>  {   
I>   A s(k + a.k);
I>   s.pr();
I>   return s;
I>  }
I>

I> Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения? И если не правильно, то как сделать правильно? через static?

Возвращай результат по значению, а не по ссылке.

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

    A operator+(const A & a)
    {   
        A s(k + a.k);
        s.pr();
        return s;
    }
};

Если дополнительное копирование объекта напрягает (меня например напрягает) почитай статьи Александреску про MOJO.

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


ПК>>

ПК>>    A operator+(const A &a) const
ПК>>    {
ПК>>        A s(k + a.k);
ПК>>        s.pr();
ПК>>        return s;
ПК>>    }
ПК>>

I> А как происходит всё это? Создаётся объект после return s, на который
I> берётся ссылка, и объект уничтожется после завершения оператора = ?

В точке вызова выделяется память под возвращаемое значение. Внутри функции, в точке return s,
в ранее выделенной памяти создается объект (путем вызова конструктора копирования). Объект s
разрушается при выходе из функции. После завершения полного выражения, в котором содержался вызов
operator+, результат вызова разрушается. Внутри полного выражения результат может быть скопирован,
или к нему может быть привязана константная ссылка, продляя время его жизни. Также компилятору разрешено
в целях оптимизации опускать копирование объекта s в возвращаемое значение, конструируя s
прямо в выделенной под возвращаемое значение памяти.

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

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

INR>>Здравствуйте, Павел Кузнецов, Вы писали:

ПК>>>

ПК>>>    A operator+(const A &a) const
ПК>>>

INR>>В книге просто опечатка

B>А если следовать принципу "семантика перегруженных операторов должна соответсвовать семантике встроенных", то еще лучше так:
B>

B>const A operator+(const A &a) const
B>

B>

Это почему это

const A operator+(const A &a) const

?????
Я, например хочу написать

a = b+c;

а не могу без const_cast, так как a — не константа???
Бред... Ты сам понимаешь, какой бред получается ??? Зачем тогда нужно это сложение?
Если я что-то не так понял — жду возражений..!

Здравствуйте, Доброжелатель, Вы писали:


Д>Это почему это

const A operator+(const A &a) const

?????

Д>Я, например хочу написать
Д>

a = b+c;

Д>а не могу без const_cast, так как a — не константа???
Д>Бред...


Д>Ты сам понимаешь, какой бред получается ??? Зачем тогда нужно это сложение?
Д>Если я что-то не так понял — жду возражений..!

А при чем тут а? Константой является результат operator+, и в приведенном тобой выражении — результат выражения b+c. Это уже потом получившаяся константа присвивается a. А поскольку сигнатура оператора присвивания выглядит так:

A& operator = (const A& rhs);

то никаких приблем при присваивании не возникнет.
Вот так

a = b + c;

а семантика оператора = следующая:

A& operator=(const A& _right);

Вот и получается:

a.operator=(b.operator+(c)); // все ок

Или так (если оператор + — глобальный)

a.operator=(operator+(b, c)); // все ок

Написано абсолютно правильно и будет работать.
В зависимости от компилятора C++ (точнее — оптимиздера кода переменная 's' будет либо сконструирована сразу же на области стека, отведенной для возвращаемого значения, либо при возврате будет вызван конструктор копирования.
Чтобы запутать Вас окончательно, задам вопрос: что происходит при возбуждении исключенияи каким образом объект исключения распространяется выше по стеку?
class Exception {...};

class MyException : public Exception {};

void myFunc()
{
throw MyException(...);//генерируем исключение
//здесь сгенерированный объект исключения уничтожается, но перед смертью он копируется в вызывающий стековый фрейм с помощью конструктора копирования
}

void main()
{
try
{
myFunc();
//здесь мы имеем уже не оригинальный объект исключения, а его копию
}
catch (MyException &e)
{
printf("MyException\n");
}
}
Кстати, если попытаться поймать не 'Exception &e' (ссылка), а 'Exception e' (значение), то информация о типе исключения (MyException) будет безвозвратно потеряна и при вызове 'throw;' далее по стеку будет распространяться только 'Exception'. По крайней мере, это происходит в известных мне компиляторах.

Respectfully,
Alexander Fedin (alexanderfedin@iname.com)
"INsideR" <forum@rsdn.ru> wrote in message news:414389@news.rsdn.ru...
From: INsideR

Есть класс:
class A{
public:
int k;

A(int v)
{
k = v;
}
A(B &b)
{
printf("Yes %d", &b);
}
void pr()
{
printf("Yes");
}
virtual ~A()
{
printf("\nDestr A %d", k);
}

A &operator=(const A &a)
{
k = a.k;
return *this;
}

A &operator+(const A &a) const
{
A s(k + a.k);
s.pr();
return s;
}
};


Правилен ли оператор +, помойму нет, ведь s уничтожается до возвращения? И если не правильно, то как сделать правильно? через static?

Глупый вопрос по operator+ Оценить