Question

我正在进行一项任务，我需要使用模板对向量进行排序，这样我就可以将不同的数据类型传递给我的类，并使用std :: sort对它们进行排序。所以到目前为止我很困我真的不知道如何使用模板接受来自main（）的输入。 PS。这是为了家庭作业，这就是为什么我不使用数组和排序功能。

到目前为止，这是我的代码。

using namespace std;

template <class T>
class SortableVector
{
private:
 T a =0;
public:
  SortableVector();                 // constructor
 ~SortableVector();                // destructor

void bubble_sort(vector<T>, a)


{
    for (int i = a.size(); i > 0;i--)
    {
      for (int j = 0, k = 1; k < i;j++, k++)
      {
        if (a[j] > a[k])
        {
          int swap = a[j];
          a[j] = a[k];
          a[k] = swap;
       }
     }
   }
}
};

我的主要是这样的：

int main()
{


  int alen, val;
  vector<int> a;
  cout << "Enter the number of elements : ";
  cin >> alen;
  for(int i = 0; i < alen; i++)
  {
   cin >> val;
    a.push_back(val);
  }
  SortableVector::bubble_sort(a);
  cout << "List of sorted elements: " << endl;
  for(int i = 0; i < alen; i++)
  {
    cout << a[i] << " ";
  }
      cout << endl;
}

欢迎任何帮助：）

好的... 所以，由于Namfuak，我做了一些改变

现在我有一个完全不同的问题

命令行输出;

Hw8_3.cpp :(。text + 0x11）：未定义引用SortableVector<int>::SortableVector()' Hw8_3.cpp:(.text+0x138): undefined reference to SortableVector :: ~SingleableVector（）' Hw8_3.cpp :(。text + 0x170）：未定义引用`SortableVector :: ~SingleableVector（）' collect2：错误：ld返回1退出状态

我真的没有得到这个。这是我到目前为止的代码;

template <class T>  
class SortableVector
{
private:
 vector<T> vec;
 public:
  SortableVector();                 // constructor
 ~SortableVector();                // destructor
void push_back(T push) {vec.push_back(push);}  
T bubble_sort(vector<T> a);
};

template <class T>
T SortableVector<T>::bubble_sort(vector<T> a)
{


for (int i = a.size(); i > 0;i--)
{
  for (int j = 0, k = 1; k < i;j++, k++)
  {
    if (a[j] > a[k])
    {
      T swap = vec[j];
      vec[j] = vec[k];
      vec[k] = swap;
   }
 }
   }return 0;
}

我的主要（）;

{
 SortableVector<int> L;

  int alen, val;
  vector<int> a;
  cout << "Enter the number of elements : ";
  cin >> alen;
  for(int i = 0; i < alen; i++)
  {
    cin >> val;
    L.push_back(val);
  }
 L.SortableVector<int>::bubble_sort(a);
  cout << "List of sorted elements: " << endl;
  for(int i = 0; i < alen; i++)
  {
    cout << a[i] << " ";
  }

}

还有其他想法吗？我真的迷失在这里......

Answer 1

如果您使用的是模板，则swap变量必须属于该模板类型。 IE：

T swap = a[j];

编辑：仔细观察，我认为你没有使用正确的设计。您的SortableVector可能应该有vector<T>成员，IE：

template <class T>
class SortableVector
{
private:
     std::vector<T> vec;
public:
    SortableVector();
    ~SortableVector();
    void push_back(T push) {vec.push_back(push);}
    void bubble_sort() //You could also return a sorted version of vec
}

否则，没有SortableVector类的原因，您可以将该函数作为模板化函数放在全局空间中。

Answer 2

您需要提供构造函数和析构函数的定义。

如果您没有声明它们，编译器将自动为您创建它们。构造函数将在每个元素（以及基类，如果有的话）上调用默认构造函数，析构函数将调用每个类元素的析构函数。

但是，由于您已声明它们，因此您还需要提供定义。

Answer 3

错误很明显：

Hw8_3.cpp:(.text+0x11): undefined reference to SortableVector<int>::SortableVector()'
Hw8_3.cpp:(.text+0x138): undefined reference toSortableVector::~SortableVector()' Hw8_3.cpp:(.text+0x170): undefined reference to `SortableVector::~SortableVector()' collect2: error: ld returned 1 exit status

您没有定义构造函数和析构函数......

SortableVector() { }
~SortableVector() { }

或者如果你想：

template<class T>
SortableVector::SortableVector()
{
...
}

template<class T>
SortableVector::~SortableVector()
{
...
}

另外，这一行L.SortableVector<int>::bubble_sort(a);为什么不只是L.buble_sort(a);
另外，在这里：

template <class T>
T SortableVector<T>::bubble_sort(vector<T> a)

您是否知道您传递了a的副本而不是参考？这意味着您对该向量的任何修改都不会出现在主函数的vector<int> a;或您从中调用它的任何函数中：

template <class T>
T SortableVector<T>::bubble_sort(vector<T>& a)

注意&

此：

  vec[j] = vec[k];
  vec[k] = swap;

您的意思是a吗？

这个班级成员没用：

vector<T> vec;

我建议提供附加到该成员的函数，然后从类中的vector<T>& a函数中删除bubble_sort参数，然后不要在主函数中创建另一个向量，或者用w / e，在SortableVector类实例上使用push。

Answer 4

#include <vector>
#include <algorithm> //This library give us some handy function swap
#include <iostream>
#include <random>

// This is a function to create random number between 1 and 10
static int random_int(){
    static std::random_device rd;
    static std::mt19937 prng{ rd() };
    static std::uniform_int_distribution<> d10{1, 10};
    return d10(prng);
}


template<class T>
class SortableVector{
    //By default element define in classes are private so no need to specify
    std::vector<T> v_;
public:
    //You dont need to specify constructor
    //Also, you dont need to specify destructor.
    //This is because the default constructor and destructor are ok.
    //The default constructor use item to item copy. In this case it's gonna copy the vector val_ wich is ok.
    //For the destructor, we don't need to do anything

    //Usually you use const T& to avoid copy
    void push_back(const T& val){
        v_.push_back(val);
    }

    //Here i don't really know what u want to do.
    //Do you want to sort your inner vector and return it ?
    //Or do you want to make a copy and return it ?

    //Let's make a static method so it helps us covering both cases.
    //This method is static so it can be used outside of an instance.
    //It's like a function that is define inside the scope of this class.
    static void bubble_sort(std::vector<T>& v){
        //Using the correct type is always better.
        //In this case it's the type that define the size of this particular vector is :
        size_t size = v.size();//Or with c++11 : auto size = v.size()
        bool change;
        do{
            change = false;
            for(int i = 0; i < size - 1; ++i){
                if(v[i-1] > v[i]){
                    std::swap(v[i-1],v[i]);
                    change = true;
                }
            }
        }
        while(change);
    }

    //This is the method version using the static one.
    std::vector<T>& bubble_sort(){
        bubble_sort(v_);
        return v_;
    }
};
int main() {
    SortableVector<int> ss;
    for(int k = 0; k < 10; ++k){
        ss.push_back(random_int());
    }
    for(auto& elem : ss.bubble_sort()){//C++ 11 foreach
        std::cout << elem << std::endl;
    }
}

泡泡排序矢量模板类

4 个答案: