Question

我想创建一个“ Act”对象的向量，其中包含指向动态分配的“ Eat”或“ Drink”对象的指针。新对象的放置方式如下：

action_vector.emplace_back(Act::BehaviorType::eat);

但是，它是段错误的，我不知道为什么。我认为emplace_back会隐式调用move构造函数，而不是析构函数，但由于某种原因，它（使我感到困惑）是什么。

有什么方法可以成功创建此类对象的向量吗？

这是其余的代码及其输出。抱歉，虽然有点冗长，但基本上这只是一种策略模式。

#include <iostream>
#include <vector>

class IBehavior
{
public:
    IBehavior() = default;
    virtual ~IBehavior() = default;
    virtual void execute() = 0;
};

class Drink : public IBehavior
{
public:
    Drink(): IBehavior() {}
    ~Drink() {}
    void execute() { std::cout << "Drinking" << std::endl; }
};

class Eat : public IBehavior
{
public:
    Eat(): IBehavior() {}
    ~Eat() {}
    void execute() { std::cout << "Eating" << std::endl; }
};


class Act
{
    IBehavior * b;

public:

    enum class BehaviorType { eat = 0, drink = 1 };

    Act() = default;
    ~Act()
    {
        std::cout << "Calling the destructor" << std::endl;
        delete b;
    }
    Act(BehaviorType b_type) { SetBehavior(b_type); }

    Act(Act&& act)
    {
        std::cout << "Calling the move constructor" << std::endl;
        this->b = act.b;
    }


    void SetBehavior(BehaviorType b_type)
    {
        if(b_type == BehaviorType::eat) b = new Eat();
        if(b_type == BehaviorType::drink) b = new Drink();
    }

    void execute() { b->execute(); }
};


int main(int argc, char * argv[])
{
    std::vector<Act> action_vector;

    for(int i = 0; i < 10; ++i)
    {
        action_vector.emplace_back(Act::BehaviorType::eat);
        action_vector[i].execute();
    }

    return 0;
}

输出：

Eating
Calling the move constructor
Calling the destructor
Eating
Calling the move constructor
Calling the move constructor
Calling the destructor
Calling the destructor
Segmentation fault: 11

Answer 1

您的移动构造函数复制b，而析构函数删除b，因此，如果您移动构造实例，则相同的指针值将被删除两次，且行为不确定。

一般解决方案：使用智能指针。

另一个错误：默认构造函数保留b未初始化。销毁默认构造的对象后，未初始化的指针将被删除，并且行为未定义。智能指针也可以解决此问题。

C ++为什么将对象包含在矢量段错误中？

1 个答案: