Définir propres fonctions principales arguments argc et argv

je veux créer un objet de type QApplication qui doit les principales fonctions des arguments argc et argv en entrée:

QApplication app(argc, argv);

Depuis que je suis à l'intérieur d'une fonction définie par l'utilisateur, sans accès à la fonction principale que je veux définir ce arguments sur mon propre. J'ai essayé plusieurs méthodes mais je ne peux pas obtenir le type de conversion. Ma dernière approche ne fonctionne pas, soit:

int argc = 1;
char **argv; 
char arguments[1][12] = {{"cgalExample"}};
argv = arguments;

Merci pour toute indication.

  • Pourriez-vous préciser ce qui n'a pas de travail? Ne compile pas? erreur lors de l'exécution? ne pas faire ce que vous vous attendiez?
  • Erreur de compilation sous Visual Studio 2008: Impossible de convertir les types. Soupçon de gs a bien fonctionné.
InformationsquelleAutor | 2009-10-05
  1. 35

    Rapide et sale, mais en travaillant pour QApplication:

    char *argv[] = {"program name", "arg1", "arg2", NULL};
int argc = sizeof(argv) / sizeof(char*) - 1;

    Pour une information plus complète et C standard conforme solution voir D. Shawley réponse.

    Pourquoi votre solution ne fonctionne pas est simple:

    array[i][j] résultats dans un i*j de la matrice. Mais ce que vous voulez vraiment est un tableau de pointeurs vers des chaînes en elle.

    • Merci beaucoup. Cette une compile sous VS 2008.
    • Peut être bon de mentionner que le premier argument est le nom du programme.
    • Belle correction pour le nom du programme et la valeur NULL, mais char* encore faut-point à mutable chaînes... les chaînes littérales sont pas.
    • Le chaos est susceptible d'être opéré si argv[argc] != NULL; code est censé être en mesure de compter sur cela.
    InformationsquelleAutor Georg Schölly
  2. 32

    Si vous voulez être incroyablement pendantic, alors vous voulez quelque chose comme ce qui suit. Les points clés sont que argv n'est pas const, argv est NULL résilié, argc est le nombre d'éléments utilisables dans argv y compris le nom du programme. Il est nécessaire d'être modifiable de sorte que vous ne pouvez pas utiliser les littéraux de chaîne - argv[i] est nécessaire pour pointer vers une modifiables tableau de caractères.

    int my_main() {
    char  arg0[] = "programName";
    char  arg1[] = "arg";
    char  arg2[] = "another arg";
    char* argv[] = { &arg0[0], &arg1[0], &arg2[0], NULL };
    int   argc   = (int)(sizeof(argv) / sizeof(argv[0])) - 1;

    QApplication the_application(argc, &argv[0]);
    return the_application.run();
}

    La Norme (ISO/IEC 9899:1999 section 5.1.2.2.1) les états suivants est vrai concernant le argc et argv dans un environnement hébergé:

    • La valeur de argc doit être positif ou nul.
    • argv[argc] doit être un pointeur null.
    • Si la valeur de argc est supérieure à zéro, les membres du groupe argv[0] par argv[argc-1] inclusive doit contenir des pointeurs vers des chaînes, qui sont donnés en œuvre les valeurs définies par l'hôte de l'environnement avant le démarrage du programme d'ailleurs dans l'environnement hébergé. Si l'hôte de l'environnement n'est pas capable de fournir des chaînes de caractères avec des lettres à la fois des majuscules et des minuscules, la mise en œuvre doit s'assurer que les chaînes sont reçues en minuscules.
    • Si la valeur de argc est supérieure à zéro, la chaîne pointée par argv[0] représente la nom du programme; argv[0][0] doit être le caractère null si le nom du programme n'est pas disponible à partir de l'hôte de l'environnement. Si la valeur de argc est supérieur à un, les chaînes pointées par argv[0] par argv[argc-1] représentent paramètres du programme.
    • Les paramètres argc et argv et les chaînes pointées par le argv tableau doit être modifiable par le programme, et de conserver leur dernier-valeurs enregistrées entre le programme de démarrage et de fin de programme.

    QApplication les états suivants:

    Avertissement: Les données visées par argc et argv doit rester valable pour la
    toute la durée de vie de la QApplication
    objet. En outre, argc doit être
    supérieure à zéro et argv doit
    contenir au moins un caractère valide
    chaîne de caractères.

    ...

    Remarque: argc et argv peut-être changé
    allongement de l'intervalle Qt supprime les arguments de ligne de commande
    qu'il reconnaît.

    • Merci pour cette précision!
    • Juste une question, faut-il ne pas l'être (int)((sizeof ...) - 1)? Sinon argc[argv] sera point un passé le NUL...
    • viens de remarquer que moi-même. Merci.
    • tingle: prendre un coup d'oeil à l'alinéa 14 de l'article 6.7.8 de C99 ou à l'alinéa 1 de l'article 8.5.2 en C++98. Indiquer clairement que un char tableau peut être initialisé à partir d'une chaîne littérale (éventuellement entre accolades); des caractères successifs de la chaîne littérale initialiser les membres de la matrice.
    • N'est-ce pas &arg0[0] le même que juste arg0?
    • D. Shawley: Vous avez tout à fait raison. J'ai rétracté mon commentaire.
    • c'est vrai dans la plupart des cas. C++ choisir un modèle de spécialisation comme template <typename T, size_t N> void foo(T (&ary)[N]) sur template <typename T> void foo(T val) si une telle spécialisation existe. Le type si arg0 correspond char (&)[12] avant de se dégrader à char*. J'ai juste pris l'habitude de passer soit char* ou une référence à un tableau de manière explicite.
    • Votre réponse est LA bonne version pour moi. Je suis de passage quelques arguments pour principale méthode qui appelle strsep sur les arguments. Si j'utilise un autre moyen que le vôtre, par exemple. Shaley, puis par exemple. strsep échoue avec une ERREUR de segmentation (voir stackoverflow.com/questions/3972332/...).
    • Le QApplication documents ne sont pas réellement en mesure de dire si argv[argc] doit être null; je suis d'accord à se tromper sur le côté de la prudence et de lui donner les mêmes garanties que main().

    InformationsquelleAutor D.Shawley
  3. 3

    Comment sur...

    int argc = 2;
