protected member is not accessible by base class as expected
<p>My derived class merge_sort from dynamic_array does not have access to protected member T* array.  Their are error everywhere it is used saying such.</p>

<p>I'm not sure why...except maybe the public designator for merge_sort should be something else?</p>

<pre><code>#include "c_include.cpp"
using namespace std;
template &lt;class T&gt; class dynamic_array
  {
  protected:
    T* array;
  public:
    int size;
    void rorder();
    void order();
    void randorder();
    void print_operator(ostream&amp;)const;
    dynamic_array(int sizein)
      {
      size=sizein;
      array=new T[size]();
      }
  };
template &lt;class T&gt; void dynamic_array&lt;T&gt;::print_operator(ostream &amp;os=cout)const
  {
  for (int i = 0; i &lt; size; i++) os &lt;&lt; array[i] &lt;&lt; endl;
  }
template &lt;class T&gt; void dynamic_array&lt;T&gt;::randorder()
  {
  srand(time(NULL));
  int *ap;
  for(ap=array;ap!=array+size;++ap){*ap=rand();} 
  }
template &lt;class T&gt; void dynamic_array&lt;T&gt;::order()
  {
  int *ap,i=0;
  for(ap=array;ap!=array+size;++ap)                                             
    { 
    *ap=i;
    ++i;        
    } 
  }
template &lt;class T&gt; void dynamic_array&lt;T&gt;::rorder()
  {
  int *ap,i=size;
  for(ap=array;ap!=array+size;++ap)                                             
    { 
    *ap=i;
    --i;        
    } 
  }
template&lt;class T&gt; ostream&amp; operator&lt;&lt;(ostream&amp; stream, dynamic_array&lt;T&gt; const&amp; data) 
  { 
  data.print_operator(stream);
  return stream; 
  }   
/*
Merge Sort
*/
template &lt;class T&gt; class merge_sort : public dynamic_array &lt;T&gt;
  {
  private:
    const static int size;
    int scratch[];
    void flip_if_unordered(int &amp;x, int &amp;y)
      {
      if(array[x]&gt;array[y])
        {
        int tmp=array[x];
        array[x]=array[y];
        array[y]=tmp;
        }
      }
    void merge_algo(int &amp;left, int &amp;right_begin, int &amp;right)
      {
      int iter,iter_left=left,iter_right=right_begin;  
      for(iter=left;iter&lt;=right;++iter)
        {
        if( (iter_right&gt;right) || ((iter_left &lt; right_begin) &amp;&amp; (array[iter_left]&lt;=array[iter_right])))
          {
          scratch[iter]=array[iter_left];
          ++iter_left;
          }
        else
          {
          scratch[iter]=array[iter_right];
          ++iter_right;
          }
        }
      for(iter=left;iter&lt;=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 &lt;= r)
        {
        while (array[l] &lt; pivot)l++;
        while (array[r] &gt; pivot)r--;
        if (l &lt;= r) 
          {
          tmp = array[l];
          array[l] = array[r];
          array[r] = tmp;
          l++;
          r--;
          }
        }
      if (left &lt; r)quick_recurse(left, r);
      if (l &lt; right)quick_recurse(l, right);
      }  
*/
</code></pre>
