1

我有一个非类的合并功能。

合并.cpp

template <typename T>
vector<T> merge(vector<T> left, vector<T> right){
    vector<T> result;
    int left_current = 0, right_current = 0;
    while(left_current < left.size() && right_current < right.size()){
        if(left[left_current] <= right[right_current]){
            result.push_back(left[left_current]); 
            left_current++;
        }else{
            result.push_back(right[right_current]); 
            right_current++;
        }
    }
    while(left_current < left.size()){
        result.push_back(left[left_current]); 
        left_current++; 
    }
    while(right_current < right.size()){
        result.push_back(right[right_current]); 
        right_current++;    
    }
    return result;
}


template <typename T>
vector<T> merge_sort(vector<T> arr){
    vector<T> left, right, result;
    if(arr.size() <= 1)
        return arr;
    int middle = arr.size() / 2;

    for(int i=0;i<middle;i++){
        left.push_back(arr[i]);
    }
    for(int i=middle;i<arr.size();i++){
        right.push_back(arr[i]);
    }

    left = merge_sort(left);
    right = merge_sort(right);
    arr = merge(left,right);
    return arr;
}

通常，我像这样在 main 中调用 merge 。

vector<int> sorted_vector=merge_sort(my_vector);

但是，我想这样调用 main 。

my_vector.merge_sort()

为了以第二种方式调用，我教我需要一个不接受 Sorter 类的参数和参数的成员函数。所以，我实现了我的成员函数，如下所示。

分拣机.cpp

template<typename T>
void Sorter<T>::merge_sort(){

    vector<int> sorted_vector = merge_sort(my_vector_2);

}

我进行了研究，发现这是关于辅助功能的，但我无法弄清楚。我的方法是否正确？

4

1 回答 1

0

所以我要吐出一些陈词滥调。

  • 纯函数——接受显式输入并返回显式输出——更容易推理。

  • 懒惰，少做事。

一般来说，方法是不纯的；它们对它们所附着的对象进行操作，隐式地获取和返回其整个状态。因此，如果函数本身不是一团糟，就状态而言，请尝试将其保持为纯函数。

另一方面，将函数附加到对象对于代码完成来说是很好的；通过首先提及名词（对象），无脑代码完成代码可以更轻松地找到您的方法及其签名。同时，自由函数是一大堆动词，代码完成工具更难使用。

接下来，此代码有一个您需要清理的小问题：

template <typename T>
vector<T> merge(vector<T> left, vector<T> right){

将此调整为：

template <typename T>
vector<T> merge(vector<T> const& left, vector<T> const& right){

甚至更好的是，获取/的span对象。leftright

对于您的方法：

template<typename T>
void Sorter<T>::merge_sort();

现在，除了作为练习之外，拥有一个作为“分类器”的有状态对象是非常荒谬的。

我认为它看起来像这样：

template<typename T>
class Sorter {
public:
  std::vector<T> m_data;
  void merge_sort();
};

（该m_部分只是提醒这是一个成员）。

在这种情况下，你会这样写merge_sort：

template<typename T>
void Sorter::merge_sort() {
  m_data = ::merge_sort(m_data);
}

并做了。

（如果merge_sort在命名空间中，例如my_code，替换::为my_code::）。

令人讨厌的部分是merge_sort方法和merge_sort函数具有相同的名称。默认情况下，由于名称查找规则，成员会阻止查找函数。::ormy_code::告诉编译器你merge_sort在说什么。

于 2020-10-27T14:30:37.987 回答