вопрос по С++

по моему это довольно неудачный пример. И конечно память будет течь.

Хотя можно предположить, что у Vec вообще нет членов и он не занимает памяти????

Это предположение оправдывает постоянное копирование при вызове и возврате значения из

Vec operator+(Vec a, Vec b)

Но, скорее всего, это просто грубые ошибки в дизайне.

Дык это твоя должна быть забота - удалить s.

> Дык это твоя должна быть забота - удалить s.

фишка в том что в s будет храниться лишь копия результата сумирования (копия поэлементная, если иного не предусмотрено переопеределённой опирацией =), поэтому добраться до элемента созданного new не представляется возможным, если только его где-то отдельно не сохранять (если так делать а потом самому удалять это не объктный подход а чёрте что).

Да согласен пример не удачный, но это пример из Страуструпа, вот что..... А подскажите как грамотно перегрузить опирацию +(только не +=, а именно +)?

Type operator+(Type &ob) {
return ob+*this;
}

Желательно, чтобы для Type был конструктор копии.

> как грамотно перегрузить опирацию +
Если нужны вектора или всякие там матрицы, то проще всего взять их
готовыми. Например с boost.org библиотека boost/numeric/ublas.
Там, кстати, операция + очень красиво, но достаточно сложно перегружена.

Если нужно, что то свое сделать по принципу дешево и эффективно, то
я бы использовал, что то типа:

typedef std::vector<MyClass> Vector;
typedef boost::shared_ptr<Vector> Vector;
VectorPtr plus( const Vector& a; const Vector& b)
{
  //добавь всякие проверки по вкусу ...
  boost::shared_ptr<Vector> resL(new Vector);
  std::transform(a.begin(),a.end(),b.begin(), std::back_inserter(*resL), std::plus<MyClass>());
  return resL;
}
Но если все же душа просит c=a+b, то можно сделать например так
std::list<VectorPtr> globalList;
Vector&
operator+ (const Vector& a; const Vector& b)
{
   globalList.push_back( plus(a,b));
   return *globalList.back();
}

typedef boost::shared_ptr<Vector> Vector;
читать как
typedef boost::shared_ptr<Vector> VectorPtr;

> А подскажите как грамотно перегрузить опирацию +(только не +=, а именно +)? 

Грамотно - это всегда перегружать их обе.  "+=" - членом класса, "+" - членом класса или свободной ф-ией - это дело вкуса, но определять её в любом случае через "+="

struct foo {
  const foo& operator+=(const foo &rhs) {
     // bla-bla-bla
     return *this;
  }
};

const foo operator+(const foo &rhs, const foo &lhs) {
  foo foo_(rhs);
  return (foo_ += lhs);
}

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

>const foo operator+(const foo &rhs, const foo &lhs)

все это абсолютно верно, но проблема заключается, что происходит ненужное копирование объекта foo. А для векторов это довольно дорого... Поэтому и приходится выкручиваться