STL map question

Why not just storing a 'bool m_bIsModified' member in 'Test'? That would make the whole thing quite simple.

Hi JKR,

I was just giving a simplified version of the whole thing.  The problem is that there are two different paths that the Test objects be modified.  One is under my control and the other is not.  What happens is that a trigger is send to me from a database whenever the Test object is modified whether by my component or by the other path.  

So, I want to cashe the initial objects in the map, then when I modify the database I will also modify the object in the map.  So, if a trigger comes in I can check the objects in the map to see if it is due to the other path.

Thanks,

>>Can I modify the object and put it back.  Or I need to remove the object to be modified and then put the modified object back to map?  

You can modify the object and put it back.No need to remove the object to be modifed and put the modified object back.

Second point,
Make 2 cache,

(key,Value),
(keystringpath1,test object)  //one which is in your control
(test object,Keystringpath2) //one which is not n your control

Will it help ! if my understanding is correct.
Best Regards,
DeepuAbrahamK

Way off topic, with apologies...

I'm often wondering how far to go with ostream& operator<<. I could have written that illustration as follows below, but it feels funny defining insertion operators for classes created from STL templates. Why? Because the template classes like map<string,Test> "come for free" and you have to roll your own ostream operator<< for them, if that's what you want to do. Why don't the template classes provide their own operator<<? ... Well I guess one size doesn't fit all, and delimiting the display of container entries with newlines will not be appropriate for all projects. When you define an insertion operator, you suppose that you know how the client wants to display your class and you pollute the global namespace with what you reckon is right.

--------8<--------
#include <iostream>
#include <string>
#include <map>
#include <algorithm>
#include <iterator>
using namespace std;

struct Test {
      string a,b;
};
typedef map<string,Test> TestMap;

ostream& operator<<(ostream& os,const Test& test) {
        return os << "a=" << test.a << ", b=" << test.b;
}

ostream& operator<<(ostream& os,TestMap::value_type v) {
      return os << "testMap[\"" << v.first << "\"] = " << v.second;
}

ostream& operator<<(ostream& os,const TestMap& testMap) {
      copy(testMap.begin(),testMap.end(),ostream_iterator<TestMap::value_type>(os,"\n"));
      return os;
}

int main()
{
      Test test_one = {"good","indifferent"};
      Test test_two = {"bad","terrible"};

      TestMap testMap;
      testMap["one"] = test_one;
      testMap["two"] = test_two;

      cout << testMap << '\n';

      // Altering a test in the map, using a reference
      Test& test = testMap["one"];
      test.b = "splendid";

      cout << testMap << '\n';
}
--------8<--------

It is nice getting rid of functions like display, though, isn't it?