QThread Char array destroyed after passing between two threads - c++

Question

I have implemented a class in Qt to receive char inputs and filter them and return meaningful char arrays to me, and also this is done in a different thread than the original thread.
Here's the header file:
class WorkerThread : public QObject
{
Q_OBJECT
QThread highspeedthread;
int bufferCounter=0;
public:
char buffer[260];
WorkerThread();
public slots:
void doWork(char parameter); // This is the function to do the filtering
signals:
void resultReady(char*); // Signal for when the result is made, It gets connected to HighspeedProcessor::handleresult
};
class HighspeedProcessor : public QObject
{
Q_OBJECT
QThread highspeedthread;
public:
HighspeedProcessor();
signals:
void process(char); // This is the function from which the cycle starts
public slots:
void handleResult(char*); // This gets the results back
};
And here's the definitions:
void WorkerThread::doWork(char parameter)
{
buffer[bufferCounter] = parameter;
// Filters the input and fills the buffer
// Code omitted for easement
// ...
qDebug()<<"Before: "<<buffer;
emit resultReady(buffer); // Pass the buffer to HighspeedProcessor::handleResult
}
HighspeedProcessor::HighspeedProcessor() {
WorkerThread *worker = new WorkerThread;
worker->moveToThread(&highspeedthread);
connect(this, SIGNAL(process(char)), worker, SLOT(doWork(char)));
connect(worker,SIGNAL(resultReady(char*)), this,SLOT(handleResult(char*)));
highspeedthread.start();
}
void HighspeedProcessor::handleResult(char *parameter)
{
qDebug()<<"After: "<<parameter;
}
The WorkerThread is doing its work just fine and filters results flawlessly, but problem is that when the result is passed to the HighspeedProcessor class, the char array gets mixed up. The result is as shown below:
Before: $CMDgFlushing FIFO
After: $CMDgFlushing FIFO�:�"��ά!���j�D��#�/�]%�i�����Rր�������y�r��<�F��!]�uh����q�=S�ߠ�"�M�d
Before: $CMDgFlushing FIFO
After: $CMDgFlushing FIFO
Before: $CMDgFlushing FIFO
After: $CMDgFlushing ��o���kj���q�9 ����^ou����
And by the way this is not happening so frequently, meaning only once out of almost 100 times it gets mixed up and other times it's ok. Also the rate of input data is almost 1Mb/s. Am I doing something wrong?
EDIT: This was already happening before I used qDebug in my code. So, it's not the result of using qDebug.

Answer 1

Your mistakes:
Your are using the buffer in two different threads, but are passing
only a pointer to it, it is pointless.
Don't protect a reading/writing to the buffer
You don't need even to use any thread-safe exchange buffer, you simply can pass a QByteArray as a parameter between threads through signals-slots.
For example:
QByteArray buffer;
//...
signals:
void resultReady(QByteArray);
//...
void WorkerThread::doWork(char parameter)
{
buffer[bufferCounter] = parameter;
//...
emit resultReady(buffer);
}
void HighspeedProcessor::handleResult(QByteArray parameter)
{
qDebug() << "After: "<< parameter;
}

Answer 2

Changing my char* variables to QByteArray solved my problem. Somehow there was some conflict happening between the two threads that used the same pointer for buffer.