Russian Qt Forum

class Matrix {
...
const Matrix & operator+(const Matrix & other);
/* Функция, складывающая матрицы по указателям. 
 * Динамически выделяет память под матрицу-результат
 * и возвращает указатель на нее, не модифицируя исходных операндов. */
Matrix* addMatrix(Matrix* other);
...
}
...
const Matrix & Matrix::operator+(const Matrix & other) {
    Matrix* result = this->addMatrix(&other);

    return *result;
}

Matrix m1(15,15);
m1.fillWithRandValues();

Matrix m2(15,15);
m2.fillWithRandValues();

Matrix m3 = m1 + m2;

//-----------------------------------------------------------------------------
ArrayMatrix* ArrayMatrix::addMatrix(const ArrayMatrix* other) const {
	// Если размеры матриц совпадают
    if(this->rowCount() == other->rowCount() &&
            this->columnCount() == this->columnCount()) {
        // Инициализировать матрицу-результат
        int result_rows = this->rowCount();
        int result_columns = this->columnCount();
        ArrayMatrix* result_matrix = new ArrayMatrix(result_rows, result_columns);

        // Выполнить поэлементное сложение
        for(int row = 0; row < this->rowCount(); row++) {
            for(int column = 0; column < this->columnCount(); column++) {
                double sum = this->value(row, column) + other->value(row, column);
                    result_matrix->setValue(row, column, sum);
            }
        }

        return result_matrix;
    }

    return NULL;
}

Matrix m3 = m1 + m2;

Matrix & m3 = m1 + m2;

	ArrayMatrix m4 = m1 + m2;
	std::clog << "m4 [" << &m4 << "]" << endl;
	const ArrayMatrix &ref_m5 = m1 + m2;
	std::clog << "ref_m5 [" << &ref_m5 << "]" << endl;

const Object& Object::operator+(const Object& other) {
    Object result = (*this);
    result += other;
    return result;
}

Object o3 = o1 + o2;

void f() {
  Object* ptr_obj = new Object();

  // ... Здесь может возникнуть исключение и delete не будет вызван ...

  delete ptr_obj;
}

void f() {
  std::auto_ptr<Object> smart_ptr( new Object() );

  // ...
  // Вызов delete больше не нужен, его вызовет деструктор smart_ptr
}

Rational a = 10;
Rational b(1, 2);
Rational c = a * b;

inline const Rational operator*(const Rational& lhs, const Rational& rhs) {
    return Rational( lhs.numerator() * rhs.numerator(), 
                            lhs.denominator() * rhs.denominator() );
}