Qt Cannot append multiple file data to one

Question

I have this program, I wanted to send the data of multiple files into a single file using a loop, but this doesn't seem to work properly.

void MainWindow::on_pushButton_clicked()
{
    FILE *fp1,*fp2;
    char ch;
    QString str="test"+i+".txt";
    QString qString1 =str.toUtf8();
    QByteArray byteArray = qString1.toUtf8();

    const char* fname1 = byteArray.constData();
    if(QFile::exists("test0.txt"))
    fp1=fopen(fname1,"r");
    fp2=fopen("CheckoutReport.txt","a");
    do
    {
        ch=fgetc(fp1);
        fputc(ch,fp2);
    }
    while(ch!=EOF);
    fcloseall();
}

Answer 1

There's several problems:

1. You've got both C++ and Qt, use QFile, don't use naked C files!

2. qString1 is a poor-man's copy of str, so what's the point of that?

3. Copying files character-by-character performs rather poorly.

4. You do not want to block your GUI while doing file operations, in general. They should be done in a separate thread.

Below is one example of how it could be done. I've strived to fully leverage what Qt has to offer, while keeping it QWidget-based. This is a self-contained, single-file example, simply add it as the lone file to a qt guy project in Qt Creator, then build and run. Remember that this code will open files in its current working directory!

The cost of using another thread in terms of code complexity is literally 6 lines. If you don't care for using a separate file-access thread and are OK with your UI being blocked by potentially slow files on the network etc., then the following 6 lines can be removed without any other changes in the code. That's the beauty of Qt.

QThread * m_thread;
w->moveToThread(m_thread);
m_thread(new QThread(this)),
m_thread->start();
m_thread->exit();
m_thread->wait();

Without the thread in place, you could also replace QMetaObject::invokeMethod(w, "joinFiles"); with a simpler w->joinFiles(). The reason for using invokeMethod instead of a direct call is to invoke the slot in the thread where the object is running. invokeMethod will, behind the scenes, post a QMetaCallEvent to the worker object. This event will be picked up by the event loop running in the thread, and will result in a call to worker's joinFiles slot, executed within the correct thread - worker->thread().

Note that I'm not deriving from QThread, and that only one thread is used for all file operations. This is perfectly adequate if your starting point is to have all file accesses done in the GUI thread. That way there are two threads: one that only does GUI, and another that only does serialized file accesses.

#include <QWidget>
#include <QPushButton>
#include <QPlainTextEdit>
#include <QLineEdit>
#include <QSpinBox>
#include <QLabel>
#include <QFormLayout>
#include <QMetaObject>
#include <QFile>
#include <QDir>
#include <QThread>
#include <QApplication>

class Worker : public QObject {
    Q_OBJECT
    Q_PROPERTY(int fileIndex READ fileIndex WRITE setFileIndex)
    Q_PROPERTY(QString sourceFileName READ sourceFileName)
    Q_PROPERTY(QString targetFileName READ targetFileName WRITE setTargetFileName)
    int m_fileIndex;
    QString m_targetFileName;
public:
    Worker(int fileIndex, QString targetFileName, QObject * parent = 0) :
        QObject(parent), m_fileIndex(fileIndex), m_targetFileName(targetFileName) {}
    explicit Worker(QObject * parent = 0) : QObject(parent), m_fileIndex(0) {}
    Q_SIGNAL void filesJoined(bool OK);
    Q_SLOT void joinFiles() {
        QFile src(sourceFileName());
        QFile dst(m_targetFileName);
        if (! src.open(QIODevice::ReadOnly)
            || ! dst.open(QIODevice::Append))
        {
            emit filesJoined(false);
            return;
        }
        while (! src.atEnd()) {
            dst.write(src.read(16384));
        }
        emit filesJoined(true);
    }
    int fileIndex() const { return m_fileIndex; }
    void setFileIndex(int i) { m_fileIndex = i; }
    QString sourceFileName() const { return QString("test%1.txt").arg(m_fileIndex); }
    QString targetFileName() const { return m_targetFileName; }
    void setTargetFileName(const QString & n) { m_targetFileName = n; }
};

class Window : public QWidget {
    Q_OBJECT
    QThread * m_thread;
    QSpinBox * m_index;
    QLineEdit * m_target;
    QPlainTextEdit * m_log;
    Q_SLOT void on_pushButton_clicked() {
        Worker * w = new Worker;
        w->setFileIndex(m_index->value());
        w->setTargetFileName(m_target->text());
        w->moveToThread(m_thread);
        connect(w, SIGNAL(filesJoined(bool)), SLOT(onJoined(bool)));
        QMetaObject::invokeMethod(w, "joinFiles");
    }
    Q_SLOT void onJoined(bool ok) {
        const Worker * w = qobject_cast<const Worker*>(sender());
        m_log->appendPlainText(QString("%1 %2 to %3")
                               .arg(ok ? "Successfully joined" : "Couldn't join")
                               .arg(w->sourceFileName()).arg(w->targetFileName()));
        sender()->deleteLater();
    }
public:
    Window(QWidget * parent = 0) :
        QWidget(parent),
        m_thread(new QThread(this)),
        m_index(new QSpinBox),
        m_target(new QLineEdit),
        m_log(new QPlainTextEdit)
    {
        QFormLayout * layout = new QFormLayout(this);
        QPushButton * button = new QPushButton("Join Files");
        button->setObjectName("pushButton");
        layout->addRow("File Index", m_index);
        layout->addRow("Append to File Name", m_target);
        layout->addRow(button);
        layout->addRow(m_log);
        QMetaObject::connectSlotsByName(this);
        m_thread->start();
        m_log->appendPlainText(QString("Current directory: %1").arg(QDir::currentPath()));
    }
    ~Window() {
        m_thread->exit();
        m_thread->wait();
    }
};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Window w;
    w.show();
    return a.exec();
}

#include "main.moc"