Специализации шаблона класса с общей функциональностью

Я не знаю, можно ли обойти проблемы типизации с оператором присваивания, но вы можете немного облегчить себе жизнь, определив шаблонные версии различных операторов, вспомогательные функции для их реализации, а затем использовать наследование.

template <typename T, std::size_t N>
class fixed_array {
public:
    virtual ~fixed_array() {}
    template <std::size_t K>
    fixed_array& operator+=(fixed_array<T,K> const& other) {
        for (std::size_t i=0; i<N; ++i)
            this->contents[i] += other[i];
        return *this;
    }
    template <std::size_t K>
    fixed_array& operator=(fixed_array<T,K> const& other) {
        assign_from(other);
        return *this;
    }
    T& operator[](std::size_t idx) {
        if (idx >= N)
            throw std::runtime_error("invalid index in fixed_array[]");
        return contents[idx];
    }
protected:
    template <std::size_t K>
    void assign_from(fixed_array<T,K> const& other) {
        for (std::size_t i=0; i<N; ++i)
            this->contents[i] = other[i];
    }
private:
    T contents[N];
};

template <typename T>
class fixed_2d_array: public fixed_array<T,2> {
public:
    T x_coord() const { return (*this)[0]; }
    T y_coord() const { return (*this)[1]; }
    template <std::size_t K>
    fixed_2d_array& operator=(fixed_array<T,K> const& other) {
        assign_from(other);
        return *this;
    }
};

int
main() {
    fixed_array<int,5> ary1;
    fixed_2d_array<int> ary2;
    ary2 = ary1;
    ary1 = ary2;
    ary2 += ary1;
    ary1 += ary2;
    return 0;
}

Вот кое-что, что я придумал, когда некоторое время назад играл с функциями C ++ 0x. Единственная функция C ++ 0x, используемая в этом, - это static_assert , поэтому вы можете использовать Boost для ее замены.

По сути, мы можем использовать функцию проверки статического размера, которая просто проверяет, что данный индекс меньше размера вектора. Мы используем статическое утверждение для генерации ошибки компилятора, если индекс выходит за границы:

template <std::size_t Index> 
void size_check_lt() const 
{ 
    static_assert(Index < N, "the index is not within the range of the vector"); 
}

Затем мы можем предоставить метод get () , который возвращает ссылку на элемент по заданному индексу (очевидно, Также была бы полезна перегрузка const):

template <std::size_t Index> 
T& get()
{ 
    size_check_lt<Index>(); return data_[Index]; 
}

Тогда мы можем написать такие простые методы доступа:

T& x() { return get<0>(); }
T& y() { return get<1>(); }
T& z() { return get<2>(); }

Если вектор имеет только два элемента, вы можете использовать x и y, но не z. Если вектор состоит из трех или более элементов, вы можете использовать все три.

В итоге я проделал то же самое с конструкторами - я создал конструкторы для векторов размерности два, три и четыре и добавил size_check_eq , который позволял создавать их экземпляры только для векторов размерности два, три и четыре соответственно. Я могу попробовать опубликовать полный код, когда вернусь домой сегодня вечером, если кому-то интересно.

Я отказался от проекта на полпути, поэтому может возникнуть огромная проблема, с которой я не столкнулся ... по крайней мере, это вариант, который стоит рассмотреть.

Самый простой способ? Использование внешних функций:

template <class T>
T& x(Vector<T,2>& vector) { return vector.at<0>(); }

template <class T>
T const& x(Vector<T,2> const& vector) { return vector.at<0>(); }

В программировании шаблонов использование внешних функций - самый простой способ добавить функциональность просто из-за проблемы со специализацией, с которой вы только что столкнулись.

С другой стороны, вы все равно можете предоставить x , y и z для любого N или, возможно, использовать enable_if / disable_if функции для ограничения области действия.