从 BubbleSort* 类型的右值初始化 'AssortedSorter&' 类型的非常量引用无效"

Question

我正在编写一个程序，它有一个抽象基类"AssortedSorted"，一个派生类"BubbleSort"和一个测试排序"AssortedSorterTest"的类。

这个想法是创建一个bubbleSort实例，将该实例传递给assortedSorterTest的实例以及一个用于创建和排序的随机数数量的int，如果向量被排序并且包含与给定的向量相同数量的元素，则从assortedsorter.testSort((方法返回true。

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

"从 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的指针。

您正在尝试将对基类的引用绑定到BubbleSort。这是行不通的。

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

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

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

这需要#include<memory>.

---

或者，考虑到main中的代码现在看起来如何，根本不需要动态分配。只是

BubbleSort bubbleSort;

也会做。