Question

使用数组时，您可以执行类似

的操作

class SomeClass
{
public:
    int* LockMember( size_t& numInts );

private:
    int*   member;
    size_t numInts;
};

int* SomeClass::LockMember( size_t& out_numInts )
{
    out_numInts = numInts - 1;
    return member + 1;
}

要返回一个数量的数组偏移量，以防止有人修改某些连续内存的某些部分，或者至少显示出一些意图，即该对象的这部分连续内存应保持不变。

由于我到处都使用矢量，我想知道是否有某种方法可以完成同样的事情：

class SomeClass
{
public:
    std::vector<int> LockMember( void );

private:
    std::vector<int> member;
};

std::vector<int> SomeClass::LockMember( void )
{
   // somehow make a vector with its beginning iterator pointing to member.begin() + 1
   // have a size smaller by one, still the same end iterator. The vector must be 
   // pointing to the same data as in this class as it needs to be modifiable.

   return magicOffsetVector;
}

将评论部分替换为真实代码。有什么想法吗？

Answer 1

如果我理解正确的话：你想要一些有两个部分的记忆：一开始你想要一些无法触及的东西，之后你想要一些可供客户代码使用的东西。

您可以按照以下代码执行操作。这将为客户端代码提供一个副本。这确实意味着你不得不做很多复制。

class SomeClass
{
public:
    std::vector<int> getMember( void ) const;
    void setMember(std::vector<int> newContent);

private:
    std::vector<int> member;
    size_t magicOffset;
};

// Read restricted part
std::vector<int> SomeClass::getMember( void ) const
{
    return vector<int>(member.begin() + magicOffset, member.end());
}

// Assign to restricted part
void SomeClass::setMember(const std::vector<int>& v)
{
    std::copy(v.begin(), v.end(), member.begin() + magicOffset);
}

为了避免复制，您可以为两个向量分配内存，一个用于受保护部分，一个用于未受保护的部分，并使用placement new将两个向量放入该内存，从而确保它们在连续的记忆中。然后给客户端代码或多或少免费访问向量的公共部分。然而，在vector中仍然存在记账变量，基本上这将是一个可怕的黑客，只是等待爆炸。

但是，如果您只需要基于每个元素访问不受限制的部分，您可以对参数进行范围检查，即：

int getElement(size_t idx)
{
    idx += magicOffset;
    if (idx > member.size() || idx < 0) throw std::out_of_range("Illegal index");

    return member[idx];
}

然后提供setElement或返回int&。

偏移并传递矢量参考

1 个答案: