Question

我在使这个程序工作时遇到了一些麻烦。我知道我的问题并不完全具体，但我不知道还能去哪里。这就是我到目前为止所拥有的。插入，大小，擦除，查找和清空所有工作正常。重载的输出操作符和sort函数都被破坏了。必须以这种方式设置程序，因为这是已分配的。

主要测试计划：

#include <iostream>
#include "UList.h"
#include "sortBS.h"
#include <vector>

using namespace std;

int main(){
    UList<size_t> list1(20), list2;

    cout<<list1.size()<<endl;
    cout<<list2.size()<<endl;
    list1.insert(3);
    list1.insert(5);
    list1.insert(4);
    list1.erase(4);
    cout<<list1.find(3)<<endl;
    cout<<list1.find(4)<<endl;
    cout<<list1.empty()<<endl;
    cout<<list2.empty()<<endl;
    sort(list1);
    cout<<list1<<endl;
    //sort
    //<<

}

UList.h

#ifndef UList__H
#define UList__H
#include <iostream>
#include <vector>
#include "sortBS.h"
template <class T>
class UList{
public:
    UList(size_t=10);
    void insert(const T&);
    bool erase(const T&);
    bool find(const T&);
    size_t size() const;
    bool empty() const;
    friend void sort (UList<T>&);
    friend std::ostream& operator << (std::ostream&, const UList<T>&);

protected:
    std::vector<T> items;
};

template <class T>
UList<T>::UList(size_t size){
    items.resize(size);
}

template <class T>
void UList<T>::insert(const T& element){
    items.insert(items.begin(), element);
}

template <class T>
bool UList<T>::erase(const T& element){
    for(size_t index=0; index<items.size(); index++){
        if(element==items.at(index))
            items.erase(items.begin()+index);
            return true;
    }
    return false;
}

template <class T>
bool UList<T>::find(const T& element){
    bool found=false;
    size_t index=0;
    while(index<items.size()){
        if(items.at(index)==element)
            found=true;
        index++;
    }
    return found;
}

template <class T>
size_t UList<T>::size() const{
    return items.size();
}

template <class T>
bool UList<T>::empty() const{
    return items.empty();
}

template<class T>
std::ostream& operator << (std::ostream& out, const UList<T>& List){
    if(List.items.empty())
        out<<"list is empty."<<std::endl;
    else{
        for(size_t index=0;index<List.items.size();index++){
            out<<List.items.at(index);
            if(index<List.items.size()-1)
                out<<" ";
        }
    }
    return out;
}

template<class T>
void sort(UList<T>& List){
    sortBS(List);
}

#endif

sortBS.h

#ifndef sortBS__H
#define sortBS__H
#include <iostream>
#include <vector>
#include "UList.h"

template <class T>
void sortBS(UList<T> List){
    for(size_t iteration=1;iteration<items.size();iteration++){
        for(size_t index=0;index<items.size()-iteration;index++){
            if(items.at(index)>items.at(index+1)){
                T temp = items.at(index);
                items.at(index) = items.at(index+1);
                items.at(index+1) = temp;
            }
        }
    }    
}

#endif // sortBS__H

错误

  ||=== Build: Debug in Program04 (compiler: GNU GCC Compiler) ===|
  G:\Program04\sortBS.h|8|error: variable or field 'sortBS' declared void|
  G:\Program04\sortBS.h|8|error: 'UList' was not declared in this scope|
  G:\Program04\sortBS.h|8|error: expected primary-expression before '>' token|
  G:\Program04\sortBS.h|8|error: 'List' was not declared in this scope|
  G:\Program04\UList.h|15|warning: friend declaration 'void sort(UList<T>&)' declares a                 non-template function [-Wnon-template-friend]|
  G:\Program04\UList.h|15|note: (if this is not what you intended, make sure the    function     template has already been declared and add <> after the function name here) |
  G:\Program04\UList.h|16|warning: friend declaration 'std::ostream&    operator<<(std::ostream&, const UList<T>&)' declares a non-template function [-Wnon-    template-friend]|
 ||=== Build failed: 4 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|

这里是创建程序的规范（这位老师非常模糊，没有丝毫帮助，所以我无法向他寻求帮助（我多次试过））

对于此分配，您将创建一个独立函数sort，它接受UList参数并使用冒泡排序算法对其进行排序。这个sort函数放在一个名为sortBS.h的文件中，而UList应该放在一个名为UList.h的文件中。 UList的UML图如下：

UList<T>
#items: vector<T>
+UList(size_t=10)
+insert(const T&): void
+erase(const T&): bool
+find(const T&) const: bool
+size() const: size_t
+empty() const: bool
+friend operator << (ostream&, const UList<T>&): ostream&
+friend sort (UList<T>&): void
Submit sortBS.h and UList.h prior to the due date/time using the following form (I will        be using my own driver file for grading purposes):

Answer 1

以下是我能找到的问题：

不要在UList.h中包含sortBS.h。 UList不需要存在sortBS（没有它就可以正常工作），所以它不应该包括在内。此外，由于在定义UList实际存在之前包含该文件，因此您会收到错误消息，称sortBS不知道UList是什么。
sortBS声明一个名为List的变量，然后不使用它，并尝试使用名为＆＃34; items＆＃34;的变量。哪个不存在。重命名其中一个以匹配另一个。
sortBS的最后一部分可以简化为：

if（items [index]＆gt; items [index + 1]）std :: swap（items [index]，items [index + 1]）;

Answer 2

首先，不需要sortBS()，因为您只需将sort()声明为班级UList的朋友。

在课程UList中，请使用以下代码：

template< typename C >
friend void sort (UList<C>&);
template< typename C>
friend std::ostream& operator << (std::ostream&, const UList<C>&);

但在sort的功能中，存在错误：您无法直接访问items，请执行vector<T> items(List.items);

template< typename T>
void sort(UList<T>& List){
    vector<T> items(List.items);
    for(size_t iteration=1;iteration<items.size();iteration++){
        for(size_t index=0;index<items.size()-iteration;index++){
            if(items.at(index)>items.at(index+1)){
                T temp = items.at(index);
                items.at(index) = items.at(index+1);
                items.at(index+1) = temp;
            }
        }
    } 
}

如果您只想使用friend void sort (UList<T>&);，你应该将函数sort的定义代码放在类UList中，就像这样：

template <class T>
class UList{
public:
    UList(size_t=10);
    void insert(const T&);
    bool erase(const T&);
    bool find(const T&);
    size_t size() const;
    bool empty() const;
    friend void sort (UList<T>& List)
    {
        vector<T> items(List.items);
        for(size_t iteration=1;iteration<items.size();iteration++){
            for(size_t index=0;index<items.size()-iteration;index++){
                if(items.at(index)>items.at(index+1)){
                    T temp = items.at(index);
                    items.at(index) = items.at(index+1);
                    items.at(index+1) = temp;
                }
            }
        } 
    }
    template< typename C>
    friend std::ostream& operator << (std::ostream&, const UList<C>&);

protected:
    std::vector<T> items;
};

如何使用向量实现冒泡排序

2 个答案: