Lets say i have:
class Base {...};
class Derived1 : public Base {...};
class Derived2 : public Base {...};
class Derived3 : public Base {...};
class Store {
public:
void Add(const Base&); //Adds mix of Derived1/2/3
private:
vector<const Base*> vec;
vector<shared_ptr<const Base> > vec_smart;
};
//------------------------------------------------------
void Store::Add(const Base& b){
vec.push_back(&b); //got sliced
}
When using vector of pointers to Base, it got sliced. I suppose i have to use smart pointers but I cant get it to work.
I tried something like:
auto tmp = make_shared<const Base> (b);
vec_smart.push_back(shared_ptr<const Base>(b));
But it still got sliced. What Iam doing wrong?
EDIT: I have << operator in Base class that calls virtual print in Derived classes.
ostream & operator <<(ostream & os, const Base & x) {
x.print(os);
return os;
}
void Base::print(ostream& os) const {
os << "Base";
}
void Derived1::print(ostream& os) const {
os << "Derived1";
}
When i call
cout << b;
In Store::Add it outputs fine but when I iterate over vector after it got stored all i get is "Base"
ostream & operator <<(ostream & os, const Store & x) {
for (auto it = x.vec.begin(); it != x.vec.end(); ++it) {
os << *(*it) << endl;
}
return os;
}
Is it a bad design?
I am going to guess you didn't declare the relevant methods in Base
as virtual
. Try this:
struct Base
{
virtual void print(std::ostream& os) const { os << "Base"; }
virtual ~Base() {}
};
struct Derived1 : Base
{
void print(std::ostream& os) const { os << "Derived1"; }
};
ans so on. Note I have only used struct
here to save me typing public
a few times.
Here is a working example:
#include <vector>
int main()
{
Base b;
Derived1 d;
std::vector<const Base*> v{&b, &d};
for (auto it = v.cbegin(); it != v.cend(); ++it)
{
std::cout << *(*it) << std::endl;
}
}
Output:
Base
Derived1
You can see it in action here .
Edit Your code has undefined behaviour because you are storing pointers to temporaries:
Store a("aaaaaaa");
a.Add(Derived("abc", 5));
a.Add(Derived("def", 6));
This version works as expected:
Store a("aaaaaaa");
Derived d0("abc", 5);
Derived d1("def", 6);
a.Add(d0);
a.Add(d1);
Edit 2 : from your comments:
Lets say Iam forced to use a.Add(Derived("abc", 5)); What can I do with it in my implementation?
You could make Add
a template:
template <typename T>
void Add(const T& elem)
{
vec.push_back(new T(elem));
}
or
template <typename T>
void Add(const T& elem)
{
vec_smart.push_back(std::make_shared(elem));
}
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.