aqe89 hat geschrieben:
1)Datei( makewhat.c ):
Vordert mit malloc speicher für 1 int Variable an.
startet den Prozess "killer" und übergibt die Adresse vom Speicherbereich an "killer"
Da gibts nur ein kleines Problemchen: "Virtuelle Addressierung". Der vorteil an Modernen Betriebssystemen ist, dass jeder Prozess seinen eigenen Adressraum hat. Dieser Adressraum ist 4GB groß, und es hat jeder Prozess den ganzen.
Natürlich hast du nicht so viel Speicher - wegen Hardwarebeschränkungen oder weil andere Prozesse den Speicher benötigen. Aber dein Programm glaubt, es hat den ganzen adressraum.
Deswegen ist es so, dass du einen Zeiger aus einem Adressraum niemals in einem Anderen Adressraum übertragen kannst - schließlich hat ja jeder Prozess seinen eigenen.
Das gilt wie gesagt nur für Moderne Betriebssysteme!
Das alte DOS ( Denial of Serv.... Äh... Disc Operating System) z.B. hatte für jeden Prozess den gleichen Adressrum. Da hättest du das z.B. machen können.
aqe89 hat geschrieben:
Programm durchlauft eine Schleife die überprüft ob auf dem Speicherbereich etwas geändert wird.
neben bei macht es noch sinnloses Zeugs.
Eine schleife? Das was dadurch passiert ist, das du unnötig die ganze CPU aufbrauchst! Deine benutzer werdens dir danken.
Was du dafür brauchst sind Betriebssystemfunktionen die Folgendes können:
- Einen gemeinsamen Speicherbereich anfordern
- Das Programm so lange anhalten, bis etwas passiert. Wenn etwas passiert wird das Programm weitergeführt. Das nennt man "Blocking Function Call"
Das sind wie gesagt Betriebssystemfunktionen, die für jedes OS unterschiedlich sind. Du hast sie schon richtigerweise als "IPC" kategorisiert. Sieh dir dazu die Anleitung zur API deines Betriebssystems an (manpages, msdn).
Es gibt allerdings bibliotheken die das für dich abstrahieren, zum Beispiel
Boost.Interprocess.
Vielleicht überlegst du dir, ob du nicht vielleicht mit Threads ("leichten Prozessen") besser bedient wärst als mit mehreren echten prozessen.
Du musst dir allerdings bewusst sein, dass das eine Völlig andere Welt der Programmierung ist als bisher. Bisher hattest du dein Programm mehr oder weniger "Sequenziell". Du hast eine Anweisung nach der Anderen ausgeführt und hast mit Kontrollstrukturen deine Programme gesteuert.
Was du hier allerdings angeschnitten hast ist etwas völlig anderes: Es ist quasi "Asynchrones Programmieren", denn jetzt ist nichts mehr Sequenziell sondern es passiert alles "Gleichzeitig".
Was ist wenn mit der Datei nie etwas passiert weil der andere Prozess nicht gestartet wurde? Man bräuchte ein art "Timeout". Aber wie willst du das implementieren ohne die CPU aufzufressen? Du bräuchtest nen Timer. Aber wie reagierst du auf einen Timer, wenn dein Programm in einem Blockierten Funktionsaufruf steckt? usw...
Das ganze ist nämlich nicht so einfach, und verursacht ziemliche Kopfschmerzen, wenn du noch wenig erfahrung damit hast (so wie ich z.B.
)
Darf man Fragen für welche Aufgabenstellung das ganze gedacht ist?
aqe89 hat geschrieben:habe mal etwas probiert, bin aber beim Funktionsaufruf gescheitert, weil ich die Adresse nicht in einen String speichern konnte(casten).
Code: Alles auswählen
#ifdef _ cplusplus
void write_adress(std::ofstream& os, void* address)
{
os<<address;
}
void* read_adress(std::ifstream& is)
{
void* address;
is>>address;
return adress;
}
#else
void write_adress(FILE* outfile, void* address)
{
fprintf(outfile, "%p", address);
}
void* read_adress(FILE* infile)
{
void* address;
fscanf(infile, "%p", &address);
return address;
}
#endif
Das nur als Tip, details bitte selber rausfinden (und auch die Fehlerbehandlung)
Haters gonna hate, potatoes gonna potate.
