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 没有成员称为“数组”。