Qt Linux memory leaks

#ifndef PARSER_H
#define PARSER_H

#include <iostream>

#include <QObject>
#include <QList>

#include <QtConcurrent>
#include <QFutureWatcher>

#include "ParserTask.h"

class Parser : public QObject
{
    Q_OBJECT
public:
    Parser(QObject *parent = nullptr)
        : QObject(parent), m_maxThreads(2)
    {}

public slots:
    void appendTask() {
        m_tasksQueue.append(new ParserTask());
        tryStart();
    }

    void taskFinished() {
        auto watcher = static_cast<QFutureWatcher<ParserTask *> *>(QObject::sender());
        std::cout << "PARSED" << std::endl;

        m_currentRunningTasks.removeAll(watcher->result());

        delete watcher->result();
        delete watcher;

        tryStart();
    }

private:
    void tryStart() {
        while(m_currentRunningTasks.size() < m_maxThreads && !m_tasksQueue.isEmpty()) {
            ParserTask* task = m_tasksQueue.takeFirst();
            m_currentRunningTasks.append(task);

            auto watcher = new QFutureWatcher<ParserTask *>(this);
            QObject::connect(watcher, SIGNAL(finished()), SLOT(taskFinished()));
            auto future = QtConcurrent::run(task, &ParserTask::run);
            watcher->setFuture(future);
        }
    }

private:
    int                 m_maxThreads;

    QList<ParserTask *> m_tasksQueue;
    QList<ParserTask *> m_currentRunningTasks;
};

#endif // PARSER_H

#ifndef PARSERTASK_H
#define PARSERTASK_H

#include <QList>
#include <QString>

class ParserTask
{
public:
    struct LineParseResult { QString article, brand, price, stock, multiplicity, __article, price_id; };
    typedef QList<LineParseResult> PResult;

    ParserTask()
    {}

    ~ParserTask() {}
    inline const PResult& result() const       { return m_result;   }

public:
    ParserTask* run() {
        for(int i = 0; i < 700000; i++) {
            LineParseResult r;
            r.article = "111111111111111111";
            r.brand = "2222222222222222222";
            r.multiplicity = "33333333333333";
            r.price = "4444444444444444";
            r.price_id = "55555555555555";
            r.stock = "666666666666666";
            r.__article = "7777777777777777";

            m_result.append(r);
        }

        return this;
    }

private:
    PResult                  m_result;
};

#endif // PARSERTASK_H

#include <QCoreApplication>

#include "Parser.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Parser p;
    p.appendTask();
    p.appendTask();
    p.appendTask();

    return a.exec();
}

#include <QCoreApplication>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    QList<QString> list;
    for(int i = 0; i < 14000000; i++)
        list.append("11111111");
    list.clear();

    return a.exec();
}

#include <list>
#include <string>
#include <unistd.h>

int main(int argc, char* argv[]) {

    std::list<std::string> list;

    for(int i = 0; i < 14000000; i++)
        list.push_back("111111111");
    list.clear();

    sleep(10000);
    return 0;
}

std::vector<int> v;
//v is swapped with its temporary copy, which is capacity optimal
std::vector<int>(v).swap(v);

#include <vector>
#include <string>
#include <unistd.h>

int main(int argc, char* argv[]) {

    std::vector<std::string> list;

    for(int i = 0; i < 14000000; i++)
        list.push_back("111111111");
    list.clear();
    list.shrink_to_fit();

    sleep(10000);
    return 0;
}

#include <vector>
#include <string>
#include <unistd.h>

int main(int argc, char* argv[]) {

    std::vector<std::string> list;

    for(int i = 0; i < 14000000; i++)
        list.push_back("111111111");
    list.clear();
    list = std::vector<std::string>();

    sleep(10000);
    return 0;
}

#include <unistd.h>
#include <time.h>
#include <vector>
#include <string>

class ShrinkToFitTest {
public:
    ShrinkToFitTest() {
        for(int i = 0; i < 7000000; i++)
            m_list.push_back("111111111111111111");
    }

    ~ShrinkToFitTest() {
        m_list.clear();
        m_list.shrink_to_fit();
    }

private:
    std::vector<std::string> m_list;
};

int main(int argc, char* argv[]) {
    ShrinkToFitTest *a = new ShrinkToFitTest();
    delete a;

    sleep(10000);
    return 0;
}

#include <vector>
#include <string>
#include <unistd.h>

int main(int argc, char* argv[]) {

    std::vector<std::string> list;

    for(int i = 0; i < 14000000; i++)
        list.push_back("111111111");
    list.clear();
    list = std::vector<std::string>();

    sleep(10000);
    return 0;
}