Question

我创建了自己的容器，它继承自vector。我想以一种检查由#define决定的边界的方式重新实现operator[]。

所以举一个例子，忽略模板参数，因为它们很复杂且无关紧要

class MyArray : vector<double>
{
    //...
    virtual double& operator[](const size_type& index);
    virtual const double& operator[](const size_type& index) const;
    //...
}


double& MyArray::operator[](const size_type& index)
{
    #ifdef DEBUG_ENABLED
        return this->at(index);
    #else
        return (*this)[index];
    #endif
}

但是，这不起作用，因为operator[]过载，在operator[]调用#else会变为递归。

我想根据我的#define检查边界，而不是基于我是使用std::vector<>::at()还是std::vector<>::operator[]。

我该如何解决这个问题？

编辑：由于它提供了很多使用std :: vector作为成员而不是继承，我不得不提到这样做对我来说不是一个很好的解决方案因为我会有重新实现std :: vector的所有成员函数。这样做不太愉快！

Answer 1

只需根据需要调用基类成员函数：

double& operator[](size_type index)
{
    #ifdef DEBUG_ENABLED
        return std::vector<double>::at(index);
    #else
        return std::vector<double>::operator[](index);
    #endif
}

您也应提供const版本。另请注意，您可能不想创建此运算符virtual。

Answer 2

首先，从标准容器派生并不是一个好主意，因为它们缺少适当支持用作基类的功能（例如虚拟析构函数）。标准容器的意图是它们不会用作基础。

如果您必须这样做，请添加此内容;

class MyArray : vector<double>
{
    //   all your other stuff

    typedef vector<double> Base;

};

double& MyArray::operator[](const size_type& index)
{
    #ifdef DEBUG_ENABLED
        return this->at(index);
    #else
        return (*((Base *)this))[index];
    #endif
}

使用static_cast通常可以更好地完成函数中的类型转换，但您明白了。

最好使容器成为您的类的成员，并将操作符函数的各个成员转发给包含的成员。

class MyArray
{
    //   all your other stuff

   private:
       std::vector<double> data;


};

double& MyArray::operator[](const size_type& index)
{
    #ifdef DEBUG_ENABLED
        return data.at(index);
    #else
        return data[index];
    #endif
}

最后，无论哪种方式，operator[]()都不必是虚拟的。

Answer 3

＆＃34;由于它提供了很多使用std :: vector作为成员而不是继承，我不得不提到这样做对我来说不是一个很好的解决方案因为我＆＃39;我必须重新实现std :: vector的所有成员函数。这样做不太愉快！

你不必。我在这里使用了继承来消除压力。

#include <iostream>
#include <vector>

using namespace std;

template <typename T>
class Vector_ : private vector<T>
{
public:
    virtual ~Vector_(){}
    virtual const T& operator[](const size_t index);
    virtual const T& at(const size_t index);
};

/*
<<I would like to make the check for bounds based on my #define, and  not based on
std::vector<>::at() or std::vector<>::operator[]. >>
*/
template <typename T>
const T& Vector_<T>::operator[](const size_t index)
{
#ifdef DEBUG_ENABLED
    return (*((vector<T>*)this))->at(index)
#else
    return (*((vector<T> *)this))[index];
#endif
}   
template <typename T>
const T& Vector_<T>::at(const size_t index)
{
#ifdef DEBUG_ENABLED
    return (*((vector<T>*)this))->at(index)
#else
    return (*((vector<T>*)this))[index];
#endif
}

//test...
Vector<int>_ vec;
vec.push_back(3);

vec[2]; or vec.at(2); //no exception

#define DEBUG_ENABLED
vec[2]; or vec.at(2);  //exception

vector / array bounds仅在声明define时检查

3 个答案: