Factory design pattern with music classes
You have implemented is a factory pattern.
What you describe in the first paragraph is an Abstract factory pattern. Slightly different.
An abstract factory allows you to plug in one of multiple different factory's in at run-time to get different situations.
As a big note. Stop using pointers like that. That is a complete no no in C++

Do you need to create the factory dynamically.
A local object will probably do.

Even though the factory probably needs to create the objects dynamically you don't want to return pointers (but rather a smart pointer or a reference depending on how you want to handle ownership semantics (there are several good articles on SO about this so go have a read)).


Example:
class MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre) = 0;
};

class AsianMusicFactory: public MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre);
};
class AfricanMusicFactory: public MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre);
};
class EuropeanMusicFactory: public MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre);
};
class SouthAmericannMusicFactory: public MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre);
};
class NorthAmericannMusicFactory: public MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre);
};
// Special factory used when running unit tests.
class UnitTestMusicFactory: public MusicFactory
{
    public:
        virtual std::unique_ptr&lt;Music&gt; getMusic(genre_e genre);
};

So you have a bunch of different factories that all implement the same interface. But how do you know which one you should use. A common way is for a single creation point. Just ask the system it will create one for the lifetime of the application.
MusicFactory&amp; getMusicFactory()
{
     // Note the static here.
     // It will only be created and initialized once (on first call).
     static std::unique_ptr&lt;MusicFactory&gt;  factory = createMusicFactory();
     return *factory;
}
// Never call this method directly.
// This function should only be called by getMusicFactory().
std::unique_ptr&lt;MusicFactory&gt; createMusicFactory()
{
     // Get info from user configuration.
     // Command line arguments. IP information etc whatever helps you
     // Make the decision on the actual factory that should be instantiated.
     // So we can decide what factory should be used by the application.
     std::unique_ptr&lt;MusicFactory&gt;  result(new XXXXX);
     return result;
}

int main()
{
    // Get the factory.
    MusicFactory&amp;          fac   = getMusicFactory();

    // Use the factory to create the music.
    // At compile time we don't know what continents the music is from
    // as this is decided at run-time by he system and what factory is
    // created.
    std::unique_ptr&lt;Music&gt; music = fac.getMusic(ROCK);

    cout&lt;&lt;&quot;Song: &quot;;
    music-&gt;song();   // Should test for NULL
}