Quote:Original post by Antheus
The fact that compiler is giving you trouble, and that you need to use reinterpret_cast to avoid it is a good hint that it's not a good idea.

Const is optional. It doesn't really do much for the code itself, but it's a strong reminder to users of the code that something either may or may not be modified.

Yes, you can get around the limitation like this, but it's very easy to miss something that will cause problems down the line.

I encountered const-correctness problems in component model. While I designed lower levels rigidly with const members in mind, a subtle flaw emerged 2 layers away. It took me quite a while before I could come up with scenario that would cause problems if I violated constness, and it turned out it wouldn't be that hard to encounter that in real code.

So the fact you encountered problems with this conversion is a good thing. It's pointing out that you should do something. Even if "some stuff" may seem irrelevant here and now, you are deliberately ignoring something important your compiler is telling you.

Quote:Original post by Extrarius

Quote:Original post by rozz666
[...]I understand, but my point is that sometimes you need to manipulate the arrays not just iterators. You need to transfer ownership, etc. Do you suggest that there's no need for any array<const T>?[...]

I don't understand why you ever need 'array<const T>'

Any situation I can think of where that would make sense, 'const array<T>' makes just as much if not more sense. The approach works perfectly for vector, and it really really makes sense to keep the object type the same if you're going to be tracking references. Changing the object's type will make the code very very confusing, and changing template parameters is doing exactly that - changing the object's type.

Quote:Original post by Extrarius
In that case, why not use boost::shared_array or boost::shared_ptr<vector> (the latter being closer to your custom class)?

Quote:Original post by Extrarius
How not? a const shared_array<T> will only give you a const pointer, so you won't be able to modify the data without using a const cast, and you can easily convert from a non-const shared_array<T> to a const shared_array<T> (and it will be done implicitly).

const shared_array<int> a1;shared_array<int> a2;a2 = a1;

Quote:

If you insist on doing it yourself, make ref_cnt mutable (it's not part of the visible state, after all) and then just use a const array<T> where the data shouldn't be changed. Resize on an array of constants doesn't make sense (except to shrink it, perhaps, but that would be an odd situation) so a const array should work everywhere you don't want the contents to be changed.

void swap(array<const T>& , array<const T>& );array<int> a1;array<const int> a2;swap(a1, a2); // works!

void swap(const int *& a1, const int *& a2);int x = 2, *p1 = &xconst int y = 3, *p2 = &yswap(p1, p2); // also works