Перегрузка бинарного оператора C ++

Question

Я пытаюсь перегрузить следующие операторы для сортировки массива строк с использованием алгоритма быстрой сортировки или, возможно, сортировки слиянием.У меня есть все мои функции в одном классе, но я получаю ошибку "слишком много параметров для этой операторской функции".Действительно, он будет принимать только один параметр.Я посмотрел на проблему, и на форуме кто-то сказал, что вы можете использовать только один параметр при перегрузке оператора внутри класса.Это не имеет большого смысла для меня.Я пытаюсь сравнить строки, поэтому мне нужны два параметра для перегрузки.Я должен перегрузить операторы вне класса, и как это будет работать?

Вот мой код:

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

class Preprocessing
{

public:

void readFile(string list[], int size);
void quickSort(int list[], int lowerBound, int upperBound);
void swapItem(int &a, int &b);

//These are the overloading functions I'm trying to implement
bool operator<=(string a, string b);
bool operator<(string a, string b);
bool operator>(string a, string b);
};

void Preprocessing::readFile(string list[], int size)
{
ifstream myFile;
myFile.open("words.txt");

for (int i = 0; i < size; i++)
{
    myFile >> list[i];
}

myFile.close();
}

void Preprocessing::quickSort(int list[], int lowerBound, int upperBound)
{
    int i, j, pivot;

    i = lowerBound;
    j = upperBound;

    pivot = list[(i + j) / 2];

    while (i <= j)
    {
        while(list[i] < pivot)
        {
            i = i + 1;
        }
        while (list[j] > pivot)
        {
            j = j - 1;
        }
        if (i <= j)
        {
            swapItem(list[i], list[j]);
            i = i + 1;
            j = j - 1;
        }//end if
    }//end outter while
    if (lowerBound < j)
    {
        quickSort(list, lowerBound, j);
    }
    if (i < upperBound)
    {
        quickSort(list, i, upperBound);
    }//end recursive if
}//end function

void Preprocessing::swapItem(int &a, int &b){
    int tmp;

    tmp = a;
    a = b;
    b = tmp;
}

bool Preprocessing::operator<=(string a, string b)
{
if (a.compare(b) > 0)
    return false;
else if (a.compare(b) == 0)
    return true;
else
    return true;
}

bool Preprocessing::operator<(string a, string b)
{
if (a.compare(b) > 0)
    return false;
else if (a.compare(b) == 0)
    return true;
else
    return true;
}

bool Preprocessing::operator>(string a, string b)
{
if (a.compare(b) > 0)
    return false;
else if (a.compare(b) == 0)
    return true;
else
    return true;
}

Answer 1

Неправильные подписи операторов:

bool operator<=(string a, string b);
bool operator<(string a, string b);
bool operator>(string a, string b);

1. Когда вы перегружаете оператор - и вы реализуете его как функцию-член, он должен принимать только один аргумент (другой вещь для сравнения)
2. Если функция не является членом (т. Е. Другом), то вы можете предоставить два аргумента, однако он не может соответствовать выходящему оператору (есть уже определенный для std::string) и обычно должен принимать ваш класс как lhs и rhs для тестирование.

Answer 2

operator внутри класса, каким бы он ни был, имеет особый смысл применения этого оператора к экземпляру этого класса и, необязательно, к параметрам.

В вашем примере operator<= должен сравнивать экземпляр класса Preprocessing с string.

class Preprocessing
{
public:
    bool operator<=(string a);

private:
    string aStringField;
}

Обычно вы используете this внутри тела метода оператора для сравнения экземпляра с параметром:

bool Preprocessing::operator<=(string a)
{
   return this->aStringField.length() <= a.length();
}

И вы называете это с:

Preprocessing p;
if ( p <= "a string" )
    // ...

Что эквивалентно:

Preprocessing p;
if ( p.operator<=("a string") )
    // ...

Если вы хотите предоставить оператор, которому не нужен «точечный синтаксис» для вызова, то вы ищете friend операторов, которые существуют вне вашего класса.

class Preprocessing
    {
    public:
        friend ostream& operator<<(ostream&, const Preprocessing&);

    private:
        string aStringField;
    }

Answer 3

Чтобы перегрузить оператор, оператор должен быть методом левого операнда. C ++ выбирает функции (и операторы) на основе типов аргументов (операндов). Внутри класса левый операнд является экземпляром класса, доступным как указатель this, поэтому в качестве аргумента оператора может быть указан только правый операнд.

В вашем примере вы можете сделать это:

class Preprocessing {
    public:
        bool operator<=(string b);
};

, который определил бы оператор <= для сравнения Preprocessing объектов со строками. Если вам нужно перегрузить операторы сравнения строк, вам нужно изменить класс std::string, что мне не известно.

Answer 4

Требуется только один аргумент, потому что левая часть передается как указатель this.