operator 연산자도 상속이 가능한가요?

부모클래스에 a()( 당연히 public 혹은 protected )라는 멤버 함수 있고 자식 클래스에서 a()라는 멤버 함수를 호출 하면 상속이
가능한것 처럼 operator 연산자 함수( 당연히 public 혹은protected )를 자식 클래스에서 호출하면 상속이 아닌가요?

일단 답변에 감사드립니다.
그래서 제 나름대로 예제를 하나 만들어 보았습니다.

      1 #include <cstdio>
      2 #include <new>
      3
      4 //========================================================================================================================
      5 template < class DataType >
      6 class xCParentsOperation
      7 {
      8 public :
      9     inline xCParentsOperation( int p_size );
     10           ~xCParentsOperation( );
     11
     12     inline void      NamolaPrintInfo( void );
     13     inline DataType& operator[] ( int p_index );
     14
     15 private :
     16     DataType* m_Alloc;
     17     int       m_Size;
     18 };
     19 //========================================================================================================================
     20
     21 //------------------------------------------------------------------------------------------------------------------------
     22 template < class DataType >
     23 inline
     24 xCParentsOperation< DataType >::xCParentsOperation( int p_size )
     25     :m_Alloc( 0 )
     26 //------------------------------------------------------------------------------------------------------------------------
     27 {
     28     m_Alloc = new DataType[ p_size ];
     29     if ( !m_Alloc ) return NULL;
     30
     31     m_Size  = p_size;
     32 }
     33
     34 //------------------------------------------------------------------------------------------------------------------------
     35 template < class DataType >
     36 xCParentsOperation< DataType >::~xCParentsOperation()
     37 //------------------------------------------------------------------------------------------------------------------------
     38 {
     39     if ( m_Alloc ) delete[] m_Alloc;
     40     m_Alloc = 0;
     41 }
     42
     43 //------------------------------------------------------------------------------------------------------------------------
     44 template < class DataType >
     45 inline
     46 DataType& xCParentsOperation< DataType >::operator[] ( int p_index )
     47 //------------------------------------------------------------------------------------------------------------------------
     48 {
     49     return m_Alloc[ p_index ];
     50 }
     51
     52 //------------------------------------------------------------------------------------------------------------------------
     53 template < class DataType >
     54 inline
     55 void xCParentsOperation< DataType >::NamolaPrintInfo( void )
     56 //------------------------------------------------------------------------------------------------------------------------
     57 {
     58     printf( "부모 멤버 함수 호출\n" );
     59 }
     60
     61 //========================================================================================================================
     62 template < class DataType >
     63 class xCChildOperation : public xCParentsOperation< DataType >
     64 {
     65 public :
     66     xCChildOperation( int Size = 1 );
     67     ~xCChildOperation();
     68
     69 private :
     70     DataType* m_ChildAlloc;
     71     int       m_ChildSize;
     72 };
     73 //========================================================================================================================
     74
     75 //------------------------------------------------------------------------------------------------------------------------
     76 template < class DataType >
     77 xCChildOperation< DataType >::xCChildOperation( int Size )
     78     :xCParentsOperation( Size ), m_ChildAlloc( 0 )
     79 //------------------------------------------------------------------------------------------------------------------------
     80 {
     81     m_ChildAlloc = new DataType[ Size ];
     82     if ( !m_ChildAlloc ) return NULL;
     83
     84     m_ChildSize = Size;
     85 }
     86
     87 //------------------------------------------------------------------------------------------------------------------------
     88 template < class DataType >
     89 xCChildOperation< DataType >::~xCChildOperation()
     90 //------------------------------------------------------------------------------------------------------------------------
     91 {
     92     if ( m_ChildAlloc ) delete[] m_ChildAlloc;
     93     m_ChildAlloc = 0;
     94 }
     95
     96 int main ( void )
     97 {
     98     xCChildOperation< int > a1( 10 );
     99     a1.NamolaPrintInfo();
    100
    101     /*
    102     a1[ 0 ] = 1;
    103
    104     int i = a1[ 0 ];
    105
    106     printf( "a1[ 0 ] => %d\n", i );
    107     */
    108
    109     return 0;
    110 }

다음과 같은 오류가 납니다. 연산자 부분은 주석 처리를 했는데...

xCOperator.cpp: In constructor
   `xCChildOperation<DataType>::xCChildOperation(int)':
xCOperator.cpp:78: class `xCChildOperation<DataType>' does not have any field
   named `xCParentsOperation'
xCOperator.cpp: In constructor
   `xCChildOperation<DataType>::xCChildOperation(int) [with DataType = int]':
