First, we must find the right data structure to store the textures. We ought to choose an STL container that does not perform unnecessary copies. std::vector is the wrong choice, since inserting new textures can trigger a reallocation of the dynamic array and the copying of all textures. Not only is this slow, but also all references and pointers to the textures are invalidated. As mentioned before, we like to access the textures by an enum, so the associative container std::map looks like the perfect choice. The key type is our enumeration, the value type is the sf::Texture.

We call our enum as ID, and let it contain three texture identifiers Landscape, Airplane, and Missile. We nest it into a namespace Textures. The namespace gives us a scope for the enumerators. Instead of writing just Airplane, we have Textures::Airplane which clearly describes the intention and avoids possible name collisions in the global scope:

namespace Textures
{
    enum ID { Landscape, Airplane, Missile };
}

We do not store the sf::Texture directly, but we wrap it into a std::unique_ptr.

Unique pointers give us a lot of flexibility; we can basically pass around heavyweight objects without creating copies. In particular, we can store classes that are non-copyable, such as, sf::Shader. Our class then looks as shown in the following code:

class TextureHolder
{
    private:
        std::map<Textures::ID, std::unique_ptr<sf::Texture>> mTextureMap;
};

The compiler-generated default constructor is fine, our map is initially empty. Same for the destructor, std::map and std::unique_ptr take care of the proper deallocation, so we do not need to define our own destructor.

What we have to write now is a member function to load a resource. It has to take a parameter for the filename and one for the identifier in the map:

void load(Textures::ID id, const std::string& filename);

In the function definition, we first create a sf::Texture object and store it in the unique pointer. Then, we load the texture from the given filename. After loading, we can insert the texture to the map mTextureMap. Here, we use std::move() to take ownership from the variable texture and transfer it as an argument to std::make_pair(), which constructs a key-value pair for the map:

void TextureHolder::load(Textures::ID id, const std::string& filename)
{
    std::unique_ptr<sf::Texture> texture(new sf::Texture());
    texture->loadFromFile(filename);

    mTextureMap.insert(std::make_pair(id, std::move(texture)));
}

So far, we have seen how to load resources. Now we finally want to use them. We write a method get() that returns a reference to a texture. The method has one parameter, namely the identifier for the resource. The method signature looks as follows:

sf::Texture& get(Textures::ID id);

Concerning the implementation, there is not much to do. We perform a lookup in the map to find the corresponding texture entry for the passed key. The method std::map::find() returns an iterator to the found element, or end() if nothing is found. Since the iterator points to a std::pair<const Textures::ID, std::unique_ptr<sf::Texture>>, we have to access its second member to get the unique pointer, and dereference it to get the texture:

sf::Texture& TextureHolder::get(Textures::ID id)
{
    auto found = mTextureMap.find(id);
    return *found->second;
}

int         a = 7;
decltype(7) a = 7;   // decltype(7) is int
auto        a = 7;   // auto is deduced as int

In order to be able to invoke get() also, if we only have a pointer or reference to a const TextureHolder at hand, we need to provide a const-qualified overload. This new member function returns a reference to a const sf::Texture, therefore the caller cannot change the texture. The signature is slightly different:

const sf::Texture& get(Textures::ID id) const;

The implementation stays the same, so it is not listed again. Our class now looks as follows:

class TextureHolder
{
    public:
        void                  load(Textures::ID id,const std::string& filename);
        sf::Texture&          get(Textures::ID id);
        const sf::Texture&    get(Textures::ID id) const;
    private:
        std::map<Textures::ID,std::unique_ptr<sf::Texture>> mTextureMap;
};

Now the get() method is easy to use and can directly be invoked when a texture is requested:

TextureHolder textures;
textures.load(Textures::Airplane, "Media/Textures/Airplane.png");

sf::Sprite playerPlane;
playerPlane.setTexture(textures.get(Textures::Airplane));