std :: map :: size（）与迭代器不同

Question

I use a std::map with a custom comparison class and custom classes as key

Now I use the operator[] to access elements by key. This however seems to create a big problem. The map seems to incorrectly allocate elements or they become corrupt. This becomes obvious because my custom comparison class throws an exception when it detects that one of the objects it compares has arbitrary values stored in its data fields (which seems to imply that the constructor didn't run or that the object was never created in the first place)

Now another discrepancy shows up:

When I call std::map::size() and compare it to the number of times I can increment a begin() iterator to get to the end() iterator then they don't match.

Specifically the map reports a larger size() than it apparently contains.

The class I use as key is a custom matrix class with data fields:

unsigned int
unsigned int
vector<vector<Another Class>>

However in none of these classes do I use pointer arithmetic or anything else that could manipulate memory directly. Also I don't have custom defined copy constructors in any of the classes that are used.

EDIT: Comparison Function

struct SymModMatComp
{
  bool operator()(const ModMat& mat1, const ModMat& mat2) const
  {
    unsigned int rows = mat1.get_row_number();

    unsigned int columns = mat1.get_column_number();
    if(mat2.get_row_number() != rows || mat2.get_column_number() != columns)
    {
      throw dimension_mismatch();
    }
    for(unsigned int i = 0; i < rows; i++)
    {
      for(unsigned int j = 0; j < columns; j++)
      {
        if(mat1.get_item(i,j).get_value() < mat2.get_item(i,j).get_value())
        {
          return true;
        }
        else if(mat1.get_item(i,j).get_value() > mat2.get_item(i,j).get_value())
        {
          return false;
        }
      }
    }
    return false;
  }
}

get_value() returns an unsigned int

SOLVED:

I used valgrind to check for any memory access errors... I found out that a totally unrelated part of the program actuallz did do a delete on an already deleted object over and over ....

That seems to have corrupted the space the map stored items in.

Thanks for all the good ideas though!

Answer 1

Without code it is difficult to guess, however I will try anyway.

Are you aware that T& operator[] ( const key_type& x ) ; insert the value in the map if the key is not there? So, the map size will increase by one if you haven't the key in the map already.

The element will be created using the default constructor.

Answer 2

If you're experiencing corruption with a map with complex user-defined keys, it's likely that your comparison function does not respect the requirements of a strict weak ordering :

• irreflexivity: !(x < x)
• asymmetry: !(x < y && y < x)
• transitivity: x < y && y < z -> x < z
• transitivity of incomparability: !(x < y || y < x || y < z || z < y) -> !(x < z || z < x)

If any of these requirements are not met, undefined behaviour (eg memory corruption) will result.

If the matrix participates in the comparison function, an easy way to ensure a strict weak ordering is to use lexicographic ordering on its elements.