仅在声明定义时检查向量/数组边界

Question

我创建了自己的容器，该容器继承自向量。我想重新实现operator[] 以检查由#define 决定的边界。

举个例子，忽略模板参数，因为它们复杂且不相关

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[] 已重载，因此在 #else 处调用 operator[] 将变得递归。

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

我该如何解决这个问题？

编辑：因为它提供了很多使用 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

“由于它提供了很多使用 std::vector 作为成员而不是继承的功能，我不得不提到这样做对我来说不是一个好的解决方案，因为我必须重新实现 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