GUI aus Programm code starten

[abcmann74]

Hi

Habe folgedendes Problem und hoffe das mir vllt. jemand weiterhelfen kann.

Ich habe ein kleines Programm geschrieben und kann dieses auch ganz normal kompilieren lassen. Die Ausgabedatei (.exe) kann ich dann auch starten und alles funktioniert.
Ich möchte nun gerne das Programm über den Quellcode eines anderen Programmes aufrufen.
Das Programm wird bei mir über folgenden Code gestartet:

Code: Alles auswählen

int main(int argc, char* argv[]) 
{
	QApplication app( argc, argv );

	DetectionMainWindow detectionMainWindow(0, Qt::Window);
	detectionMainWindow.show();

	app.exec();
	
	return 0;
}

Wenn ich nun die GUI (DetectionMainWindow) aus dem Quellcode heraus starten möchte, weiß ich nicht was für Parameter ich für int argc, char* argv[] übergeben muss.
Ich weiß das der erste Parameter argc die Anzahl der Argumente beinhaltet, welche dem Programm beim Start übergeben wurden. Der zweite Parameter argv[] ist mit den einzelnen Argumenten gefüllt.
Ich habe mir die Werte mal ausgeben lassen. argc war =1 und in argv[0] stand dann der Pfad der EXE Datei um das Programm zu starten.
Aber was muss ich jetzt bei einem Start aus dem Quellcode dafür einsetzen?
Gibt es evtl. noch eine andere Möglichkeit ein Programm zu starten ohne die Paramter int argc, char* argv[] zu nutzen? Ich hab bereits versucht das Fenster einfach mittels .show() anzeigen zu lassen. Das Programm startet so auch, beendet sich aber sofort wieder. Das liegt wohl daran, dass der main Event Loop nicht aufgerufen wird.

Beste Grüße

[RHBaum]

Ich versteh irgendwie Bahnhof
Also ich versteh nicht so recht was du machen willst. Also noch mal langsam, tief Luft holen und Schritt fuer Schritt, damit wir es auch Begreifen.

Was ich bisher verstanden hab:

- Du hasst ein Programm schon geschrieben (compiliert, exe lauffaehig !).
? Das Programm soll so bleiben ? nehm ich mal an !
? Hat dieses Programm eine GUI ? oder ist es eine ConsolenApp ?
- Du willst dieses Programm aus einem anderen, neuen Programm starten ! (Quellcode ruft nix auf, Quellcode kompiliert nur ! )
? Obig geposteter Code ist der Code, fuer die 2te App, die die erste starten soll, richtig ?

weiß ich nicht was für Parameter ich für int argc, char* argv[] übergeben muss.

Was das soll, weiss ich gar nicht !
du rufst doch die main nicht auf ! Das macht generell das Betriebssystem. Die main() ist dein Einsprungspunkt.
argc und argv sind Parameter(Argumente) die dir mitgegeben werden, und zwar sind das die commandlineparameter, mit der deine App(exe) aufgerufen wurde ! Die fasst du nur (lesend)an, wenn du mit deinem Prog auch kommandozeilenoptionen auswerten willst !

BinaerCode von einem Programm(Prozess) aus einem anderen Kompilat ausfuehren geht eigentlich nur mit Dlls (dynamische Bibliotheken) (inprocess).

andere Exes kannst du nur ueber das BS ausfuehren lassen, nicht selber:
Dabei musst unterscheiden, ob du synchron, oder assynchron aufrufen willst:

synchron: dein aktueller prozess wird "überlagert" also kurz ausgesetzt.
dein neues Programm wird in den prozess geladen und ausgefuehrt
wurde dein Programm beendet, wird dein orginaler code wieder aktiviert und weiter ausgefuehrt.
ergo: du rufst die synchrone funktion auf, dein anderes programm startet, laeuft , beendet sich, und wenn beendet, kommt in deinem Programm die synchrone funktion zurueck:
Rueckgabewert ist der Exit-Code des Programms, das aufgerufen wurde.

unter Linux/posix:
exec... familie:
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg , ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);

unter Windows (WinAPI):
_exec[...] funktionen
_wexec[...] funktionen

Assynchron:
Dein aktueller Prozess wird nicht ueberlagert, stattdessen wird ein neuer prozess gestartet. Deine Aufruffunktion kehrt sofort zurueck ...
und rueckgabewert ist dann nateurlich nur ein interner Fehlercode, ob das starten des Progs geklappt hat.

Linux/Posix:
system()
nachbau durch Kombination aus fork() und den exec[...]() funktionen.

Windows (WinAPI):
system()
_wsystem()
CreateProcess()

Unter Qt gibts natuerlich auch ne schoene Klasse, die dir zumindest fuer die assynchrone variante alles auf eine Lib Adaptiert :
QProcess

Ciao ...

[metz153]

Wenn ich das richtig verstanden habe, dann willst du einfach nur irgend eine exe (in diesem Fall deine GUI Detection"MainWindow") starten.

Da hilft z.B.:

Code: Alles auswählen

QProcess::startDetached(/*meinPfad/.exe param1 param 2*/)

->Verhält sich, glaube ich, wie wenn du das Programm aus der CMD aufrufen würdest...

Gruß