C++ (Qt)
void QPixmapDropShadowFilter::draw(QPainter *p,
                                   const QPointF &pos,
                                   const QPixmap &px,
                                   const QRectF &src) const
{
    Q_D(const QPixmapDropShadowFilter);
 
    if (px.isNull())
        return;
 
    QImage tmp(px.size(), QImage::Format_ARGB32_Premultiplied);
    tmp.setDevicePixelRatio(px.devicePixelRatioF());
    tmp.fill(0);
    QPainter tmpPainter(&tmp);
    tmpPainter.setCompositionMode(QPainter::CompositionMode_Source);
    tmpPainter.drawPixmap(d->offset, px);
    tmpPainter.end();
 
    // blur the alpha channel
    QImage blurred(tmp.size(), QImage::Format_ARGB32_Premultiplied);
    blurred.setDevicePixelRatio(px.devicePixelRatioF());
    blurred.fill(0);
    QPainter blurPainter(&blurred);
    qt_blurImage(&blurPainter, tmp, d->radius, false, true);
    blurPainter.end();
 
    tmp = blurred;
 
    // blacken the image...
    tmpPainter.begin(&tmp);
    tmpPainter.setCompositionMode(QPainter::CompositionMode_SourceIn);
    tmpPainter.fillRect(tmp.rect(), d->color);
    tmpPainter.end();
 
    // draw the blurred drop shadow...
    p->drawImage(pos, tmp);
 
    // Draw the actual pixmap...
    p->drawPixmap(pos, px, src);
}
 

C++ (Qt)
void MainWindow::on_pushButton_begin_clicked()
{
QProcess process;
QStringList strListKey;
strListKey << "track01.wav track02.wav result.wav";
 
process.start(QDir::currentPath() + "/SoX-Sound_eXchange/sox.exe", strListKey);
process.waitForFinished(-1);
}

C++ (Qt)
strListKey << "track01.wav track02.wav result.wav";
 

C++ (Qt)
strListKey << "track01.wav" << "track02.wav" << "result.wav";
 

C++ (Qt)
#include <QCoreApplication>
#include <QThread>
#include <QTimer>
#include <QDebug>
 
class Worker : public QObject {
    Q_OBJECT
public:
    Worker(QObject *parent = 0) : QObject(parent), mTimer(0) {}
    ~Worker() { qDebug() << Q_FUNC_INFO; }
 
    Q_INVOKABLE void start() {
        // для того, что бы создать таймер в контексте потока, в который перемещён
        // воркер, используем QMetaObject::invokeMethod
        if (QThread::currentThread() != thread()) {
            QMetaObject::invokeMethod(this, "start", Qt::QueuedConnection);
            return;
        }
        mTimer = new QTimer(this);
        connect(mTimer, &QTimer::timeout,
                this, &Worker::onTimeout);
        mTimer->start(1000);
    }
 
signals:
    void timeout();
 
private:
    void onTimeout() {
        qDebug() << "worker" << QThread::currentThreadId();
        emit timeout();
    }
 
private:
    QTimer *mTimer;
 
};
 
class Test : public QObject
{
    Q_OBJECT
public:
    Test(QObject *parent = 0) :
        QObject(parent),
    mWorker(new Worker())
    {
    connect(mWorker, &Worker::timeout,
            this, &Test::onTimeout,
            Qt::QueuedConnection);
    }
    ~Test()
    {
        // планируем удаление воркера
        mWorker->deleteLater();
        if (mThread.isRunning()) {
            // рубим поток
            mThread.quit();
            // даём время уничтожится воркеру
            mThread.wait();
        }
        qDebug() << Q_FUNC_INFO;
    }
 
    void start() {
        // перемещаем воркер в отдельный поток
        mWorker->moveToThread(&mThread);
        // стратуем поток
        mThread.start();
        // и воркер
        mWorker->start();
        // планируем через 5 секунд выход из тестового приложения
        QTimer::singleShot(5000, this, &Test::onQuitTimeout);
    }
 
 
    void onTimeout() {
        qDebug() << "test" << QThread::currentThreadId();
    }
 
    void onQuitTimeout() {
        qApp->quit();
    }
 
private:
    QThread mThread;
    Worker *mWorker;
 
};
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
 
    Test t;
    t.start();
 
    return a.exec();
}
 
#include "main.moc"
 
 

C++ (Qt)
#include <QCoreApplication>
 
#include <QDebug>
#include <QVector>
#include <QtConcurrent>
 
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    QVector<int> vector;
    // Для примера массив 10 миллионов значений
    vector.resize(10000000);
    QList<QFuture<void>> results;
    for (int i = 0; i < 10; ++i) {
        // Получаем указатель на нужный блок
        int *data = vector.data() + i * 1000000;
        // запускаем в отдельных потоках заполнялку, указываем лямбде адрес начала блока и его длинну
        auto result = QtConcurrent::run([i](int *data, const size_t size) {
            for (int i = 0; i < size; ++i) {
                *(data++) = qrand();
            }
            // для отладки выводим на экран номер заполненного блока
            qDebug() << i;
        }, data, 1000000);
        // нужно для ожидания окончания заполнения массива
        results.append(result);
    }
 
    // ждем завершение заполнения массива
    for (auto &f : results) {
        f.waitForFinished();
    }
 
    qDebug() << "end";
 
    return 0;
}