vector<ofstream > indexing

[Gary Wessle]

Hi

I have a map<string, doublem_tempera tures which gets updated
often.
I need to save the data to files corresponding to each string each
time the map is updated, I am expecting about 80 files in total.

how do I go about it?, do I set a vector<ofstream *cities; something
like

map<string, doublem_tempera tures;
vector<ofstream *files

/* first create ofstreams and leave them open for appending */
for( map<string, double>::iterat aor i = m_temperatures. begin();
i != m_temperatures. end(), i++ ){
ofstream* ofs( i->first.c_str( ), ios::app );
files.push_back ( ofs );
}

void updating( map<string,doub lemp ){
loop through the map and increment a counter, use this counter to
index the vector<ofstream *which can then be de-refrenced and
values from the map appended to the file.
}

but that is fragile because the order of the map is no guaranty to
correspond to the order of the streams in the vector.

any better ideas.

thanks

[isanbard]

On Dec 12, 5:22 pm, Gary Wessle <phd...@yahoo.c omwrote:

Hi

I have a map<string, doublem_tempera tures which gets updated
often.
I need to save the data to files corresponding to each string each
time the map is updated, I am expecting about 80 files in total.

how do I go about it?, do I set a vector<ofstream *cities; something
like

map<string, doublem_tempera tures;
vector<ofstream *files

/* first create ofstreams and leave them open for appending */
for( map<string, double>::iterat aor i = m_temperatures. begin();
i != m_temperatures. end(), i++ ){
ofstream* ofs( i->first.c_str( ), ios::app );
files.push_back ( ofs );
}

void updating( map<string,doub lemp ){
loop through the map and increment a counter, use this counter to
index the vector<ofstream *which can then be de-refrenced and
values from the map appended to the file.

}but that is fragile because the order of the map is no guaranty to
correspond to the order of the streams in the vector.

Slightly grosser hack:

std::pair<doubl e, std::ofstreamVa lPair;
std::map<std::s tring, ValPairm_temper atures;

for (std::map<std:: string, ValPair>::itera tor i =
m_temperature.b egin(),
e = m_temperature.e nd(); i != e; ++I) {
ofstream* ofs(i->first.c_str( ), ios::app);
i->second.first = ofs;
}

void updating(std::m ap<std::string, ValPairmp) {
...
}

-bw

[Capstar]

is******@gmail. com schreef:

On Dec 12, 5:22 pm, Gary Wessle <phd...@yahoo.c omwrote:

> Hi

I have a map<string, doublem_tempera tures which gets updated
often.
I need to save the data to files corresponding to each string each
time the map is updated, I am expecting about 80 files in total.

how do I go about it?, do I set a vector<ofstream *cities; something
like

map<string, doublem_tempera tures;
vector<ofstrea m*files

/* first create ofstreams and leave them open for appending */
for( map<string, double>::iterat aor i = m_temperatures. begin();
i != m_temperatures. end(), i++ ){
ofstream* ofs( i->first.c_str( ), ios::app );
files.push_back ( ofs );
}

void updating( map<string,doub lemp ){
loop through the map and increment a counter, use this counter to
index the vector<ofstream *which can then be de-refrenced and
values from the map appended to the file.

}but that is fragile because the order of the map is no guaranty to
correspond to the order of the streams in the vector.

Slightly grosser hack:

std::pair<doubl e, std::ofstreamVa lPair;

I think you're missing a typedef here.

std::map<std::s tring, ValPairm_temper atures;

for (std::map<std:: string, ValPair>::itera tor i =
m_temperature.b egin(),
e = m_temperature.e nd(); i != e; ++I) {
ofstream* ofs(i->first.c_str( ), ios::app);
i->second.first = ofs;
}

void updating(std::m ap<std::string, ValPairmp) {
...
}

-bw

Depending on the requirements for your m_temperature, I'd probably wrap
the whole thing in a class, that will act more or less like a std::map,
but on assigning a value to a key, it would append a string to a file.
This might however not be worth while if you want this class to be a
compliant container, since then it's a quite a lot more work.

Mark

[Gary Wessle]

Gary Wessle <ph****@yahoo.c omwrites:

Hi

I have a map<string, doublem_tempera tures which gets updated
often.
I need to save the data to files corresponding to each string each
time the map is updated, I am expecting about 80 files in total.

how do I go about it?, do I set a vector<ofstream *cities; something
like

