Стратегия выделения/освобождения памяти

static Bitmap IoBmp::open(/*...*/) {
    //...
    return Bitmap(/*...*/);
}

static Bitmap* IoBmp::open(/*...*/) {
    //...
    return new Bitmap(/*...*/);
}

void Bitmap::free() {
    delete this;
}

Bitmap* bmp = IoBmp::open(fileName); //IoBmp знает как выделена память
bmp->free(); //Bitmap знает как ее освободить. внешней программе пофиг,но все равно нехорошо как-то

static void IoBmp::free(Bitmap* bmp) {
    delete bmp;
}
Bitmap* bmp = IoBmp::open(fileName);
IoBmp::free(bmp);

static size_t IoBmp::getSize(const std::string &fileName);
static void IoBmp::open(Bitmap* bmp, const std::string &fileName);
Bitmap* bmp = new Bitmap(IoBmp::getSize(fileName)); //выделяем память под битмап по данным из файла
IoBmp::open(bmp, fileName); //читаем из файла растр
delete bmp;

class abstract_image
{
public:
    virtual ~abstract_image(){}
    virtual int height()const=0;//высота
    virtual int width()const=0;//ширина
    virtual int color(int x,int y)const=0;//цвет конкретной точки
};

using BitmapPtr = std::unique_ptr<Bitmap>;
//...
static Bitmap* IoBmp::open(/*...*/) {
    //...
    return new Bitmap(/*...*/);
}
//....
BitmapPtr bmp(IoBmp::open(/*...*/));
// работаем с bmp как с обычным указателем
bmp->Draw(device);
// Память автоматически освобождается

static std::unique_ptr< Bitmap > IoBmp::open(/*...*/);

#include <iostream>
#include <string>
#include <memory>
 
struct IImage
{
    //virtual ~IImage(){}
    
    
    // обратите внимание: диструктор базового класса не виртуальный
    // в обычной жизни это может привести к UB 
    // (потерям ресурсов, утечкам памяти, крашам, и тп)
    
    // но в нашем случае, тем не менее все отработает, как часики
    // скажем спасибо смартпоинтерам
    ~IImage(){}
    
    virtual const char* AboutMe()const = 0;
};
 
 
struct Png: IImage
{
    Png(){ std::cout<<"Png was created\n"; }
    
    ~Png() { std::cout<<"Png was destroyed\n"; }
    
    virtual const char* AboutMe()const  { return "PNG"; }
};
 
 
struct Custom: IImage
{
    Custom(){ std::cout<<"Custom was created\n"; }
    
    ~Custom() { std::cout<<"Custom was destroyed\n"; }
    
    virtual const char* AboutMe()const  { return "Custom"; }
};
    
 
struct FactoryImage
{
    typedef std::shared_ptr<IImage>
        Image;
    
    static Image Load(const char* filename)
    {
        const std::string file = filename;
        
        if(file.find(".png")!=std::string::npos)
           return std::make_shared<Png>();
        
        return std::make_shared<Custom>();
    }
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    // обратите внимание:
    // вызывающая сторона сама лично не захватывала ресурсы
    // и поэтому не несет отвественность за их освобождение
    
    // грузим png
    const auto bitmap1 = FactoryImage::Load("example.png");
    std::cout<<"resource = "<< bitmap1->AboutMe() << std::endl;
    
    // грузим custom
    const auto bitmap2 = FactoryImage::Load("example.custom");
    std::cout<<"resource = "<< bitmap2->AboutMe() << std::endl;
    
    
    // тем не менее, все ресурсы будут корректно освобождены
    // за это отвечает тот, кто их выделял - фабрика
    // она сама подготавливает "правильные" смарты
    // которые позаботся о корректном освобождении.
    
    // после этой надписи наша программа завершается
    // и мы должны увидеть запуски диструкторов
    // всех захваченных фабрикой ресурсов
    std::cout<<"[Work completed] expect to release all resources...\n";
    
    // таким образом реализуется правило "кто ресурс захватывал, тот его и освобождает"
        
}

#include <iostream>
#include <cassert>
#include <string>
#include <memory>
#include <map>
 
//--- интерфейс ресурса
struct IImage
{
    virtual ~IImage(){}
    virtual const char* AboutMe()const = 0;
};
 
// --- ресурс
struct Png: IImage
{
    Png() { std::cout<<"Png was created\n";   }
   ~Png() { 
std::cout<<"Png was destroyed\n"; 
}
    virtual const char* AboutMe()const { return "PNG"; }
};
 
