ich befasse mich zur Zeit mit dem Thema IPC über shared memory.
Um einen Einstieg zu finden, habe ich mir auch einfache client/server Programme mit boost und Qt 4.8 Untersützung geschrieben.
Die funktionieren soweit auch, solange das darunterliegende Framework gleich ist.
Also boost client <-> boost server
und Qt client <-> Qt server
funktionieren einwandfrei.

Nun möchte ich meinen boost server mit meinem Qt client kommunizieren lassen. Und an diesem Punkt scheitere ich.
Was hab ich übersehen, bzw. was muss ich am Quellcode ändern, damit das funktioniert?

Grüße,
Vic

Anhang:
Boost server:

#include <boost/interprocess/shared_memory_object.hpp>
#include <boost/interprocess/windows_shared_memory.hpp> 
#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>  
#include <iostream> 
#include <string>

int main(int argc, char** argv) 
{
	const std::string key = "SharedMemoryTest";
	boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_or_create, key.c_str(), boost::interprocess::read_write); 
	//boost::interprocess::windows_shared_memory shdmem(boost::interprocess::open_or_create, "Shared Memory Test", boost::interprocess::read_write); 
	shdmem.truncate(1024); 
	boost::interprocess::mapped_region region(shdmem, boost::interprocess::read_write); 
	boost::interprocess::named_mutex named_mtx(boost::interprocess::open_or_create, "mtx");
	const std::string content = "This is boost content";

	char* pOrigin = static_cast<char*>(region.get_address());
	strcpy(pOrigin, content.c_str()); 

	system("pause");

	bool removed = boost::interprocess::shared_memory_object::remove(key.c_str());		
	return 0;
}

Boost client:

#include <boost/interprocess/shared_memory_object.hpp> 
#include <boost/interprocess/mapped_region.hpp>
#include <boost/interprocess/sync/named_mutex.hpp>  
#include <iostream> 
#include <string>

int main(int argc, char** argv) 
{
	try {
		const std::string key = "SharedMemoryTest";
		boost::interprocess::shared_memory_object shdmem(boost::interprocess::open_only, key.c_str(), boost::interprocess::read_write); 
		boost::interprocess::mapped_region region(shdmem, boost::interprocess::read_write);    
		boost::interprocess::named_mutex named_mtx(boost::interprocess::open_or_create, "mtx");

		char* pOrigin = static_cast<char*>(region.get_address());

		std::cout << "Shared Memory content:" << std::endl;
		std::cout << pOrigin;
	} catch (boost::interprocess::interprocess_exception &e) {
		std::cerr << e.what() << std::endl;
	}
	return 0;
}

QT server:

#include <QtCore/QCoreApplication>
#include <QtCore/QSharedMemory>
#include <QtCore/QBuffer>
#include <QtCore/QDataStream>
#include <iostream>

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

	QString key = QString::fromStdString("SharedMemoryTest");
	QSharedMemory sharedMemory(key);
	sharedMemory.setNativeKey(key);
	QBuffer buffer;

	buffer.open(QBuffer::ReadWrite);
	QDataStream out(&buffer);

	out << "This is QT content";
	int size = buffer.size();

	if (!sharedMemory.create(size)) {
         std::cerr << "Unable to create shared memory" << std::endl;
    } else {
		sharedMemory.lock();
		char *pSharedMemoryOrigin = (char*)sharedMemory.data();
		const char *pDataToShare = buffer.data().data();

		memcpy(pSharedMemoryOrigin, pDataToShare, qMin(sharedMemory.size(), size));
		sharedMemory.unlock();
	}

	return a.exec();
}

QT client:

#include <QtCore/QCoreApplication>
#include <QtCore/QSharedMemory>
#include <QtCore/QBuffer>
#include <QtCore/QDataStream>
#include <iostream>

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

	QString key = QString::fromStdString("SharedMemoryTest");
	QSharedMemory sharedMemory;
	sharedMemory.setNativeKey(key);
	bool attached = sharedMemory.attach(QSharedMemory::ReadOnly);
	if (!attached) {
		std::cerr << "Unable to attach shared memory" << std::endl;
		std::cerr << sharedMemory.errorString().toStdString();
	} else {
		QBuffer buffer;
		QDataStream in(&buffer);
		char* pContent = 0;

		sharedMemory.lock();
		int sharedMemSize = sharedMemory.size();
		pContent = new char[sharedMemSize];
		buffer.setData((char*)sharedMemory.constData(), sharedMemSize);
		buffer.open(QBuffer::ReadOnly);
		in >> pContent;
		sharedMemory.unlock();

		std::cout << "Shared memory content:" << std::endl;
		std::cout << pContent;

		delete pContent;
	}

	return a.exec();
}

Und da es sich um lauffähigen Code handelt, können auch andere Neulinge von diesen Beispielen lernen.

Wenn du dich nicht mit diesem Thema beschäftigen möchtest, dann sei es so. Aber solche unqualifizierten Kommentare kannst du dir sparen.
Und jetzt zurück zum Thema.