A nonconst vector whose elements cannot change - alternatives - c++

Question

I have this obsession with making things const that really should be const, even when it seems a bit painful to do so.
In this case, I want a vector<int> into which I can add elements, but whose existing elements I cannot change. The problem is that vector<const int> is not allowed.
The purpose is not only to prevent the users of my classes to modify things they shouldn't modify (this can be easily done by const iterators in member functions). It is also, just as importantly, so I myself don't later do things in my own code that I didn't intend on doing.
I have found two alternatives:
Use deque<const int> instead.
Create my own vector class that wraps the actual vector, like this (I do this for int here, but in reality I would use templates for generality)
class my_vector {
private:
std::vector<int> vec;
public:
std::vector<int>::const_iterator cbegin() { return vec.cbegin(); }
std::vector<int>::const_iterator cend() { return vec.cend(); }
void push_back(int i) { vec.push_back(i); }
};
Which of these ideas (or others) would you recommend? Will the compiler turn the second alternative into code that is just as fast as using the vector directly?

Answer 1

Your obsession is understandable and I do not disagree, but unless you have a really pressing need for it, the effort required might not be worth the effort.
Assuming you chose vector as your container based on your design requirement, I would not recommend changing it to deque, or any other type. It would only serve to confuse a future reader (which would likely be yourself), and is also a bad practice otherwise.
If we go with your wrapper solution, you would have to hide override all members which could modify the vector, which is a problem since there are a number of methods used to both access and modify, such as operator[], at(), front(), back(). This could confuse a future reader, since they are used to the "standard" vector behavior.
By the way, are you sure deque<const int> foo; works? I get the following error:
error: invalid conversion from 'const void*' to 'void*'
Edit It seems I didn't quite answer your question. If you have to pick one, I would choose the wrapper approach.

Answer 2

I prefer private inheritance for these sort of standard-container-almost-exactly-fits-my-needs cases. Public inheritance leads to slicing or non-virtual destruction through a pointer to a base class. Composition requires too much extra typing.
Private inheritance and the use of using expresses your intent well.
Here is an exmaple:
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
class my_vector : private std::vector<int> {
// Utility type
typedef std::vector<int> base;
public:
// Types I don't need to tweak:
using base::value_type;
using base::allocator_type;
using base::size_type;
using base::difference_type;
using base::const_reference;
using base::const_pointer;
using base::const_iterator;
using base::const_reverse_iterator;
// Types I do need to tweak:
typedef const_reference reference;
typedef const_pointer pointer;
typedef const_iterator iterator;
typedef const_reverse_iterator reverse_iterator;
// Constructors
// Implicit constructors OK
// Destructors
// Implicit destructors OK
// Assignment
// Implicit assignment OK
// Methods that I don't need to tweak:
using base::assign;
using base::get_allocator;
using base::empty;
using base::size;
using base::max_size;
using base::reserve;
using base::capacity;
using base::clear;
using base::push_back;
using base::pop_back;
using base::swap;
// Methods I need to tweak
const_reference at( size_type pos ) const { return base::at(pos); }
const_reference operator[](size_type pos) const { return base::operator[](pos); }
const_reference front() const { return base::front(); }
const_reference back() const { return base::back(); }
const_iterator begin() const { return base::begin(); }
const_iterator end() const { return base::end(); }
const_reverse_iterator rbegin() const { return base::rbegin(); }
const_reverse_iterator rend() const { return base::rend(); }
// Methods I need to delete:
// base::insert;
// base::erase;
// base::resize;
};
int main () {
my_vector m;
m.push_back(1);
m.push_back(2);
m.push_back(3);
my_vector m2;
m2 = m;
std::copy(m2.begin(), m2.end(), std::ostream_iterator<int>(std::cout, "\n"));
}

Answer 3

There's nothing magic about the standard containers. If you need a container with characteristics that are different from those of the standard containers, write your own. If one of the standard containers is close to what you need, use that as the internal implementation. In short, my_vector is the way to go.