On 4 Oct, 19:38, "Jim Langston" <tazmas...@rocketmail.com> wrote:
"terminator" <farid.mehr...@gmail.com> wrote in message
news:1191519613.729325.303320@g4g2000hsf.googlegroups.com...
On Oct 4, 6:48 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
esuv...@googlemail.com wrote:
On 4 Oct, 15:13, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:
esuv...@googlemail.com wrote:
I wish to modify some values of items contained in a set after they
have been added. [..] How acceptable is this?
And are there other reasons the items should be treated as const,
besides the ordering?
No, there are no other reasons. However, to be entirely correct,
you should perhaps consider storing the iterator following the item
you're trying to change, remove the item, change it, and then insert
it again using the stored iterator as the hint. It will be constant
AFA the complexity is concerned. And you'll have no mutable members
in your structs... Try it.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask
Ok, thanks for the quick reply. I will look into removing and
reinserting the object - my only concern is that other iterators may
be pointing at it (in my triangle and mesh classes). If I remove and
reinsert it then it will be at the same point in the sequence, but I
doubt if this guarantees existing iterators will still be valid.
That's a valid concern. Most likely they will become invalid.
Though I can probably change my code so I don't create other iterators
until the vertex object is finished being set up. I'll have a look...
V
wrap it:
class my_data;
class const_remover{
mutable my_data data;
//define ctor(s)
};
class my_alloc:
std::allocator<const_remover>
{
//redefine:
class value_type;
class reference_type;
class pointer_type;
};
class my_comp;
typedef set<const_remover,my_comp,my_alloc> my_set;
Is VC++ .net 2003 non standard compliant as far as set goes then? This
compiled and runs, and according to this discussion it shouldn't. I was
planning on seeing what chaning i to mutable would do, but it runs with or
without it being mutable.
#include <iostream>
#include <string>
#include <set>
class Foo
{
public:
double x, y, z;
double i;
};
bool operator<( const Foo& lhs, const Foo& rhs )
{
if ( lhs.x < rhs.x )
return true;
else if ( lhs.x == rhs.x )
if ( lhs.y < rhs.y )
return true;
else if ( lhs.y == rhs.y )
if ( lhs.z < rhs.z )
return true;
return false;
}
int main()
{
std::set<Foo> Bar;
Foo Inst;
Inst.x = 1.0;
Inst.y = 2.0;
Inst.z = 3.0;
Inst.i = 1234.0;
Bar.insert( Inst );
std::set<Foo>::iterator it = Bar.find( Inst );
it->i = 5.0;
it->x = 7.0;
for ( std::set<Foo>::iterator it = Bar.begin(); it != Bar.end(); ++it )
{
std::cout << it->x << " " << it->y << " " << it->z << " " << it->i
<< "\n";
}
return 0;
}
Under GCC, I get the following error with your code:
david@localhost:~$ g++ test.cpp
test.cpp: In function int main():
test.cpp:39: error: assignment of data-member Foo::i in read-only
structure
test.cpp:40: error: assignment of data-member Foo::x in read-only
structure
which corresponds to the lines:
it->i = 5.0;
it->x = 7.0;
However, my interpretation of the Josuttis book is not that you can't
do it, but that you shouldn't do it. I suspect that find(), begin(),
etc would like to return a const_iterator but that they are required
to return a non-const version in order to be compliant with the rest
of the STL. Though I don't know how GCC knows that the data structure
is read only.
disallowed. However the compiler can not know which members of the
must disallow all modifications of its elements. In the implementation