Нужна помощь

[aibalit]

Здравствуйте. Есть код и нужно сделать так, чтобы перегрузки операторов + и > были описаны в абстрактном классе.
Оператор сложения: c[i][j]=(a[i][j]+b[i][j])/(amin+bmin), где amin и bmin - минимальные элементы в iой строке
Оператор >: Истина, если среднее арифметическое икаждого столбца 1 матрицы > чем среднее арифметическое кадого столбца во 2ой матрице

#include "StdAfx.h"
#include <iostream>
#include <cstring>
#include <fstream>
#include <locale>

using namespace std;

class Matrix {
public:
  int size; 
  int elSize; 
  char **values; //память для хранения элементов различного типа

  Matrix(): size(0), elSize(0), values(0) {}

  Matrix(int els): size(0), elSize(els), values(0) {}
  
  Matrix(int s, int els)
  {
    size = s;
    elSize = els;
    values = new char*[size]; 
    
    for (int i = 0; i < size; ++i) { 
      values[i] = new char[size*elSize];
    }
  }
  
  Matrix(const Matrix &m) //конструктор копирования
  {
    delete[] values; 
    size = m.size; 
    values = new char*[size]; 
    int rowSize = size * elSize; 
    
    for (int i = 0; i < m.size; ++i) {
      values[i] = new char[rowSize]; 
      memcpy(values[i], m.values[i], rowSize); 
    }
  }

  ~Matrix()
  {
    delete[] values;
  }

  void operator=(const Matrix &m); 
 
  void operator++(); //префиксный инкремент
 
  void operator++(int) //постфиксный инкремент
  { 
    operator++(); //делать то же самое, что и при префиксном
  }

  void operator--(); //префиксный декремент

  void operator--(int) //постфиксный декремент
  {
    operator--();
  }

  virtual void out1(ostream& os, int i, int j) = 0; 
  virtual void in1(istream& is, int i, int j) = 0;
  
  void out(ostream& os)
  {
    for (int i = 0; i < size; ++i) {
      for (int j = 0; j < size; ++j) {
	out1(os, i, j);
	os << ' ';
      }
      os << endl;
    }
  }

  void in(istream& is)
  {
    for (int i = 0; i < size; ++i) {
      for (int j = 0; j < size; ++j) {
	in1(is, i, j);
      }
    }
  }
};

class MatrixFloat : public Matrix
{
public:
  MatrixFloat(): Matrix(sizeof(float)) {}
  MatrixFloat(int size): Matrix(size, sizeof(float)) {}

  void out1(ostream& os, int i, int j)
  {
    os << *(float*)&values[i][j*elSize];
  }

  void in1(istream& is, int i, int j)
  {
    is >> *(float*)&values[i][j*elSize];
  }
  friend MatrixFloat operator+(MatrixFloat& a,MatrixFloat& b);
  friend MatrixFloat operator>(MatrixFloat& a, MatrixFloat& b);
};
MatrixFloat operator > (MatrixFloat& a, MatrixFloat& b)
{
	bool z=1;
	float sumA, sumB, avarA, avarB;
	int k;
	for (int j = 0; j < a.size; ++j) {
		if (z == 0) {
			break;
		}
		sumA = 0;
		sumB = 0;
		avarA = 0;
		avarB = 0;
		k = 0;
		for (int i = 0; i < a.size; ++i) {
			sumA = sumA + a.values[j][i];
			sumB = sumB + b.values[j][i];
			k++;
		}
		avarA = sumA/k;
		avarB = sumB/k;
		if (avarA < avarB) {
			z = 0;
		}
	}
	return z;
}
MatrixFloat operator+(MatrixFloat& a,MatrixFloat& b)
{
	if (a.size=b.size) {
		MatrixFloat temp;  //сохраняем значения во временном массиве
		temp.size = a.size;
		temp.values = new char*[temp.size];
		float amin=a.values[0][0], bmin=b.values[0][0];		
		for (int j = 0; j < a.size; ++j) {
			for (int i = 0; i < a.size; ++i) {
				if (amin > a.values[j][i]){
					a.values[j][i] = amin;
				}
				if (bmin > b.values[j][i]){
					b.values [j][i] = bmin;
				}
			}
		}
		for (int j = 0; j < a.size; ++j) {
			for (int i = 0; i < a.size; ++i) {
				if (amin+bmin==0){
					temp.values[j][i]=0;
				}
				else 
				{
					temp.values[j][i] = (a.values[j][i] + b.values[j][i])/(amin+bmin);
				}
			}
		}
		return temp;
	}
	else 
	{
		cout << "Размеры матриц не совпадают" << endl;
		return 0;
	}
}
 void Matrix::operator=(const Matrix &m)
  {
    delete[] values;
    size = m.size;
    values = new char*[size];
    int rowSize = size * elSize;
    
    for (int i = 0; i < size; ++i) {
      values[i] = new char[rowSize];
      memcpy(values[i], m.values[i], rowSize);
    }
  }