массивы — C ++ функция Хэмминга

Предполагается, что эта программа создаст три массива объекта класса My_array. Первый массив заполнен случайными числами. Второй массив является точной копией первого. Третий массив вводится пользователем. Программа проверяет, чтобы убедиться, что первые два массива действительно равны друг другу, а затем проверяет расстояние Хэмминга первого и третьего массивов. Профессор определяет расстояние Хэмминга как каждую часть массива, которая отличается.

Моя проблема в том, чтобы заставить Хэмминга работать. На самом деле мне трудно работать с перегрузкой, поэтому я удивлен, что это работает (ну, у меня нет ошибок, показывающих в VS Studio), но я не хамминг. Любая помощь будет оценена. Есть три файла по порядку: main.cpp, my_array.cpp, а также my_array.h, Определения функций и декларации были предоставлены профессором. Я должен указать, как работает каждая функция.

#include "my_array.h"#include <iostream>
using namespace std;

int main()
{
int size;

cout << "How big of an array shall we work with? ";
cin >> size;
My_array a(size);
My_array b(size);
My_array c(size);

a.randomize(100);

b = a;

c.input();cout << a << endl;
cout << b << endl;
cout << c << endl;

cout << "a != b: " << (a != b) << endl;
cout << "a == b: " << (a == b) << endl;
cout << "The hamming distance is: " << a.hamming(c);return 0;
}#include "my_array.h"#include <iostream>
using namespace std;
#include <stdlib.h>
#include <time.h>// Constructor
My_array::My_array(int the_size)
{
array = NULL;
size = 0;
resize(the_size);
}

// Destructor.
My_array::~My_array()
{
empty();
}

// Copy constructor
My_array::My_array(My_array &data)
: size(data.size)
{
array = new int[size];
for (int i = 0; i<size; i++)
array[i] = data.array[i];
}

// Overloaded assignment operator.
My_array &My_array::operator=(My_array &data)
{
if (this != &data) {
resize(data.size);
for (int i = 0; i<size; i++)
array[i] = data.array[i];
}
else
cout << "Attempt to copy an object on itself. "<< "Operation ignored." << endl;
return *this;
}

void My_array::input()
{
int j;
cout << "Please enter " << size << " numbers.\n";

for (int i = 0; i < size; i++)
{
cout << "Number " << i + 1 << ": ";
cin >> j;
array[i] = j;
}
}

void My_array::randomize(int limit)
{
srand(time(NULL));

for (int i = 0; i < size; i++)
array[i] = rand() % limit + 1;
}

bool My_array::operator ==(My_array &data)
{
if(this->size != data.size)
return false;
for (int i = 0; i <size; i++)
{
if (*this[i].array != data.array[i])
return false;
}
return true;
}

bool My_array::operator !=(My_array &data)
{
if (*this == data)
return false;
return true;
}

int My_array::hamming(My_array &data)
{
int ham = 0;

for (int i = 0; i < size; i++)
if (*this[i].array != data[i].array)
ham++;
return ham;
}

// This function will empty the target object
void My_array::empty()
{
if (size != 0 && array != NULL) {
size = 0;
delete[] array;
}
}

// Resize the array.
void My_array::resize(int the_size)
{
if (size >= 0) {
empty();
if (the_size != 0) {
size = the_size;
array = new int[size];
}
}
else
cout << "Resize attepmted with a negative size. "<< "Operation ignored." << endl;
}

// Access an element of the array.
int &My_array::operator[](int index)
{
if (index < size)
return array[index];
else {
cerr << "Illegal access to an element of the array." << endl
<< "The size of the array was " << size
<< " and the index was " << index << endl;
exit(1);
}
}

// Accessor
int My_array::get_size()
{
return size;
}

void My_array::output()
{
cout << "The array of size " << size
<< " contains the elements:" << endl;
for (int i = 0; i<size; i++)
cout << array[i] << ' ';
cout << endl;
}

//overloading the << operator.
ostream &operator<<(ostream &out, My_array &data)
{
out << "The array of size " << data.size
<< " contains the elements:" << endl;
for (int i = 0; i<data.size; i++)
out << data.array[i] << ' ';
out << endl;
return out;
}

#ifndef MY_ARRAY_H
#define MY_ARRAY_H

#include <iostream>
using namespace std;

class My_array {
protected:
int size;
int *array;

public:
// Constructor
My_array(int the_size = 0);

// Destructor
~My_array();

// Copy constructor
My_array(My_array &data);

// Assignment operator
My_array &operator=(My_array &data);

void input();

void randomize(int limit);

bool operator ==(My_array &data);

bool operator !=(My_array &data);

int hamming(My_array &data);

// Deletes the array
void empty();

// Resize the array.
void resize(int the_size = 0);

// Access an element of the array.
int &operator[](int index);

// Returns the size of the array.
int get_size();

// Output the elements of the array.
void output();friend ostream &operator<<(ostream &out, My_array &data);
};

#endif