對類構造函數的無法解釋的調用會生成“匹配函數錯誤”

Question

當我調用merge_sort時，我得到一串錯誤，因為最可讀的是：

no matching function call to dynamic_array<int>::dynamic_array()

讓基類實例化子類會導致該子類重新實例化調用基類嗎？

這是我的第一個猜測。

//調用main函數

#include "c_dynamic_array.cpp"
int main()
  {
  dynamic_array<int> d1(20);
  d1.order();cout << d1 << endl;
  d1.rorder();cout << d1 << endl;
  d1.randorder();cout << d1 << endl;
  d1.merge_sort();cout << d1 << endl; // This line starts a string of errors
  }

//動態數組類和合並內部（合並排序）類

#include "c_include.cpp"

/*
Dynamic Array
*/

using namespace std;
template <typename> class merge_inner;

template <class T> class dynamic_array
  {
  protected:
    T* array;
  public:
    int size;
    void rorder();
    void order();
    void randorder();
    void print_operator(ostream&)const;
    dynamic_array(int sizein)
      {
      size=sizein;
      array=new T[size]();
      }
    void merge_sort()
      {
      merge_inner<T> M1;
      }
  };
template <class T> void dynamic_array<T>::print_operator(ostream &os=cout)const
  {
  for (int i = 0; i < size; i++) os << array[i] << endl;
  }
template <class T> void dynamic_array<T>::randorder()
  {
  srand(time(NULL));
  int *ap;
  for(ap=array;ap!=array+size;++ap){*ap=rand()%size;} 
  }
template <class T> void dynamic_array<T>::order()
  {
  int *ap,i=0;
  for(ap=array;ap!=array+size;++ap)                                             
    { 
    *ap=i;
    ++i;        
    } 
  }
template <class T> void dynamic_array<T>::rorder()
  {
  int *ap,i=size-1;
  for(ap=array;ap!=array+size;++ap)                                             
    { 
    *ap=i;
    --i;        
    } 
  }
template<class T> ostream& operator<<(ostream& stream, dynamic_array<T> const& data) 
  { 
  data.print_operator(stream);
  return stream; 
  }   

/*
Merge Sort
*/

template <class T> class merge_inner : public dynamic_array <T>
  {
  using dynamic_array<T>::array;
  private:
    const static int size;
    T *scratch;
    void flip_if_unordered(int &x, int &y)
      {
      if(array[x]>array[y])
        {
        int tmp=array[x];
        array[x]=array[y];
        array[y]=tmp;
        }
      }
    void merge_algo(int &left, int &right_begin, int &right)
      {
      int iter,iter_left=left,iter_right=right_begin;  
      for(iter=left;iter<=right;++iter)
        {
        if( (iter_right>right) || ((iter_left < right_begin) && (array[iter_left]<=array[iter_right])))
          {
          scratch[iter]=array[iter_left];
          ++iter_left;
          }
        else
          {
          scratch[iter]=array[iter_right];
          ++iter_right;
          }
        }
      for(iter=left;iter<=right;++iter){array[iter]=scratch[iter];}
      }
    void merge_recurse(int left,int right)
      {
      int left_end=(left+((right-left)/2)); 
      int right_begin=left_end+1;  
      if(((left+1)==right)){flip_if_unordered(left,right);return;}
      else if ((left==right)){return;}
      else
        { 
        merge_recurse(left,left_end);               
        merge_recurse(right_begin,right);  
        merge_algo(left,right_begin,right);
        }   
      }
  public:
    merge_inner()
      {
      scratch = new T[size]();
      if(scratch != NULL){merge_recurse(0, size);}
      }
  };
/*Quick Sort
    void quick_sort()
      {
      quick_recurse(0,size);
      }
    void quick_recurse(int left, int right) 
      {  
      int l = left, r = right, tmp;
      int pivot = array[(left + right) / 2];
      while (l <= r)
        {
        while (array[l] < pivot)l++;
        while (array[r] > pivot)r--;
        if (l <= r) 
          {
          tmp = array[l];
          array[l] = array[r];
          array[r] = tmp;
          l++;
          r--;
          }
        }
      if (left < r)quick_recurse(left, r);
      if (l < right)quick_recurse(l, right);
      }  
*/

Answer 1

dynamic_array似乎缺少一個默認的構造函數，因為它有一個自定義構造函數，編譯器不會提供一個。 將此添加到您的班級：

  dynamic_array()
  {
      size = 0;
      array = new T[0](); // or NULL, but note that new T[0] will be != NULL
  }

或者，為現有構造函數提供默認sizein ，以便它也可以用作默認構造函數：

dynamic_array(int sizein = 0)

Answer 2

由於您的基類dynamic_array<T>沒有默認構造函數，因此每個派生類構造函數都必須以某種方式調用某些基礎構造函數。 將基本初始化放在構造函數初始化列表中。 例如：

template <typename T>
class merge_inner : public dynamic_array<T>
{
public:
  merge_inner() : dynamic_array<T>(0) { }
  // ...
};