C ++ std :: make_shared内存泄漏

Question

I'm having memory leak problems with the following line of code:

auto state = newSpriteState();

Where these are the related functions:

class SpriteState {
    protected:
        Vector3 position;
        int width, height;
        double rotation, scaling;
        int priority;

    public:
        SpriteState()
            : position(0,0,0),
            width(1), height(1),
            rotation(0), scaling(1.0f),
            priority(0)
        {}

    std::shared_ptr<SpriteState> newSpriteState()
    {
        return std::make_shared<SpriteState>();
    }
};

class Vector3 {
private:
    double x, y, z;

public:
    Vector3( double x_, double y_, double z_ )
    {
        x = x_; y = y_; z = z_;
    }
};

Intel Inspector continues to report that I'm having a memory leak in the function newSpriteState() ; more specifically std::make_shared<SpriteState>() .

UPDATE

Judging from the comments, it seems there may be some external reason for this so here's more code:

bool Sprite::loadImage() {
    auto state = newSpriteState();
    initStateVector(0, state);
}

where:

class Sprite
{
public:
    Sprite();

    std::map<const int, const std::shared_ptr<SpriteState>> stateVector;

    void initStateVector(const int line, std::shared_ptr<SpriteState>& state)
    { 
        stateVector.clear(); 
        stateVector.insert(std::make_pair( line, std::move(state) )); 
    }

    void loadImage();
}

I've uploaded a simplified version of the Sprite class I'm actually using for clarity.

Basically, I'm allocating a shared_ptr<SpriteState> and sticking into a std::map in class Sprite .

Answer 1

The problem has been solved after an upgrade to vs12. My best estimation is that the problem had something to do with the tr1 implementation of smart pointers.