当实现operator[]时，我应该如何包含边界检查？

Question

首先，我为这么长时间提出这样一个简单的问题表示歉意。

我正在实现一个类，它充当空间填充曲线上非常长的一维索引或表示索引对应的笛卡尔坐标的 n 元组。

class curvePoint
{
public:
    friend class curveCalculate;

    //Construction and Destruction
    curvePoint(): point(NULL), dimensions(0) {}
    virtual ~curvePoint(){if(point!=NULL) delete[] point;}

    //Mutators
    void convertToIndex(){ if(isTuple()) calc(this); }
    void convertToTuple(){ if(isIndex()) calc(this); }
    void setTuple(quint16 *tuple, int size);
    void setIndex(quint16 *index, int size);
    void setAlgorithm(curveType alg){algorithm = alg;}

    //Inspectors
    bool isIndex(){return current==Index;}
    bool isTuple(){return current==Tuple;}
    size_t size(){return dimensions;}
    quint16 operator[](size_t index);

    enum curveType{HilbertCurve, ZCurve, GrayCodeCurve};
    enum status{Index, Tuple};

private:
    curveCalculate calc;
    curveType algorithm;
    quint16 *point;
    size_t dimensions;
    status current;
};

（点指向的数组的长度是维度）

无论如何，在operator[]的实现中，我想知道实现边界检查的最佳方法是什么。 我希望尽可能避免抛出异常，并且数组中的每个数字都可以使用完整的值范围，因此在出现越界错误时返回特殊值也是不可能的；

我正在考虑类似的事情，尽管在类定义中实现了：

quint16 curvePoint::operator[](size_t index)
{
    return point[ index % dimensions ];
}

这使得我们永远不会离开数组的边界，如果有充分的记录，我认为这会很好； 尽管如此，我对这个特定的实现还是很了解的。

这看起来别人可以接受吗？ 有没有其他方法可以在满足我的约束的同时进行边界检查？

编辑： 希尔伯特曲线等的计算非常混乱，混乱到我不希望 stl 库的附加接口受到干扰。

另外，因为每次查询多维数据库时我都必须转换数千个这样的数据，所以如果可能的话，我不希望混合使用 stl 函数调用的额外成本。

我更喜欢断言的想法； 但是，如果我没记错的话，发布版本中的中断不是吗？

我想我可以使用异常，这似乎是每个人都支持的，但我正在使用 Qt 库，它们避免了性能和可移植性的异常，我希望也能这样做。

Answer 1

拥有一个永远不会失败的operator[]听起来不错，但如果调用函数使用非法偏移量，从缓冲区的开头找到一个值，然后继续处理，就好像这是一个有效值一样，以后可能会隐藏错误。

Answer 2

实现边界检查的最佳方法是添加断言。

quint16 curvePoint::operator[](size_t index)
{
    assert(index < dimensions);
    return point[index];
}

如果您的代码已经依赖于 Boost 库，您可能需要使用 BOOST_ASSERT 来代替。

Answer 3

如果我是你，我会遵循 stl 设置的示例。

在这种情况下，std::vector 提供了两种方法：进行边界检查的 at 和不进行边界检查的operator[] 。 这允许客户决定要使用的版本。 我绝对不会使用 % size()，因为这只是隐藏了错误。 然而，当迭代大型集合时，边界检查会增加大量开销，这就是为什么它应该是可选的。 尽管我同意其他发帖者的观点，即断言是一个非常好的主意，因为这只会导致调试版本中的性能下降。

您还应该考虑返回引用并提供 const 和非 const 版本。 以下是 std::vector 的函数声明：

reference at(size_type _Pos);
const_reference at(size_type _Pos) const;

reference operator[](size_type _Pos);
const_reference operator[](size_type _Pos) const;

作为一个好的经验法则，如果我不确定如何指定 API，我会查找其他人如何指定类似 API 的示例。 此外，当我使用 API 时，我会尝试对其进行判断或评级，找出我喜欢和不喜欢的部分。

Answer 4

感谢 Daniel Daranas 帖子中对 C# 功能的评论，我已经设法找到了一个可能的解决方案。 正如我在问题中所说，我正在使用 Qt 库。 在那里我可以使用 QVariant。 QVariant 可以设置为无效状态，可以通过接收它的函数进行检查。 所以代码会变成这样：

QVariant curvePoint::operator[](size_t index){
    QVariant temp;
    if(index > dimensions){
        temp = QVariant(QVariant::Invalid);
    }
    else{
        temp = QVariant(point[index]);
    }

    return temp;
}

当然，这有可能在函数中插入一些粗糙的开销，所以另一种可能性是使用对模板。

std::pair<quint16, bool> curvePoint::operator[](size_t index){
    std::pair<quint16, bool> temp;
    if(index > dimensions){
        temp.second = false;
    }
    else{
        temp.second = true;
        temp.first = point[index];
    }
    return temp;
}

或者我可以使用 QPair，它具有完全相同的功能，并且不需要链接 STL。

Answer 5

另一种选择是让调用者选择越界策略。 考虑：

template <class OutOfBoundsPolicy>
quint16 curvePoint::operator[](size_t index)
{
    index = OutOfBoundsPolicy(index, dimensions);
    return point[index];
}

然后您可以定义调用者可以选择的多个策略。 例如：

struct NoBoundsCheck {
    size_t operator()(size_t index, size_t /* max */) {
        return index;
    }
};

struct WrapAroundIfOutOfBounds {
    size_t operator()(size_t index, size_t max) {
        return index % max;
    }
};

struct AssertIfOutOfBounds {
    size_t operator()(size_t index, size_t max) {
        assert(index < max);
        return index % max;
    }
};

struct ThrowIfOutOfBounds {
    size_t operator()(size_t index, size_t max) {
        if (index >= max) throw std::domain_error;
        return index;
    }
};

struct ClampIfOutOfBounds {
    size_t operator()(size_t index, size_t max) {
        if (index >= max) index = max - 1;
        return index;
    }
};

Answer 6

您也许可以向 [] 运算符（或至少一个断言）添加“越界”异常。

这应该可以捕获任何问题，尤其是在调试时。

Answer 7

除非我严重误解了某些东西，否则

return point[ index % dimensions ];

根本不是边界检查。 它从线路的完全不同部分返回真实值，这将使检测错误变得更加困难。

我会：

1. 抛出异常或断言（尽管您说过您不想这样做）
2. 以“自然”方式简单地取消引用指向数组（即跳过任何内部检查）。 相对于%的优点是它们更有可能（尽管未定义是未定义的）获得“奇怪”的值和/或访问冲突

最后，调用者违反了你的先决条件，你可以做任何你想做的事。 但我认为这些都是最合理的选择。

如果合理的话，还请考虑 Cătălin 所说的关于合并内置 STL 集合的内容。

Answer 8

如果您提供对椭圆形点的访问，您的解决方案会很好。 但如果您将其用于任意几何函数，则会导致非常严重的错误，因为您故意提供了错误值。

Answer 9

模运算符对于数组索引的效果出人意料地好——它还实现了负索引（即point[-3] = point[dimensions - 3]）。 这很容易使用，因此我个人推荐使用模运算符，只要它有详细的文档记录即可。

Answer 10

最简单的解决方案是像 C++ 本身那样做。 这限制了用户体验到的惊喜的数量。

C++本身是相当一致的。 如果您使用越界数组索引，则指针上的内置 [] 和 std::vector::operator[] 都具有未定义的行为。 如果您想要进行边界检查，请明确并使用 std::vector::at

因此，如果您对类执行相同的操作，则可以将越界行为记录为“标准”。

Answer 11

无论如何在实施中
运算符[] 我想知道什么
实现边界检查的最佳方法
是。 我想避免抛出
如果可能的话，例外，并且
全范围的值可用于
数组中的每个数字都是特殊的
超出时返回的值
边界错误也是不可能的；

那么剩下的选项是：

• 灵活的设计。你做了什么。 “修复”无效的输入，以便它尝试做一些有意义的事情。 优点：功能不会崩溃。 缺点：访问越界元素的无知调用者将得到一个谎言<​​/strong>结果。 想象一栋 10 层楼的建筑，其中 1 层到 10 层：

你：“谁住在三楼？”

我：“玛丽”。

你：“谁住在九楼？”

我：“乔”。

你：“谁住在 1,203 楼？”

我：（等等...1,203 % 10 = 3...）
> “玛丽”。

你：“哇，玛丽一定能欣赏到 那么她拥有两套公寓吗？”

• bool 输出参数表示成功或失败。 此选项通常会生成不太可用的代码。 许多用户会忽略返回码。 您仍然保留在另一个返回值中返回的内容。

• 按合同设计。断言调用者在范围内。 （有关 C++ 中的实用方法，请参阅 Miro Samek 的异常还是错误？ 或 Pedro Guerreiro 的 C++ 合约设计简单支持。）

• 返回一个System.Nullable。 哎呀，等等，这不是 C#。 好吧，您可以返回一个指向 quint16 的指针。 这当然有很多含义，我不会在这里讨论，并且可能使该选项不可用。

我最喜欢的选择是：

• 对于公开发布的库的公共接口：将检查输入并抛出异常。 您排除了此选项，因此它不适合您。 对于公开发布的库的界面，它仍然是我的选择。
• 对于内部代码：按合同设计。

Answer 12

对我来说，这个解决方案是不可接受的，因为你可能隐藏了一个很难发现的错误。
抛出超出范围的异常是正确的方法，或者至少在函数中放置一个断言。

Answer 13

如果您需要的是某种“圆形”点数组，那么您的解决方案就可以。 然而，对我来说，它看起来就像将索引运算符的误用隐藏在一些“安全”逻辑后面，所以我反对您提出的解决方案。

如果不想允许索引溢出，那么您可以检查并抛出异常。

quint16 curvePoint::operator[](size_t index)
{
    if( index >= dimensions)
    {
       throw std::overflow_error();
    }
    return point[ index ];
}

如果您想减少开销，可以通过使用调试时断言来避免异常（假设提供的索引始终有效）：

quint16 curvePoint::operator[](size_t index)
{
    assert( index < dimensions);
    return point[ index ];
}

但是，我建议不要使用点和维度成员，而是使用 std::vector< quint16> 用于点存储。 它已经具有您可以使用的基于索引的访问：

quint16 curvePoint::operator[](size_t index)
{
    // points is declared as std::vector< quint16> points;
    return points[ index ];
}