Does a std::set ever rebalance ?

[mathieu]

hi there,

I would like to know if the following piece of code is garantee to
work. I am afraid that the cstring address I am using in the std::map
found from a request in std::set is not garantee to remain the same as
the std::set grows...

thanks
-Mathieu

#include <set>
#include <map>
#include <iostream>

struct FileValuePair {
const char *filename;
const char *value;
};

static FileValuePair MAPPINGS[] = {
{ "foo1.dat" , "value1" },
{ "foo2.dat" , "value2" },
{ "foo3.dat" , "value1" },
{ "foo4.dat" , "value3" },
{ "foo5.dat" , "value2" },
{ "foo6.dat" , "value3" },
{ NULL , NULL },
};

int main()
{
FileValuePair *p = MAPPINGS;
std::set< std::string values;
std::map< const char *, const char * mappings;
while(p->filename)
{
values.insert( p->value );
// find back the address:
const char *v = values.find( p->value )->c_str();
mappings.insert (
std::map<const char*,const char*>::value_t ype(p->filename, v));
++p;
}

std::map<const char*,const char*>::const_i terator it =
mappings.begin( );
for(; it != mappings.end(); ++it)
{
std::cout << it->first << " -" << it->second << std::endl;
}

return 0;
}

[Victor Bazarov]

Re: Does a std::set ever rebalance ?

mathieu wrote:

I would like to know if the following piece of code is garantee to
work. I am afraid that the cstring address I am using in the std::map
found from a request in std::set is not garantee to remain the same as
the std::set grows...

Insertions in 'std::set' or 'std::map' do not invalidate iterators
or references. The call to 'find' returns an iterator. You call the
'c_str()' for the object referred to by the iterator. The object is
not going to change unless you remove the entry itself from the set.
So, the pointer returned by 'c_str()' should still be valid up until
the set is destroyed.

At least that's my take on it...

>
thanks
-Mathieu
>
#include <set>
#include <map>
#include <iostream>
>
struct FileValuePair {
const char *filename;
const char *value;
};
>
static FileValuePair MAPPINGS[] = {
{ "foo1.dat" , "value1" },
{ "foo2.dat" , "value2" },
{ "foo3.dat" , "value1" },
{ "foo4.dat" , "value3" },
{ "foo5.dat" , "value2" },
{ "foo6.dat" , "value3" },
{ NULL , NULL },
};
>
int main()
{
FileValuePair *p = MAPPINGS;
std::set< std::string values;
std::map< const char *, const char * mappings;
while(p->filename)
{
values.insert( p->value );
// find back the address:
const char *v = values.find( p->value )->c_str();
mappings.insert (
std::map<const char*,const char*>::value_t ype(p->filename, v));
++p;
}
>
std::map<const char*,const char*>::const_i terator it =
mappings.begin( );
for(; it != mappings.end(); ++it)
{
std::cout << it->first << " -" << it->second << std::endl;
}
>
return 0;
}

--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Jerry Coffin]

Re: Does a std::set ever rebalance ?

In article <219f47cb-04a3-4d05-9d82-
4e8930d7b3fa@i2 9g2000prf.googl egroups.com>, mathieu.malater re@gmail.com
says...

hi there,
>
I would like to know if the following piece of code is garantee to
work. I am afraid that the cstring address I am using in the std::map
found from a request in std::set is not garantee to remain the same as
the std::set grows...

It does rebalance, but rebalancing only involves changing the
arrangement of the nodes in the tree. Each node contains pointers to one
or two children. Rebalancing involves changing the pointers between
nodes, but does not actually move the nodes themselves. Addresses and/or
iterators that refer to objects you store in the set/map are never
invalidated by inserting into the set/map.

--
Later,
Jerry.

The universe is a figment of its own imagination.