Probleme mit Boost: Interprozess Shared Memory

Question

Ich habe Probleme beim Implementieren Boost/Interprozess-Bibliothek für Shared Memory-Operationen zwischen zwei Programmen. Dies ist das erste, das ich Shared Memory-Operationen verwendet habe, und ich habe zuerst einige der Beispielcode in der Boost-Dokumentation geändert, die ich hier gefunden: (http://www.boost.org/doc/libs/1_41_0/doc/html/interprocess/quick_guide.html).

Die modifizierte Demo funktioniert gut und ist im Grunde wie folgt:

typedef std::pair<double, int> MyType; 
managed_shared_memory segment(create_only, "MySharedMemory", 65536); 

MyType *instance = segment.construct<MyType> 
    ("MyType instance") //name of the object 
    (12.34, 0);   //ctor first argument 

MyType *instance2 = segment.construct<MyType> 
    ("MyType instance2") //name of the object 
    (56.78, 0);   //ctor first argument 

und dann in einem anderen Prozess, rufen diese Variablen:

managed_shared_memory segment(open_only, "MySharedMemory"); 

std::pair<MyType*, managed_shared_memory::size_type> res; 
std::pair<MyType*, managed_shared_memory::size_type> res2; 

res = segment.find<MyType>("MyType instance"); 
printf("1: %d, %d\n", res.first, res.second); // show pointer and size 
printf("1a: %f\n\n", *res.first); //show double value 


res2 = segment.find<MyType>("MyType instance2"); 
printf("2: %d, %d\n", res2.first, res2.second); // show pointer and size 
printf("2a: %f\n", *res2.first); // show double value 

ok, so dass alle th an sieht ok, und der Terminal-Ausgang ist:

Das Problem ist, wenn ich versuche, dies in einem anderen (bestehenden) zu replizieren Anwendung.

Ich habe alles soweit gemacht, was ich sagen kann (identisch in der Syntax vielleicht sogar?), Aber ich bekomme einige verschiedene und unerwartete Ergebnisse.

typedef std::pair<double, int> myDouble; 
managed_shared_memory segment(create_only, "sharedMemBlock", 65536); 

myDouble *valX = segment.construct<myDouble> 
    ("valX") 
    (1.1, 0); 

myDouble *valY = segment.construct<myDouble> 
    ("valY") 
    (2.2, 0); 

myDouble *valZ = segment.construct<myDouble> 
    ("valZ") 
    (3.3, 0); 

und in dem zweiten Prozess diese Werte abzurufen:

managed_shared_memory segment(open_only, "sharedMemBlock"); 
std::pair<myDouble*, managed_shared_memory::size_type> valShrX; 
std::pair<myDouble*, managed_shared_memory::size_type> valShrY; 
std::pair<myDouble*, managed_shared_memory::size_type> valShrZ; 

valShrX = segment.find<myDouble>("valX"); 
valShrY = segment.find<myDouble>("valY"); 
valShrZ = segment.find<myDouble>("valZ"); 

printf("PtrvalSharedX: %d,PtrvalSharedY: %d, PtrvalSharedZ: %d\n", valShrX.first, valShrY.first, valShrZ.first); 
printf("valSharedX: %f, valSharedY: %f, valSharedZ: %f\n\n", *valShrX.first, *valShrY.first, *valShrZ.first); 

aber die Ergebnisse sind nicht das, was ich erwarte, und kommen wie folgt aus:

PtrvalSharedX: 196724, PtrvalSharedY: 196772, PtrvalSharedZ: 196820 
valSharedX: 1.100000, valSharedY: 0.000000, valSharedZ: 2.200000 

Also, was ist hier los? Warum bekomme ich nicht 1.1, 2.2 und 3.3 für valSharedX, valSharedY und valSharedZ?

Nicht sicher, warum im Grunde derselbe Code in einem Fall funktioniert, aber nicht in einem anderen. Ich habe festgestellt, dass der Unterschied zwischen den Zeigern im ersten Beispiel (196780 - 196724) = 56, aber im zweiten Beispiel kleiner ist (196772 - 196724) = (196820 - 196772) = 48. Nicht sicher, ob das relevant ist, aber ich dachte es Es war wert darauf hingewiesen zu werden (Wortspiel!).

Danke, B

Answer 1

Das Problem, dass jeder übersehen, auch ich, das war ...

wegen der Art:

std::pair<myDouble*, managed_shared_memory::size_type> valShrX 

bekommen:

valShrX.first 

gibt einen Zeiger auf ein myDouble zurück und nicht auf das erste double, das ich sa Teil des std :: Paares, das in definiert:

typedef std::pair<double, int> myDouble; 

Da printf nicht weiß, was wirklich ist Typ myDouble, und da dieser Typ nicht nativ von printf bekannt, das Problem nur dargestellt, wenn das Drucken mehrere Werte in einer Sequenz und bezieht sich auf die Größe von myDouble nicht mit der Größe eines double.

Das Drucken jedes Wertes mit einer eigenen printf-Anweisung (wie im ersten Codeauszug) funktioniert gut, weil der Zeiger valShrX.first printf sagt, wo er richtig starten soll. Auch wenn die Größe von valShrX.first den int, der Teil des Paares ist, enthalten muss, druckt printf% f und stoppt.

Im zweiten Codeauszug habe ich versucht, alle drei Werte im Shared Memory in der gleichen printf-Anweisung zu drucken, und so wurde die volle Größe von std :: pair myDouble (einschließlich darin der Doppel und der Int) propagiert und würde versetzt werden der zweite und dritte Wert wird gedruckt.

Die richtige Anweisung sollte nur das erste Element des myDouble Paar bekommen, dass innerhalb des übergeordneten Paar ist ... Mit anderen Worten ist dies die korrekte Syntax printf meine Datentypen gegeben:

printf("valSharedX: %f, valSharedY: %f, valSharedZ: %f\n\n", valShrX.first->first, valShrY.first->first, valShrZ.first->first); 

So, Meine printf-Syntax war in beiden Beispielen falsch, aber die mehr strafende Operation von printf beim Drucken mehrerer Werte in einer Anweisung war der einzige Fall, der das Problem offenbar machte.

Meine einzige verbleibende Frage, die mein Gehirn kitzelt ist dies: Warum dieses Problem in Visual Studio 2013 angezeigt wurde, aber der identische Code, wenn in Linux kompiliert das Problem nicht angezeigt, wenn printf% f erhielt eine myDouble in einer Serie von Werten gedruckt werden? Alles funktionierte gut, wenn es in Linux kompiliert wurde. Warum?