Ссылка типа «Bucket &» (не квалифицированная как const) не может быть инициализирована значением типа «SortedList».Как можно исправить эту ошибку?

Question

Ошибка возникает в моем классе SortedList в методе функции sortList.Я пытался переименовывать, удалять, перемещать и манипулировать некоторыми вещами безрезультатно.Я покажу вам хороший объем кода, чтобы вы могли видеть, откуда я иду.

void SortedList::sortList(const vector <double>& list) {
    BucketSort bucketA;
    bucketA.insert(list);
    bucketA.createSortedList(*this); // <--- Problem here, on this one line. 
                                    // The * is highlighted in red in my IDE.
}

Ошибка: ссылка типа "Bucket &" (не квалифицированная как const) не может быть инициализированасо значением типа "SortedList"

Для справки, если вам нужно посмотреть, чтобы получить контекст моей ошибки:

SortedList.h:

#ifndef SORTEDLIST_H
#define SORTEDLIST_H    

#include "bucketsort.h"
#include <vector>

using namespace std;

class SortedList
{
public:
    SortedList();
    void sortList(const vector <double>& list);
    ~SortedList();
private:
};

#endif

Bucketsort.h:

#ifndef BUCKETSORT_H
#define BUCKETSORT_H    

#include "bucket.h"
#include <iostream>
#include <vector>
#include <iomanip>

using namespace std;

const int DEFAULTCAPACITY = 10;

class BucketSort
{
public:
    // Constructors:
    BucketSort();
    // Functions:
    void print() const;
    void insert(const vector <double>& v) const;
    void createSortedList(Bucket& a);
    //
    ~BucketSort();
private:
    Bucket ** a;
};

#endif

Bucketsort.cpp:

#include "bucketsort.h"

BucketSort::BucketSort() {
    a = new Bucket*[DEFAULTCAPACITY]();
}

void BucketSort::print() const {
    for (int i = 0; i < DEFAULTCAPACITY; ++i) {
        if (a[i] != nullptr) {
            a[i]->print();
        }
    }
}

void BucketSort::insert(const vector <double>& v) const {
    int index;

    for (int i = 0; i < v.size(); ++i) {
        index = v[i] * 10;

        if (a[index] == nullptr) {
            Bucket* newBucket = new Bucket;
            a[index] = newBucket;
        }

        a[index]->insert(v[i]);
    }
}

void BucketSort::createSortedList(Bucket& a){

}

BucketSort::~BucketSort() {
    for (int i = 0; i < DEFAULTCAPACITY; ++i) {
        if (a[i] != nullptr) {
            a[i]->deleteBucket();
        }
    }

    delete a;
    a = nullptr;
}

Bucket.h:

#ifndef BUCKET_H
#define BUCKET_H    

#include <iostream>
using namespace std;

class Node
{
public:
    Node() : item(0.0), link(nullptr) {}
    Node(double newItem, Node *newLink) : item(newItem), link(newLink) {}
    Node* getLink() const { return link; }
    double getItem() const { return item; }
    void setItem(double newItem) { item = newItem; }
    void setLink(Node *newLink) { link = newLink; }
    ~Node() {}
private:
    double item;
    Node *link;
};


class Bucket
{
public:
    Bucket();
    void insert(double value);
    void testPrint() const;
    void print() const;
    int getNumberOfElements() const;
    void deleteBucket();
    ~Bucket();
private:
    Node * ptrToFirst;
    Node *ptrToLast;
    int numberOfElements;
};

#endif

Bucket.cpp:

#include "bucket.h"

Bucket::Bucket() {
    ptrToFirst = nullptr;
    ptrToLast = nullptr;
    numberOfElements = 0;
}

void Bucket::insert(double value) {
    if (numberOfElements != 0) {
        Node *newNode = new Node(value, nullptr);

        if (value < ptrToFirst->getItem()) {
            newNode->setLink(ptrToFirst);
            ptrToFirst = newNode;
        }
        else if (value > ptrToLast->getItem()) {
            ptrToLast->setLink(newNode);
            ptrToLast = newNode;
        }
        else if (value != ptrToFirst->getItem()) {
            Node *current = ptrToFirst;

            while (value > current->getLink()->getItem()) {
                current = current->getLink();
            }

            if (current->getLink()->getItem() != value) { 
                newNode->setLink(current->getLink());
                current->setLink(newNode);
            }
        }
    }
    else {
        ptrToFirst = new Node(value, ptrToLast);
        ptrToLast = ptrToFirst;
    }

    ++numberOfElements;
}

void Bucket::testPrint() const {
    cout << "Pointer to first: " << ptrToFirst << endl;
    cout << "Pointer to last: " << ptrToLast << endl;

    if (ptrToFirst != nullptr && ptrToLast != nullptr) {
        cout << "Value of ptrToFirst: " << ptrToFirst->getItem() << endl;
        cout << "Value of ptrToLast: " << ptrToLast->getItem() << endl;
    }

    cout << "Number of elements: " << numberOfElements << endl;
    cout << "Contents of bucket: " << endl;

    Node *current = ptrToFirst;
    while (current != nullptr) {
        cout << current->getItem() << " ";
        current = current->getLink();
    }

    cout << endl;
}

void Bucket::print() const {
    Node *current = ptrToFirst;

    while (current != nullptr) {
        cout << current->getItem() << " ";
        current = current->getLink();
    }
}

int Bucket::getNumberOfElements() const {
    return numberOfElements;
}

void Bucket::deleteBucket() { 
    Node *trailingCurrent;

    while (ptrToFirst != nullptr) {
        trailingCurrent = ptrToFirst;
        ptrToFirst = ptrToFirst->getLink();
        delete trailingCurrent;
        trailingCurrent = nullptr;
    }

    ptrToLast = nullptr;
    numberOfElements = 0;
}

Bucket::~Bucket() {
    deleteBucket();
}

Помощь?

Answer 1

void SortedList::sortList(const vector <double>& list) {
   [...]
   bucketA.createSortedList(*this); // <--- Problem here

В приведенной выше строке this относится к типу SortedList *, поэтому *this относится к типу SortedList &.

... и, тем не менее, ваш метод createdSortedList требуетаргумент другого типа, Bucket &:

void createSortedList(Bucket& a);

Поскольку SortedList и Bucket не являются одинаковыми типами, и нет способа (о котором знает компилятор) преобразоватьSortedList объект в Bucket объект, компилятор правильно помечает вызов как ошибку.

Чтобы решить эту проблему, вам нужно либо изменить createSortedList, чтобы принять SortedList & в качестве егоаргумент, вместо Bucket &, или измените ваш вызов, чтобы передать Bucket & вместо SortedList &.