Offset and pass vector reference

When using arrays you can do something like

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;
}

To return an array offset by some amount so as to prevent someone from modifying some part of contingeous memory, or, atleast, show some intent that this part of contingeous memory of the object should remain untouched.

Since I use vectors everywhere, I am wondering if there was some way to accomplish the same sort of thing:

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 sam开发者_高级运维e data as in this class as it needs to be modifiable.

   return magicOffsetVector;
}

With the commented part replaced by real code. Any ideas?

---

If I understand you correctly: You want some memory with two parts: At the beginning you want something that can't be touched, and after that you want something that is open for use by client code.

You could do something along the following code. This will give the client code a copy to play with. This does mean you would have to do a lot of copying, though.

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);
}

In order to avoid the copying, it is possible that you could allocate memory for two vectors, one for the protected part and one for the unprotected part, and use placement new to put both vectors into that memory, thus ensuring that they are in contiguous memory. And then give the client code more or less free access to the public part of the vector. However, there's still the thing with bookkeeping variables in vector, and basically this would be an awful hack that's just waiting to blow up.

However, if you only need access to the unrestricted part on a per-element basis, you could just do range-checking on the arguments, i.e.:

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

    return member[idx];
}

And then either provide a setElement, or return int&.