// --- ресурс
struct Custom: IImage
{
    Custom() { std::cout << "Custom was created\n";   }
   ~Custom() { std::cout << "Custom was destroyed\n"; }
    virtual const char* AboutMe()const { return "Custom"; }
};
    
// --- ядро системы, контролирует ресурсы
struct Core
{
    typedef std::shared_ptr<IImage>
        Image;
    
    // --- подсистемы обычно - сингелтоны
    // данный метод не оч красиво оформлен
    // но для данной иллюстрации сойдет
    static Image Load(const char* filename)
    {
        static Core c;
        return c.CreateResource(filename);
    }
private:    
    typedef std::shared_ptr<IImage>
        Res;
    typedef std::map<Res, bool>    
        Resources;
 
    ~Core()
    {
        // --- при уничтожении системы, 
        // она сама позаботится о своих оставшихся ресурсах
        // и никто, кроме неё не знает, 
        // как это правильно сделать.
        // и вообще, не должен об этом думать
        std::cout<<"[SYSTEM] list resources:\n";
        for(const auto& i: mResources)
            std::cout
                << " [RESOURCE] " << i.first->AboutMe()
                << " : status = " << (i.second? "enabled\n" : "disabled\n");
 
        std::cout<<"[SYSTEM] deactivate...\n";
    }
    
    Image CreateResource(const char* filename)
    {
        // --- обратите внимание:
        // смарт, который получает вызывающая сторона 
        // не контролирует время жизни ресурса
        // пользователю будет доступен интерфейс ресурса
        // но он никак не сможет уничтожить сам ресурс 
        // в обход системы, которая на самом деле
        // является единственным (монопольным) 
        // владельцем ресурса.
 
        // когда снаружи у смартов не останется потребителей
        // то последний оставшийся в живых просигналит системе
        // о том, что ресурс снаружи больше никому не нужен
        // дальнейшая судьба ресурса полностью на усмотрение самой системы
        // в данном примере-иллюстрации система не будет уничтожать ресурсы
        // а будет лишь помечать их как "освободившиеся".
 
        // функтор будет запущен внешними смартами,
        // когда у ресурса не останется потребителей
        // запуск функтора будет сигналом о том, 
        // что ресурс можно освободить
        const auto deletter 
            =  [this](IImage* res){ Free(res); };
 
        // физически ресурс живет в потрохах системы
        // и не допступен снаружи
        const auto pair_ 
            = mResources.emplace(std::move(Make(filename)), true);
 
        const auto& res 
            = pair_.first->first;
        
        std::cout<<"[SYSTEM] create resource: '" 
            << res->AboutMe() <<"'\n";
 
        // выдаваемый наружу смарт может лишь 
        // предоставить доступ к интерфейсу ресурса
        // но не контролирует время жизни самого ресурса
        // он лишь просигналит системе о том, 
        // что у ресурса больше нет потребителей
        return Image(res.get(), deletter);
    }
 
    // захват реального ресурса.
    // приватный метод, только для служебного пользования
    static Res Make(const char* filename)
    {
        const std::string file = filename;
        if(file.find(".png") != std::string::npos)
            return Res(new Png); 
 
        return Res(new Custom); 
    }
    
    // только для служебного пользования
    // когда смарт снаружи просигналит об отсутствии потребителей
    // запуститься этот метод
    void Free(IImage* res)
    {
        std::cout
            << "[SYSTEM] detected free resource: '"
            << res->AboutMe()<<"'\n";
        
        // здесь мы можем сделать с ресурсом все, что захотим.
        // можем убить его. или переиспользовать.
        // зависит от задачи и от фантазии.
 
        // в данном примере, 
        // ресурс просто помечается как "не занятый".
        Res key(res, [](IImage*){});
        auto it = mResources.find(key);
        assert(it!=mResources.end());
        it->second = false;
    }
    
    Resources mResources;
    
};
 
 
 
int main()
{
    std::cout << "Hello, world!\n";
    
    
    // грузим png
    const auto bitmap1 = Core::Load("example.png");
    std::cout<<"resource = "<< bitmap1->AboutMe() << std::endl;
    
    // грузим custom
    const auto bitmap2 = Core::Load("example.custom");
    std::cout<<"resource = "<< bitmap2->AboutMe() << std::endl;
    
    std::cout<<"[Work completed] expect to release all resources...\n";
    
}

shared_ptr< Bitmap > bmp1 = shared_ptr< Bitmap >(new Bitmap());
shared_ptr< Bitmap > bmp2 = make_shared< Bitmap >(); // на некоторых ресурсах пишут что так быстрее и безопаснее (интересно как это реализовано)