从类型为BubbleSort *的右值开始，对'AssortedSorter＆'类型的非常量引用进行了无效的初始化”

Question

[我正在编写一个具有抽象基类“ AssortedSorted”，派生类“ BubbleSort”和用于测试排序“ AssortedSorterTest”的类的程序。

想法是创建一个bubbleSort实例，将该实例与一个用于创建和排序的随机数的整数一起传递给assortedSorterTest的实例，如果对向量进行了排序，则从assortedsorter.testSort（）方法返回true。包含与给定向量相同数量的元素。

如果您阅读了代码，则需要进行一些更改才能完成此操作，但是除非它们与我当前有关main的第16行上的无效初始化的问题相关，否则我不关心更正这些问题。 cpp。我得到的错误是这个

“从BubbleSort类型的右值对类型为'AssortedSorter＆'的非常量引用进行的无效初始化”

起初，我认为将#include“ BubbleSort.h”添加到AssortedSorterTest类中可能会纠正此问题，但并没有。我还尝试过将某些引用更改为指针，这给我带来了新的问题，因此我改回了引用。我没有运气来解决这个问题，所以任何帮助都将不胜感激。

#pragma once
#include <vector>
#include <string>

class AssortedSorter
{
public:

    virtual std::vector<int> sort(const std::vector<int> &itemsToSort) = 0;
    virtual std::string getName() const = 0;
    virtual ~AssortedSorter() {};

};

#include <sstream>

class BubbleSort : public AssortedSorter
{    
private:
    long loopCount{0};
    long swapCount{0};

public:
    BubbleSort();
    ~BubbleSort() override;

    std::vector<int> sort(const std::vector<int> &itemsToSort) override;
    std::string getName() const override;
    friend std::ostream &operator<<(std::ostream &out, const BubbleSort &rhs);


};

#include "BubbleSort.h"

BubbleSort::BubbleSort()
{
}

BubbleSort::~BubbleSort() 
{
}

std::vector<int> BubbleSort::sort(const std::vector<int> &itemsToSort)
{

    std::vector<int> itemsSorted = itemsToSort;
    bool swap{false};
    int temporary_num{};

    do
    {
        swap = false;

        for (int index = 0; index < itemsSorted.size()-1; index++)
        {
            loopCount++;

            if (itemsSorted[index] > itemsSorted[index + 1])
            {
                swapCount++;

                temporary_num = itemsSorted[index];
                itemsSorted[index] = itemsSorted[index + 1];
                itemsSorted[index + 1] = temporary_num;
                swap = true;
            }
        }
    } while (swap);

    return itemsSorted;
}

std::string BubbleSort::getName() const
    {return "BubbleSort";}

//Overloaded insertion operator
std::ostream &operator<<(std::ostream &os, const BubbleSort &rhs)
{
    os << rhs.getName() << ":     " <<  std::to_string(rhs.loopCount) << "          " << std::to_string(rhs.swapCount);
    return os;
}

#pragma once
#include "AssortedSorter.h"
#include <vector>

class AssortedSorterTest
{
public:
    AssortedSorterTest();
    ~AssortedSorterTest();
    bool testSort(AssortedSorter &assortedSorter, int size);

};

#include "AssortedSorterTest.h"

AssortedSorterTest::AssortedSorterTest()
{
}

AssortedSorterTest::~AssortedSorterTest()
{
}

bool testSort(AssortedSorter &assortedSorter, int size)
{
    std::vector<int> randomNumbers;

    for(int index{0}; index < size; index++)
    {
        randomNumbers.push_back(rand());
    }

    std::vector<int> sortedVector = assortedSorter.sort(randomNumbers);

    if(sortedVector == randomNumbers)
    {
        return true;
    }

    else
    {
        return false;
    }
}

#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
#include "AssortedSorterTest.h"
#include "BubbleSort.h"


std::vector<int> assign_vector_values(int size);

int main()
{

    std::vector<int> vec = assign_vector_values(100);

    AssortedSorter &bubbleSort = new BubbleSort; //problem is here

    AssortedSorterTest sortTester;

    if(sortTester.testSort(bubbleSort, 100))
    {
        std::cout << "Vector has been sorted" << std::endl;
    }

    else
    {
        std::cout << "Vector has not been sorted properly" << std::endl;
    }

    delete bubbleSort;

    return 0;
}


std::vector<int> assign_vector_values(int size)
{
    std::vector<int> temp_vector;

    for(int index{0}; index < size; index++)
    {

        temp_vector.push_back(rand());
    }

    return temp_vector;
}

Answer 1

错误消息告诉您确切的问题是什么。

new BubbleSort导致对BubbleSort的指针。

您正在尝试将reference绑定到BubbleSort的基类。那行不通。

要么需要取消引用指针，要么需要初始化pointer而不是引用。

在任何情况下，您都不应在现代C ++中使用裸露的new / delete。使用std::unique_ptr<AssortedSorter>和std::make_unique<BubbleSort>()代替：

std::unique_ptr<AssortedSorter> bubbleSort = std::make_unique<BubbleSort>();

这需要#include<memory>。