Vector of Base unique_ptr导致emplace_back(new T())上的对象切片

Question

我试图将类型作为参数传递给一个方法，该方法将正确构造并将对象推送到unique_ptr的向量，但是创建的对象始终是Base对象。这发生在使用emplace_back()时，如果我只是实例化对象，同样的工作很好。

在向量之外构造对象工作得很好，但是我不确定如何将指针移动到向量之后。

body_parts.hpp

#include <vector>
#include <string>
#include <fmt/core.h>
using namespace std;
namespace uhcr {
class body_part
{
public:
string name = "Generic";
template <class T>
void add_body_part()
{
this->body_parts.emplace_back<T*>(new T());
fmt::print("{}n", this->body_parts.back()->name);
}
private:
vector<unique_ptr<body_part>> body_parts;
};
class torso : public body_part
{
public:
string name = "Torso";

};
}

character.hpp

#include <string>
#include "components/body_parts.hpp"
using namespace std;
namespace uhcr {

class character : public body_part
{
public:
string name = "Character";

};
}

main.cpp

#define FMT_HEADER_ONLY
#include <memory>
#include <fmt/core.h>
#include "src/character.hpp"
using namespace fmt;
using namespace uhcr;
void create_human() {
character human;
human.add_body_part<torso>();
}
int main(void) {
create_human();  
return 1;
}

错误在add_body_part()，当运行这段代码时，它打印"Generic"

Answer 1

在子类中有多个名为name的数据成员。您可能希望为body_part中的成员赋值，而不是声明新成员来遮蔽它。

class body_part
{
public:
body_part() = default;
string name = "Generic";
template <class T>
void add_body_part()
{
this->body_parts.emplace_back<T*>(new T());
fmt::print("{}n", this->body_parts.back()->name);
}
protected:
body_part(std::string name) : name(name) {}
private:
vector<unique_ptr<body_part>> body_parts;
};
class torso : public body_part
{
public:
torso() : body_part("Torso") {}

};
class character : public body_part
{
public:
character() : body_part("Character") {}

};

Answer 2

您的代码中没有切片。您似乎期望虚拟成员变量，但没有这样的事情。当使用虚拟方法时，可以得到预期的输出:

#include <memory>
#include <vector>
#include <iostream>
#include <string>
using namespace std;

class body_part
{
public:
virtual std::string getName() { return "Generic";}
template <class T>
void add_body_part()
{
this->body_parts.emplace_back<T*>(new T());
std::cout << this->body_parts.back()->getName();
}
virtual ~body_part() = default;
private:
vector<unique_ptr<body_part>> body_parts;
};
class torso : public body_part
{
public:
std::string getName() override { return "Torso"; }

};

class character : public body_part
{
public:
std::string getName() override { return "Character"; }
};

void create_human() {
character human;
human.add_body_part<torso>();
}
int main(void) {
create_human();  
return 1;
}

现场演示

---

这是一个同样效果的简单例子:

#include <iostream>
#include <string>
struct foo {
std::string name = "Generic";
void x(foo& f){
std::cout << f.name;
}
virtual ~foo() = default;
};
struct bar : foo {
std::string name = "Beneric";
};
int main () {
foo f;
bar b;
f.x(b);
}

bar有两个name成员。在foo中，当你写std::cout << f.name时，它指的是foo::name而不是bar::name。如果foo实际上是bar，则可以在foo中访问bar::name，但这会导致一些反向设计:

#include <iostream>
#include <string>
struct foo {
std::string name = "Generic";
void x(foo& f);
virtual ~foo() = default;
};
struct bar : foo {
std::string name = "Beneric";
};
void foo::x(foo& f) {
std::cout << dynamic_cast<bar&>(f).name;
}

int main () {
foo f;
bar b;
f.x(b);
}

在您的示例中，dynamic_cast将不是一个问题，因为您刚刚创建了T，并且您知道它是T，但是您应该使用虚拟方法而不是依赖于强制转换。