Dereferencing iterator (c++) - c++

Question

I have problem with dereferencing result of operation that returns non-pointer value.
In this map i have pointers to matrixes
map<string, GeneralMatrix*> matrixes;
and this is how operations with matrixes look like
GeneralMatrix & add(const GeneralMatrix & m2) {
//Check for compatible matrixes
if (height != m2.height || width != m2.width) {
cout << "Matrix sizes must match!" << endl;
return *this;
}
//Create new empty matrix
GeneralMatrix &m3 = createNew(width, m2.height);
//Set every number to sum of this and given matrix
for (int i = 0; i < height; i++) {
for (int j = 0; j < m2.width; j++) {
double val = m2.get(i, j);
if (val != 0) {
val += get(i, j);
m3.set(i, j, val);
}
}
}
return m3;
}
As you can see, add method returns non-pointer matrix that i want to insert into my map.
This is what I tried:
map<string, GeneralMatrix *>::iterator itop1 , itop2;
//now seting iterators to their position
//there is the problem
matrixes.insert(pair<string, GeneralMatrix *>(result, (*itop1->second->add(*itop2->second))));
Problem is that i cant find out how to insert second parameter of pair. It alway ends with error because of different types.
Attempt n1:
itop1->second->add(itop2->second)
Add method needs pointer
Attempt n2:
itop1->second->add(*itop2->second)
Result is non-pointer, needs to be pointer
Attemp n3:
(*itop1->second->add(*itop2->second))
main.cpp:611:68: error: no match for ‘operator*’ (operand type is ‘GeneralMatrix’)
How to derefence result then ?

Answer 1

Ideally you would change matrixes to type map<string, GeneralMatrix>.
Alternatively you could keep an std::list<GeneralMatrix> that stores the matrices and you give a pointer to the matrix inside the list.
It is considered bad style to have naked pointers. Pointers should instead tell the ownership status they have over the item, such as unique_ptr, shared_ptr or weak_ptr. That would also take care of memory management.
If your class is well behaved and the map holds owning pointers you could do something like this:
matrixes.insert(std::make_pair(std::string("name"), new GeneralMatrix(std::move(m)));
Where m is the matrix you are trying to move into the map.
If the pointers in the map do not own the pointers you can just insert the address of the map with &m, but that requires you to store the matrix somewhere persistent such as the list shown above.
Edit:
Your specific problem with the iterator can be solved like this:
matrixes.insert(pair<string, GeneralMatrix *>(result, &(*itop1)));

Answer 2

A quick solution to your problem is:
GeneralMatrix& m3= add(m2);
matrixes["string"] = &m3;
matrixes.insert(std::make_pair(std::string("name"), (&m3)));
matrixes.insert(std::make_pair<std::string, GeneralMatrix*>("name", &m3));
They are basically both equivalent in this case, however operator[] will always insert a value in the map, even if the right hand operator is null.
For example:
matrixes["s"];
will insert an empty pointer
Your code however has several problems:
first, why do you need to return a reference from the method createNew?
Just return a value to a new matrix. You don't gain anything doing this.
GeneralMatrix createNew(width, m2.height);
As suggested in another answer, have a map of string to unique_pointers instead of using raw pointers and/or leverage move semantics.
In your case, since an "add" operation will always result in creating a new matrix, I wouldn't even bother dealing with pointers, as they give you no real advantage
Here you can find some stripped down code that will fit your needs:
std::map<std::string, GeneralMatrix> matrixes;
GeneralMatrix add(const GeneralMatrix& m2)
{
//Create new empty matrix
auto m3 = createNew(width, m2.height);
return m3;
}
Note also that this code will be optimized by your compiled, using something called NRVO (named return valueoptimization), and it will likely be faster that your previous one that dealt with dynamic allocation in the createNew method).
Now, if General matrix implements correctly the rvalue copy constructor you can move it to your map
map.insert(std::string("string"), std::move<m3>);
or you can just emplace it (not yet implemented by all compilers)
map.emplace(std::make_pair(std::string("string"), createNew(m2)));
If you need polymorphism, just use a factory method that returns a base std::unique_ptr.
std::unique_ptr<GeneralMatrix> createNew(width, m2.height);