map<string, doublem_tempera tures;
vector<ofstream *files

/* first create ofstreams and leave them open for appending */
for( map<string, double>::iterat aor i = m_temperatures. begin();
i != m_temperatures. end(), i++ ){
ofstream* ofs( i->first.c_str( ), ios::app );
files.push_back ( ofs );
}

void updating( map<string,doub lemp ){
loop through the map and increment a counter, use this counter to
index the vector<ofstream *which can then be de-refrenced and
values from the map appended to the file.
}

but that is fragile because the order of the map is no guaranty to
correspond to the order of the streams in the vector.

any better ideas.

thanks

would this explain a bit better what I am trying to do?

int main(){
/* city, temperature map. */
vector<stringna mes;
names.push_back ("a");
names.push_back ("b");

map<string, ofstream*m_os;
for( vector<string>: :iterator i = names.begin();
i != names.end(); i++ ){
ofstream* p_of( (*i).c_str(), ios::app );
m_os[*i] = p_of;
}

for( int i=0; i<10; i++ ) {
m_os["a"].second << i << " ";
}
}

[Gary Wessle]

Capstar <ne**@eg.homeip .netwrites:

is******@gmail. com schreef:

On Dec 12, 5:22 pm, Gary Wessle <phd...@yahoo.c omwrote:

Hi

I have a map<string, doublem_tempera tures which gets updated
often.
I need to save the data to files corresponding to each string each
time the map is updated, I am expecting about 80 files in total.

how do I go about it?, do I set a vector<ofstream *cities; something
like

map<string, doublem_tempera tures;
vector<ofstream *files

/* first create ofstreams and leave them open for appending */
for( map<string, double>::iterat aor i = m_temperatures. begin();
i != m_temperatures. end(), i++ ){
ofstream* ofs( i->first.c_str( ), ios::app );
files.push_back ( ofs );
}

void updating( map<string,doub lemp ){
loop through the map and increment a counter, use this counter to
index the vector<ofstream *which can then be de-refrenced and
values from the map appended to the file.

}but that is fragile because the order of the map is no guaranty to
correspond to the order of the streams in the vector.

Slightly grosser hack:

std::pair<doubl e, std::ofstreamVa lPair;

I think you're missing a typedef here.

std::map<std::s tring, ValPairm_temper atures;

for (std::map<std:: string, ValPair>::itera tor i =
m_temperature.b egin(),
e = m_temperature.e nd(); i != e; ++I) {
ofstream* ofs(i->first.c_str( ), ios::app);
i->second.first = ofs;
}

void updating(std::m ap<std::string, ValPairmp) {
...
}

-bw

Depending on the requirements for your m_temperature, I'd probably wrap
the whole thing in a class, that will act more or less like a std::map,
but on assigning a value to a key, it would append a string to a file.
This might however not be worth while if you want this class to be a
compliant container, since then it's a quite a lot more work.

Mark

thanks for the idea.

here is as complete and simple I can put it, but it is not firing, I
am screwing up the syntax? or the structure is wrong?

this is not compiling, if I get it to compile, it will "hopefully"
solve my problem.

int main(){
vector<stringna mes;
names.push_back ("a");
names.push_back ("b");

map<string, ofstream*m_os;
for( vector<string>: :iterator i = names.begin();
i != names.end(); i++ ){
ofstream* p_of( (*i).c_str(), ios::app );
m_os[*i] = p_of;
}

for( vector<string>: :iterator i=names.begin() ;
i!=names.end(); i++ ){
(*( m_os[*i].second)) << "123" << " ";
}
}

[Capstar]

Gary Wessle schreef:

here is as complete and simple I can put it, but it is not firing, I
am screwing up the syntax? or the structure is wrong?

this is not compiling, if I get it to compile, it will "hopefully"
solve my problem.

I have not tested my alterations, but I think it might work.

>
int main(){
vector<stringna mes;
names.push_back ("a");
names.push_back ("b");

map<string, ofstream*m_os;

Try:map<string, ofstreamm_os;

for( vector<string>: :iterator i = names.begin();
i != names.end(); i++ ){
ofstream* p_of( (*i).c_str(), ios::app );

Try: ofstream p_of( (*i).c_str(), ios::app );

m_os[*i] = p_of;
}

for( vector<string>: :iterator i=names.begin() ;
i!=names.end(); i++ ){
(*( m_os[*i].second)) << "123" << " ";
}
}

Mark