protected 멤버는 기본 클래스에서 예상대로 액세스 할 수 없습니다.

Question

내 파생 클래스 인 dynamic_array의 merge_sort는 보호 된 멤버 T * 배열에 액세스 할 수 없습니다. 그것들은 어디에서나 그런 말로 사용되는 오류입니다.

나는 왜 merge_sort에 대한 public 지정자가 다른 것일까?

#include "c_include.cpp" 
using namespace std; 
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](); 
     } 
    }; 
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();} 
    } 
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; 
    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_sort : public dynamic_array <T> 
    { 
    private: 
    const static int size; 
    int 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_sort() 
     { 
     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<T>::array 

또는

this->array 

또는

using dynamic_array<T>::array;