Поясните принцип работы паттерна "абстрактная фабрика"

#include <iostream>
 
class ICar // AbstractProductA
{
public:
    virtual void printName() = 0;
    virtual ~ICar() {}
};
 
class Ford: public ICar // ConcreteProductA1
{
public:
    virtual void printName()
    {
        std::cout << "Ford" << std::endl;
    }
};
 
class Toyota: public ICar // ConcreteProductA2
{
public:
    virtual void printName()
    {
        std::cout << "Toyota" << std::endl;
    }
};
 
class IEngine // AbstractProductB
{
public:
    virtual void printPower() = 0;
    virtual ~IEngine(){}
};
 
class FordEngine: public IEngine // ConcreteProductB1
{
public:
    virtual void printPower()
    {
        std::cout << "Ford Engine 4.4" << std::endl;
    }
};
 
class ToyotaEngine: public IEngine // ConcreteProductB2
{
public:
    virtual void printPower()
    {
        std::cout << "Toyota Engine 3.2" << std::endl;
    }
};
 
class ICarFactory // AbstractFactory
{
public:
    virtual ICar*    createCar()    const = 0;
    virtual IEngine* createEngine() const = 0;
};
 
class FordFactory: public ICarFactory // ConcreteFactory1
{
public:
 
    virtual ICar* createCar() const // from ICarFactory
    {
        return new Ford();
    }
 
    virtual IEngine* createEngine() const
    {
        return new FordEngine();
    }
};
 
class ToyotaFactory: public ICarFactory // ConcreteFactory2
{
public:
    virtual ICar* createCar() const // from ICarFactory
    {
        return new Toyota();
    }
 
    virtual IEngine* createEngine() const
    {
        return new ToyotaEngine();
    }
};
 
void use(const ICarFactory& f)
{
    ICar*     myCar     =  f.createCar();
    IEngine*  myEngine  =  f.createEngine();
 
    myCar->printName();
    myEngine->printPower();
 
    delete myCar;
    delete myEngine;
}
 
 
int main(){
    ToyotaFactory       toyotaFactory;
    FordFactory fordFactory;
 
    use (toyotaFactory);
    use (fordFactory);
 
    return 0;
}