map< int, double* > ???

[turbozedd]

I inherited some code in which every class member of every class is public. I am attempting to hide the guts by writing accessors, then I can fix the problem with the type of data which is map< int, double* >.

So for the time being I have to write an accessor to a double* map.

At the moment I am getting a seg fault for writing data to the map. I havent tried accessing data stored in the map yet.

class mapthing
{
 public:

  map<int, double*> map_data;
  
  inline double& operator() (int i, int j)
  {
      double *arr=map_data[i];
      return arr[j];
  }
  inline double operator() (int i, int j) const
  { 
      map<int, double*>::const_iterator it= this->map_data.find(i);
      double *arr=it->second;
      return arr[j];
  }
};

[turbozedd]

Well, I suppose I have to actually allocate the double array if the map key doesn't exist.

Any other suggestions?

[kevinchkin]

Post some more code if you can ... so that we can try debugging

Edit: on the side note, you do not have to put inline infront of function if you are giving it's full definition inside the class itself. Any function which you define completely inside the class is by default inline

[kempofighter]

I don't really understand the question. What does mapthing have to do with the problems that you inherited?

As far as mapthing goes, it looks like a functor to me. Why did you overload operator()? What is this class for and why do you need to write a wrapper class for a std::map? Since map_data is public how can the class possibly be implemented with correct accessor functions? The class instance can't know if the map was changed by some other part of the program. There is no way that mapthing could know how big the array of doubles is and there is no way for it to perform any error checking to verify requests by the user since the object can be initialized and changed at any time by users of the object.

[turbozedd]

"mapthing" is a reduced version of the class I am currently working on privatizing.

The class already exists and is being used in a large working program. I am attempting to refactor the program.

All of the items kempofighter lists are things I am trying to fix. I am adding accessors so that I can replace all the instances where the object is accessed externally. Then I can move the data to private and use a normal data structure like a 2-d array or a vector of vectors.

The class does know how big it is (sorry I left that out):

class csignature
{
 public:
    int rows;
    int cols;
...

Here is a simple program that has everything(probably) that could happen to a mapthing's data.:

int main ()
{ 
    mapthing a,b;

    a.rows=3; b.cols=a.rows;
    a.cols=4; b.rows=a.cols;

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            a(i,j)=i+j;
        }
    }

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            b(i,j)=a(j,i);
        }
    }

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            cout << a(i,j) << ' ';
        }cout << endl;
    }cout << endl;

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 3; j++) {
            cout << b(i,j) << ' ';
        }cout << endl;
    }cout << endl;
    
    return 0;
}

Thanks for the help!

[kempofighter]

Your second post is on the right track. Where is memory allocated for the double array? I can see why the program would segfault given what you have posted. Setting the rows,cols ints don't change the fact that the map is still empty. Then you make this call.

a(i,j)=i+j;

So that calls the non-const version of operator() which attempts to return a reference to an element of the double array which has never been created in the first place.


Since nothing was ever inserted into the map, map_data[i] causes a pair to be inserted into the map. The double* is default initialized since what is returned is a pointer to nothing. then you attempt to access the arr with j but the arr doesn't point to anything.

double *arr=map_data[i];
      return arr[j];

First, you understand how operator[] of a map works correct? It will search for the key and if it doesn't find a value for the key specified it will construct the key/value pair and then return a reference to the value associated with the key. I can appreciate what you are doing but you are going to have to design a completely new interface that allows the user to specify the parameters and the object will have to construct the map and the underlying double array on its own. The interface functions used to access the data must be safe. You are going to have to validate the input params first and possibly throw exceptions if the params don't make sense, otherwise the program could simply crash or exhibit undefined behavior.

[turbozedd]

I really DO NOT want to use map< int, double* > . I hope to replace it with vector<vector<double*> > or a Fortran style matrix so I can use CLAPACK. I am trying to abstract away the data so I can change it. without affecting functionality

Here is my second try, I get a syntax error: no matching function call for insert line

double& operator() (int i, int j)
{
        map<int, double*>::iterator it = map_data.lower_bound(i);
        
        if (it == map_data.end() || map_sig_data.key_comp()(i, (*it).first)){
            double *newrow = new double[cols];
            it = map_sig_data.insert(it, newrow);
        }

        return (*it).second[j];
}

[kempofighter]

What is the container supposed to represent? what functionality do you want to have? A multi-dimensional array of double? What is the significance of the key? If you are able to make a simple 2d array, go for it! The map would be used, in my opinion, if the keys were non-contiguous values. If all you need is a multi-dimensional array, then the std::map is not the way to go. Would you just want a std::vector<std::vector<double> >?

The reason that it fails to compile the insert is because you are attempting to insert a pointer to an array. the value_type for this map is std::pair<int, double*>.

Take a look at this. In the example, notice the 1st and 2nd example of insert usage. Notice that a pair is being constructed.
http://cplusplus.com/reference/stl/map/insert/

It might help us give you some better advice if we had a general idea of what kind of data this mapthing class is supposed to manage.