Metoda wytwórcza - wzorzec projektowy

Mam problem z implementacja wzorca Metody wytwórczej. Choodzi o to, że nie rozumiem co funkcja wirtualna w klasie Factory powinna zwracać, tak aby była uniwersalna:

#include <string.h>
#include <iostream>

class Vehicle {
	public:
		virtual void getName(void) = 0;
};

class Car : public Vehicle 
{
	private:
		std::string name;
	public:
		Car(std::string n) {
			name = n;	
		}
		
		void getName(void) {
			std::cout << "This car is: " << name << std::endl;
		}
};

class Bicykle : public Vehicle 
{
		private:
		std::string name;
	public:
		Bicykle(std::string n) {
			name = n;
		}
		
		void getName(void) {
			std::cout << "This bicykle is: " << name << std::endl;
		}
};


class Factory {
	public:
		virtual Vehicle create(std::string n) = 0; //Vehicle nie może zwracać, ale Car i Bicykle też nie powinna bo nie będzie uniwersalna
};

class CarFactory : public Factory  {
	
	public:
		Car create(std::string n) { //i tutaj
			return new Car(n);
		}
};

class BicykleFactory : public Factory  {
	
	public:
		Bicykle create(std::string n) {  //...i tutaj
			return new Car(n);
		}	
};

int main(void) {
	
	
	return 0;
}

musi zwracać jakis wskaźnik. Np tak:

class VehicleFactory {
    public:
        virtual ~VehicleFactory() {}
        virtual std::unique_ptr<Vehicle> create(std::string n) = 0;
};

// albo tak
class VehicleFactory {
    public:
        virtual ~VehicleFactory() {}
        virtual std::shared_ptr<Vehicle> create(std::string n) = 0;
};

Poza tym interface musi mieć pusty wirtualny destruktor:

class Vehicle {
    public:
        virtual ~Vehicle() {}
        virtual void getName(void) = 0;
};

Tak może wyglądać factory w C++14:

class VehicleFactoryImpl : public VehicleFactory {
public:
        override std::shared_ptr<Vehicle> create(std::string n) {
             static const auto porshe = "Porsche"s;
             static const auto giant = "Giant"s;

             if (std::equal(std::begin(porshe), std::end(porshe), std::begin(n)))
                   return std::make_shared<Car>(std::move(n));

             if (std::equal(std::begin(giant), std::end(giant), std::begin(n)))
                   return std::make_shared<Bicykle>(std::move(n));
             … … …
        }
};

TLDR "Metoda wytworcza"? A nie "fabryczna"?