Map which stores derived objects - c++

Question

I have parent class:
class Data
{
public:
Data ( void ) { }
Virtual int Size ( void )
{
return 100;
}
protected:
map<string, Data*> m;
};
Classes that inherit from class Data:
class Struct : public Data
{
public:
Struct ( void ) { }
Struct & Add ( const string & name, Data x )
{
Data * tmp = new Data ( x );
m[name] = tmp;
return *this;
}
void Print ( void )
{
for ( const auto & tmp : m )
cout << tmp . first << " " << tmp . second -> Size () << endl;
}
};
class IntData : public Data
{
public:
IntData ( void ) { }
int Size ( void )
{
return 4;
}
};
class DoubleData : public Data
{
public:
DoubleData ( void ) { }
int Size ( void )
{
return 8;
}
};
main :
int main ( void )
{
Struct a;
a . Add ( "Integer",IntData () );
a . Print ();
return 0;
}
Current output : Integer 100
Expected output : Integer 4
I want to create a map which would hold various types of objects that are derived from Data class. But when i want to call method Size from stored object in map ( in this case IntData ) which should return 4 It always returns value from parent class Data. How could i fix that please?

Answer 1

There's your problem:
Data * tmp = new Data ( x );
The actual pointer you're putting into the map is an instance of the Data parent class. You're copy-constructing a new instance of the Data parent class from an argument that you're passing, by value, as a parameter.
You need to change this whole function to:
Struct & Add ( const string & name, Data *x)
{
m[name] = x;
return *this;
}
And the caller is now responsible for constructing a new instance of any subclass:
a . Add ( "Integer",new IntData);
Then, this will work as you intended.
Of course, this kind of an approach brings up various issues with memory leaks, etc..., so you're better off using std::shared_ptr. But that would be a different question...

Answer 2

I've rewritten your code for you.
#include <unordered_map>
#include <memory>
#include <iostream>
class Data {
public:
virtual ~Data(){}
virtual int Size() = 0;
};
class Struct : public Data {
std::unordered_map<std::string, std::unique_ptr<Data>> m;
public:
Struct& Add(const std::string& name, std::unique_ptr<Data> x) {
m[name] = std::move(x);
return *this;
}
void Print() {
for(const auto& tmp : m )
std::cout << tmp.first << " " << tmp.second->Size() << "\n";
}
int Size() override {
int sum = 0;
for (const auto& tmp : m)
sum += tmp.second->Size();
return sum;
}
};
class IntData : public Data {
public:
int Size( ) override { return 4; }
};
class DoubleData : public Data {
public:
DoubleData( ) { }
int Size( ) override { return 8; }
};
int main() {
Struct a;
a.Add("Integer", std::make_unique<IntData>() );
a.Print();
}
Your welcome.