Не могу перегрузить [] в производном классе

#include <iostream>
 
#include "IntArray.h"
#include "IntArrayRC.h"
 
void swap(IntArray& ia, int ix, int jx) {
    int tmp = ia[ix];
    ia[ix] = ia[jx];
    ia[jx] = tmp;
}
 
int main() {
    int array[4] =  {1, 2, 3, 4};
    IntArray ia1(4, array);
    IntArrayRC ia2(array, 4);
    swap(ia1, 1, 3);
    
    swap(ia2, 1, 3);
    return 0;
}

#ifndef INTARRAY_H
#define INTARRAY_H
 
class IntArray {
public:
    explicit IntArray(int array_size = defaultArraySize);
    IntArray(int array_size, int *array);
    IntArray(const IntArray&);
    virtual ~IntArray() { delete[] ia; }
    
    virtual int& operator[](int index) const;
    
    int size() const { return _size; }
    //virtual int find(int index) const;
    //virtual int min() const;
    //virtual int max() const;
    //virtual void sort();
    
    virtual void view();
protected:
    static const int defaultArraySize = 10;
    int *ia;
    int _size;
    void init(int array_size, int *array);
};
 
#endif

#include <iostream>
#include <cassert>
 
#include "IntArray.h"
 
void IntArray::view() {
    for(int ix = 0; ix < _size; ++ix)
        std::cout << ia[ix] << ' ';
}
 
int& IntArray::operator[](int index) const {
    assert(index >= 0 &&  index < _size);
    return ia[index];
}
 
void IntArray::init(int array_size, int *array) {
    _size = array_size;
    ia = new int[_size];
    
    for(int ix = 0; ix < _size; ++ix) {
        if(!array)
            ia[ix] = 0;
        else
            ia[ix] = array[ix];
    }
}
 
IntArray::IntArray(int array_size) {
    init(array_size, 0);
}
 
IntArray::IntArray(int array_size, int *array) {
    init(array_size, array);
}
 
IntArray::IntArray(const IntArray& rhs) {
    init(rhs._size, rhs.ia);
}

#ifndef INTARRAYRC_H
#define INTARRAYRC_H
 
#include <cassert>
 
#include "IntArray.h"
 
class IntArrayRC: public IntArray {
public:
    IntArrayRC(int sz = defaultArraySize);
    IntArrayRC(int *array, int array_size);
    IntArrayRC(const IntArrayRC& rhs);
    
    virtual int& operator[](int index) const;
private:
    void check_range(int ix) const;
};
 
inline IntArrayRC::IntArrayRC(int sz)
    : IntArray(sz) { }
    
int& IntArrayRC::operator[](int index) const {
    check_range(index);
    return ia[index];
}
 
inline IntArrayRC::IntArrayRC(int *array, int array_size)
    : IntArray(array_size, array) { }
 
inline void IntArrayRC::check_range(int ix) const {
    assert(ix >= 0 && ix < _size);
}
 
#endif