Question

 class CSensor
 {
    public:
    CSensor(int nVal1,char* pVal2,unsigned int nVal3);
    CSensor(const CSensor& refMessage);
    const CSensor& operator=(const CSensor& refMessage);
   ~CSensor(void);
   private:
   int m_nVal1;
   char* m_pVal2;   
   unsigned int m_nVal3;
 };

 // vector erase

 std::vector<CSensor> SensorList;
 CSensor obj1(1,"Test1",10);
 SensorList.push_back(obj1);
 CSensor obj2(2,"Test2",11);
 SensorList.push_back(obj2);
 CSensor obj3(3,"Test3",12);
 SensorList.push_back(obj3);

 SensorList.erase (SensorList.begin()+1);



// map erase
    std::map<int ,CSensor> ListSensor;
CSensor obj11(1,"Test1",10);    
CSensor obj12(2,"Test2",11);
CSensor obj13(3,"Test3",12);

ListSensor.insert(std::pair<int,CSensor>(1,obj11));
ListSensor.insert(std::pair<int,CSensor>(2,obj12));
ListSensor.insert(std::pair<int,CSensor>(3,obj13));

ListSensor.erase(2);

I debugged both the case.
In both the cases i am deleting the second element.In case of vector
it is copying 3 element to 2nd poition and than it it deleting the 3 rd location.

So when u say

   List.erase (List.begin()+1);

it is calling assignment operator(CSensor=) and then calling destructor.

In case of map when i do

   ListSensor.erase(2);

it only calls the destructor.

I have gone through STL vector vs map erase.
It talks Iterator,couldn’t explain the behavior.

My question is why erase behaves differently for these two STL container??

Answer 1

This is not a behaviour of .erase per se, but a consequence of how each respective container works.

Deleting from a vector

When you delete from a vector ^{(List is a really poor name for a vector, btw)}, its contents must be shuffled along to fill the gap because the elements of a vector are always stored contiguously in memory.

This is generally done by copying (or moving) elements then chopping off the remainder:

• Vector elements in memory:

  +---+---+---+---+---+---+---+---+---+
  | a | b | c | d | e | f | g | h | i |
  +---+---+---+---+---+---+---+---+---+
  

• Erase ‘e’:

  +---+---+---+---+---+---+---+---+---+
  | a | b | c | d |   | f | g | h | i |
  +---+---+---+---+---+---+---+---+---+
  

• Fill the gap by copying/moving across:

                     <--
  +---+---+---+---+---+---+---+---+---+
  | a | b | c | d | f | f | g | h | i |
  +---+---+---+---+---+---+---+---+---+
  
                         <--
  +---+---+---+---+---+---+---+---+---+
  | a | b | c | d | f | g | g | h | i |
  +---+---+---+---+---+---+---+---+---+
  
                             <--
  +---+---+---+---+---+---+---+---+---+
  | a | b | c | d | f | g | h | h | i |
  +---+---+---+---+---+---+---+---+---+
  
                                 <--
  +---+---+---+---+---+---+---+---+---+
  | a | b | c | d | f | g | h | i | i |
  +---+---+---+---+---+---+---+---+---+
  

• Resize the container:

  +---+---+---+---+---+---+---+---+
  | a | b | c | d | f | g | h | i |
  +---+---+---+---+---+---+---+---+
  

---

Deleting from a map

This is not the case for a map, whose contents are not necessarily stored contiguously in memory (in fact, the complexity requirements mean it’s almost always a tree structure filled with pointers to discontiguous data).