A comment:
The Artemis implementation is interesting. I came up with a similar solution, except I called my components "Attributes" and "Behaviors". This approach of separating types of components has worked very nicely for me.

Regarding the solution:
The code is easy to use, but the implementation might be hard to follow if you're not experienced with C++. So...

The desired interface

What I did is to have a central repository of all components. Each component type is mapped to a certain string (which represents the component name). This is how you use the system:

// Every time you write a new component class you have to register it.
// For that you use the `COMPONENT_REGISTER` macro.
class RenderingComponent : public Component
{
    // Bla, bla
};
COMPONENT_REGISTER(RenderingComponent, "RenderingComponent")

int main()
{
    // To then create an instance of a registered component all you have
    // to do is call the `create` function like so...
    Component* comp = component::create("RenderingComponent");

    // I found that if you have a special `create` function that returns a
    // pointer, it's best to have a corresponding `destroy` function
    // instead of using `delete` directly.
    component::destroy(comp);
}

The implementation

The implementation is not that bad, but it's still pretty complex; it requires some knowledge of templates and function pointers.

The header file

#include <map>
#include <string>


class Component
{
};


namespace component
{    
    Component* create(const std::string& name);
    void destroy(const Component* comp);

    // This namespace contains implementation details.
    namespace detail
    {
        template<class T>
        Component* createComponent()
        {
            return new T;
        }

        typedef std::map<std::string, Component* (*)()> ComponentRegistry;
        ComponentRegistry& getComponentRegistry();

        template<class T>
        struct RegistryEntry
        {
            RegistryEntry(const std::string& name)
            {
                ComponentRegistry& reg = getComponentRegistry();
                reg[name] = createComponent<T>;
            }
        };

    } // namespace detail

} // namespace component


#define COMPONENT_REGISTER(TYPE, NAME) \
    namespace { \
        static const component::detail::RegistryEntry<TYPE> reg_ent_##TYPE(NAME); \
    }

The source file

#include "component.h"
#include <string>

namespace component 
{
    namespace detail
    {
        ComponentRegistry& getComponentRegistry()
        {
            static ComponentRegistry reg;
            return reg;
        }
    }


    Component* create(const std::string& name)
    {
        detail::ComponentRegistry& reg = detail::getComponentRegistry();
        detail::ComponentRegistry::iterator it = reg.find(name);

        if (it == reg.end()) {
            // This happens when there is no component registered to this
            // name. Here I return a null pointer, but you can handle this
            // error differently if it suits you better.
            return 0;
        }

        return it->second();
    }

    void destroy(const Component* comp)
    {
        delete comp;
    }

} // namespace component

Extending with Lua

I should note that with a bit of work (it's not very hard), this can be used to seamlessly work with components defined in either C++ or Lua, without ever having to think about it.

It seems like what you want is a factory.

http://en.wikipedia.org/wiki/Factory_method_pattern

What you can do is have your various components register with the factory what name they correspond to, and then you have some map of string identifier to constructor method signature to generate your components.