const char* argv[] ={"program","first-argument"};

    ...ou si vous en avez besoin pour être non-const...

    int argc = 2;
char* argv[] ={strdup("program"),strdup("first-argument")};
    • Je suis d'accord avec vous. En général, le premier argument est la commande
    InformationsquelleAutor alex tingle
  4. 3

    Pourquoi êtes-vous à propos de votre auto avec la taille du texte dans argv, je voudrais juste laisser le compilateur faire:

    int argc = 1;
char* argv[] = {"Hello Qt!"}; //exactly as it is defined in main
    • Eh bien, qui ne compile pas pour une chose: "erreur: corset-clos de l'initialiseur utilisé pour initialiser ‘char*’"
    • Il compile bien avec moi (VC2008). Quel compilateur que vous utilisez?
    • Oui, mais n'est-il pas nécessaire que le tableau argv lui-même est nul?
    • Oui, je connais argc, mais si vous frayer un processus dans linux, ne pas le faire entraînera une erreur de segmentation; et si vous effectuez une recherche sur google, il y a quelques consignes de sécurité sur ce point.
    • argc contient le nombre d'arguments argv.
    • gcc 4.0.1: warning: braces around scalar initializer
    • Honnêtement, je n'ai aucune idée sur la programmation sous Linux. N'est-ce pas argc requis par le C/C++ normes pour contenir le nombre d'arguments?
    • J'ai essayé celui de trop et j'obtient l'erreur de compilation: Erreur 4error C2664: 'QApplication::QApplication(int &,char **,int)' : impossible de convertir le paramètre 2 de 'char *' to 'char **'
    • Je l'ai attachée à l'aide de VC2008 (/W4) et cela ne me donne aucun avertissement!
    • J'ai fait une recherche sur ce point: "Le tableau de pointeurs doit être terminée par un pointeur NULL.", voir: linux.die.net/man/3/exec Oui, argc doit contenir le nombre, mais il semble que quelqu'un voulait permettre la while(++argv) style.
    • c'est un tout autre problème. Le execl fonction prend null arguments. argv lui-même n'est pas null.
    • J'ai enlevé les crochets autour du texte juste parce que j'ai confiance GCC 😉
    • Et je vais vous redonner votre vote. 🙂
    • la Norme exige que argv est NULL résilié. Voir ma réponse pour le texte exact.
    • AraK: Voici 10p, procurez-vous un bon compilateur 🙂
    • Merci! C'est vraiment intéressant.

    InformationsquelleAutor AraK
  5. 0

    Bien que ni le C ni C++ standard nécessite, la plupart des compilateurs font les arguments principaux qui vous _argv et _argc. Si la mémoire est POSIX exige. De toute façon, vous devez utiliser quelque chose comme:

    extern int _argc;
extern char *_argv[];

    et à partir de là, vous pouvez les utiliser comme normal.

    InformationsquelleAutor Jerry Coffin
  6. -2

    J'espère que cela fonctionne:

    char* argv[1];
argv[0] = "cgalExample";
    • Vous êtes en cours d'initialisation char* avec un const char[]. Coquine!
    • Contrairement à la déclaration ci-dessus, ici c'est vraiment un problème...
    InformationsquelleAutor MrMage