C++ Функция Хэмминга

Question

Эта программа должна создавать три массива объекта класса 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 

Answer 1

Это:

*this[i].array != data[i].array 

должен быть таким:

array[i] != data.array[i] 

этом:

array[i] != data[i] 

*this не является необходимым, и data[i] является ссылкой на int (тот же, который вы получаете по телефону data.array[i], благодаря вашему operator[]), а int не имеет члена, называемого «массив».