xCOperator.cpp:98:   instantiated from here
xCOperator.cpp:80: no matching function for call to `xCParentsOperation<int>::
   xCParentsOperation()'
xCOperator.cpp:7: candidates are:
   xCParentsOperation<int>::xCParentsOperation(const xCParentsOperation<int>&)
xCOperator.cpp:25:
   xCParentsOperation<DataType>::xCParentsOperation(int) [with DataType = int]
xCOperator.cpp:98:   instantiated from here
xCOperator.cpp:82: returning a value from a constructor

그렇군요...다시 수정했습니다.

      1 #include <cstdio>
      2 #include <iostream>
      3
      4 using std::cout;
      5 using std::endl;
      6
      7 #include <new>
      8
      9 using std::bad_alloc;
     10
     11 //========================================================================================================================
     12 template < class DataType >
     13 class xCParentsOperation
     14 {
     15 public :
     16     inline xCParentsOperation( int p_size );
     17           ~xCParentsOperation( );
     18
     19     inline void      NamolaPrintInfo( void );
     20     inline DataType& operator[] ( int p_index );
     21
     22 private :
     23     DataType* m_Alloc;
     24     int       m_Size;
     25 };
     26 //========================================================================================================================
     27
     28 //------------------------------------------------------------------------------------------------------------------------
     29 template < class DataType >
     30 inline
     31 xCParentsOperation< DataType >::xCParentsOperation( int p_size )
     32     :m_Alloc( 0 )
     33 //------------------------------------------------------------------------------------------------------------------------
     34 {
     35     try
     36     {
     37         m_Alloc = new DataType[ p_size ];
     38     }
     39     catch( bad_alloc &memoryAllocationException )
     40     {
     41         cout << "메모리 할당 실패 : "
     42              << memoryAllocationException.what() << endl;
     43     }
     44
     45     m_Size  = p_size;
     46 }
     47
     48 //------------------------------------------------------------------------------------------------------------------------
     49 template < class DataType >
     50 xCParentsOperation< DataType >::~xCParentsOperation()
     51 //------------------------------------------------------------------------------------------------------------------------
     52 {
     53     if ( m_Alloc ) delete[] m_Alloc;
     54     m_Alloc = 0;
     55 }
     56
     57 //------------------------------------------------------------------------------------------------------------------------
     58 template < class DataType >
     59 inline
     60 DataType& xCParentsOperation< DataType >::operator[] ( int p_index )
     61 //------------------------------------------------------------------------------------------------------------------------
     62 {
     63     return m_Alloc[ p_index ];
     64 }
     65
     66 //------------------------------------------------------------------------------------------------------------------------
     67 template < class DataType >
     68 inline
     69 void xCParentsOperation< DataType >::NamolaPrintInfo( void )
     70 //------------------------------------------------------------------------------------------------------------------------
     71 {
     72     printf( "부모 멤버 함수 호출\n" );
     73 }
     74
     75 //========================================================================================================================
     76 template < class DataType >
     77 class xCChildOperation : public xCParentsOperation< DataType >
     78 {
     79 public :
     80     inline xCChildOperation( int Size = 1 );
     81     ~xCChildOperation();
     82
     83 private :
     84     DataType* m_ChildAlloc;
     85     int       m_ChildSize;
     86 };
     87 //========================================================================================================================
     88
     89 //------------------------------------------------------------------------------------------------------------------------
     90 template < class DataType >
     91 inline
     92 xCChildOperation< DataType >::xCChildOperation( int Size )
     93     :xCParentsOperation< DataType >( Size ), m_ChildAlloc( 0 )
     94 //------------------------------------------------------------------------------------------------------------------------
     95 {
     96     try
     97     {
     98         m_ChildAlloc = new DataType[ Size ];
     99     }
    100     catch( bad_alloc &memoryAllocationException )
    101     {
    102         cout << "메모리 할당 실패 : "
    103              << memoryAllocationException.what() << endl;
    104     }
    105
    106
    107     m_ChildSize = Size;
    108 }
    109
    110 //------------------------------------------------------------------------------------------------------------------------
    111 template < class DataType >
    112 xCChildOperation< DataType >::~xCChildOperation()
    113 //------------------------------------------------------------------------------------------------------------------------
    114 {
    115     if ( m_ChildAlloc ) delete[] m_ChildAlloc;
    116     m_ChildAlloc = 0;
    117 }
    118
    119 int main ( void )
    120 {
    121     xCChildOperation< int > a1( 10 );
    122     a1.NamolaPrintInfo();
    123
    124
    125     a1[ 0 ] = 1;
    126
    127     int i = a1[ 0 ];
    128
    129     printf( "a1[ 0 ] => %d\n", i );
    130
    131
    132     return 0;
    133 }

처음에는 operator= 이것으로 질문 하였는데....
operator 연산자는 아무거나 만들어도 상관 없다는 생각에
operator[] 연산자를 만들었습니다.

D::operator=()가 호출됩니다. 이 함수는 
컴파일러가 대신 만들어 주기 때문에 눈에 보이지 않을 뿐 B::operator=()와는 
다른 함수입니다. 이것이 상속받은 멤버와의 차이입니다

그러면 operator 연산자는 상속 가능한 연산자가 있고 상속이 가능하지 못한 연산자가 있는건가요?