Zugriff auf int argc, char * argv[] vor main

[franksa]

Hi All,
Ich habe eine Frage und bitte Euch um Hilfe. Ich moechte auf die Argumente von main zugreifen:

class d {
publc:
d();
~d();
};

d::d()
{
cerr << "argc:" << argc << endl;
}
d::~d()
{
}

d st;

main ( int argc, char *argv[] )
{
}

Ich habe nicht einmal eine Idea unter welchem Stichwort ich da suchen muesste. Wo kann ich dazu eine Beschreibung finden.
Vielen Dank und viele Gruesse, Frank

 

[etuli]

Naja. Du muesstest vielleicht erstmal ein Objekt erstellen, die Argumente argc und argv uebrgeben und dann koenntest du darueber nachdenken die beiden dann vorhandenen Variablen ihrem Typ entsprechend auszugeben.

 

[franksa]

Hi, erstmal Danke fuer Deine Antwort.
Aber genau das ist es, ich muss vor dem Aufruf von main schon auf argc/argv zugreifen. Kann also nach main nichts mehr tun.
Gruss, Frank

 

[etuli]

Naja. Was haellst du denn davon das Objekt erst in main() zu erstellen?

 

[hopfe]

Warum mußt du vor den Aufruf von Main schon was mit den Variablen machen?

main() wird für normal als aller erstes aufgerufen, ich denke nicht das du eine Funktion davor setzten kannst.

 

[franksa]

Hi,
Vor dem Aufruf von main werden alle Konstructoren der globalen Klassen aufgerufen. Es wird also tatsaechlich ein Programmteil vor main aufgerufen. Meine globale Klasse muss nun etwas machen und dazu auf die argc/argv zugreifen.

Viele Gruesse und vielen Dank fuer Eure Hilfe, Frank

 

[h2owasser]

Warum nicht so wie etuli schon sagte?

#include <iostream>

using namespace std;

class d {

public:
d( int argc,char *argv[]);
~d();
};

d::d(int argc,char *argv[])
{
cout << "argc:" << argc << endl;
}
d::~d()
{
}
main ( int argc, char *argv[] )
{d st(argc,argv);}

 

[franksa]

Hi,
weil st dann erst instanziert wird wenn main schon aufgerufen wurde und main eine C-Funktion ist.
Es ist schon klar, dass nach dem Aufruf von main alles machbar ist. Aber ich brauche das leider schon vor main.

Wenn es also keine Funktion gibt, die nur der C++-Compiler irgentwie zur Verfuehgung stellt, die vor allem aufgerufen wird und argc/argv bekannt macht, dann geht das, was ist brauche nicht.

Viele Gruesse, Frank

 

[etuli]

Welche Anwendung, braucht denn solche Konstrukte? Mir faellt keine ein.

 

[cremi]

ich würd mal sagen dass was du machen willst nicht funktioniert.

aber ich kann mir nicht vorstellen das du das nicht irgendwie anders lösen kannst, indem du nicht im konstruktor auf argv zugreifst.
aber da ich keine ahnung habe was du konkret machen wilst - und vor allem warum! - kann ich dir keinen lösungsvorschlag anbieten.

 

[ExRevel]

Ich möchte mich dem etuli da gerne anschliessen, welche Applikation benötigt denn aufrufe vor main() wobei es eh schnee ist. Die Konstruktoren werden doch auch nicht vor main aufgerufen? Wo wäre der Sinn? Ich meine wenn ich eine Klasse instanziere dann wird der Konstruktor aufgerufen, wie soll er vorher aufgerufen werden, oder warum? Wenn keine Instanz gefordert wird, dann brauch doch auch der Konstruktor nett aufgerufen werden! Der Compiler verarbeitet die Klassen vllt. vor der main() aber doch nicht im Programmablauf... wenn ich mich so unglaublich täuschen sollte, dann haette ich gerne einen schwarz auch weiss beweis mittels einer kompetenten website.

Also meine Meinung, das wird sicher nicht funktionieren was du vor hast.

ciao Exi

 

[panzi]

Probiers doch aus! Konstruktoren global angelegter Objekte werden vor main() ausgeführt!

#include <iostream>

class Foo {
public:
   Foo() { std::cout << "Foo()" << std::endl; }
   virtual ~Foo() { std::cout << "~Foo()" << std::endl; }
};

Foo bar;

int main() {
   std::cout << "main()" << std::endl;
   return 0;
}

Ausgabe:

Foo()
main()
~Foo()

 

[pinky]

Also ich muß ehrlich sagen, dass ich das Problem auch nicht verstehe.
Denn selbst wenn man, wie panzi gezeigt hat, ein globales Objekt erzeugt. Dann passiert darin ja noch nichts "dynamisches". Der Programmablauf beginnt immer in main(), warum dann also nicht einfach in main foo die Argumente mitteilen?

Also z.B.

int main(int argc, char* argv[]) {
   foo.setArgs(argv);
   return 0;
}

Ausserdem sind globale Objekte mind. genauso unschön wie globale Variablen

 

[cremi]

kann pinky nur zustimmen - so würd ich das auch machen

 

[ExRevel]

Ok, habe ich wieder was gelernt an panzis beispiel, nur auf die Argumente des Programms wird man dennoch nicht zugreifen können?! Ich kann nur wieder die gleiche Frage stellen wie pinky, wär schön wenn sich franksa dazu mal äußern würde... ist einfach nur interesse wann man sowas brauchen könnte.

ciao Exi

 

[etuli]

Passend zu diesem Thema: http://dev.webreeze.de/board/viewtopic.php?p=49#49 (Dynamische Initialisierung konstanter Klassenvariablen inC++). Es gibt naemlich doch eine Loesung.

 

[MadJoe]

die möglichkeiten sind ziemlich interessant, aber da kann ich allen anderen nur zustimmen. es kommt mir ziemlich pervers vor, wenn ich das mal so sagen darf, argc und argv vor main verwenden zu wollen. ich würde mich an ein strenges objektorientiertes schema halten, bei dem erst in main alles initalisiert wird. damit konnten noch alle probleme gelöst werden.

 

[MrFenix]

Ich weiß nicht, es ist zwar SERH gepfuscht, aber wie wäre es mit sowas:
Programm 1:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char * argv) {
  int i;
  string comv;
  for (i=0; i<argc; i++) {
    comv += argv[i];
  }
  setenv("comandvars", comv.c_str(), 1);
  system("prog2");
  return 0;
}

Programm 2:

#include <cstdlib>
#include <iostream>

using namespace std;

class schrott {
public:
  schrott {
         char * vars = getenv("comandvars");
         unsetenv("comandvars);
         cout << vars << endl;
   }
  ~schrott {
  }
};

schrott muell;

int main() {
cout << "main" << endl;
return 0;
}

F*CK the system Methode