Comment puis-je accéder à argc et argv en C++ à partir d'une fonction de bibliothèque

Question

J'écris une bibliothèque qui doit être chargée dynamiquement en C++. Je voudrais lire argc et argv (pour des raisons de débogage) à partir de mon code, mais je n'ai pas accès à la fonction principale. Y at-il un moyen de récupérer la ligne de commande (à la fois Windows et Linux solution serait bien).

Merci, Dan

Answer 1

Cette discussion montre comment le faire sous Linux.

http://linux.derkeiler.com/Newsgroups/comp.os.linux.development.system/2005-07/0147.html

Answer 2

Il y a la fonction GetCommandLine() dans l'API Win32. Sur d'autres plateformes, vous devriez sauvegarder argc/argv quelque part (variable externe?).

Answer 3

Sous Linux, le pseudo-fichier/proc/self/cmdline contient la ligne de commande du processus. Chaque argument est terminé avec un octet 0 et l'argument final est suivi d'un octet supplémentaire.

Answer 4

Je suggère que cela ressemble à une étrange situation. Etes-vous en train d'écrire un plugin ou quelque chose? Peut-être ne devriez-vous pas accéder à argv/argc?

Answer 5

Sous Windows, vous pouvez utiliser GetCommandLine() pour obtenir un pointeur sur la ligne de commande, puis utiliser CommandLineToArgvW() pour convertir ce pointeur au format argv []. Cependant, il existe seulement une version large (Unicode).

Answer 6

Utilisez les commandes getpid() et ps.

int pid;

int fd;

char cmd [80];

pid = getpid(); Sprintf (cmd, "ps% d", pid)

sprintf (cmd, "ps% d", pid);

fd = popen (cmd, "r");

.... lignes devraient être comme

.... 1358 ./a.out abc def

Answer 7

Sur Windows, vous pouvez accéder argc/argv via __argc et __argv. __wargv si vous voulez la version à caractères larges.

Answer 8

Sous Windows, j'utilise ce genre de chose pour obtenir les arguments:

#include <windows.h> 
#include <string> 
#include <vector> 
#include <cwchar> 
#include <cstdio> 
#include <clocale> 
using namespace std; 

vector<wstring> getArgs() { 
    int argc; 
    wchar_t** argv = CommandLineToArgvW(GetCommandLineW(), &argc); 
    vector<wstring> args; 
    if (argv) { 
     args.assign(argv, argv + argc); 
     LocalFree(argv); 
    } 
    return args; 
} 

int main() { 
    const vector<wstring> argv = getArgs(); 
    setlocale(LC_CTYPE, ".OCP"); 
    for (vector<wstring>::const_iterator i = argv.begin(); i != argv.end(); ++i) { 
     wprintf(L"%s\n", i->c_str()); 
    } 
} 

Edit: Une fonction de getArgs comme qui est également utile pour MinGW comme MinGW ne supporte pas wmain().

Answer 9

Avez-vous pensé à utiliser des variables d'environnement au lieu de la ligne de commande? Peut être plus facile pour l'utilisateur en fonction des types d'applications dans lesquelles la bibliothèque sera utilisée, et vous pouvez utiliser la fonction standard getenv().

Je pense, en tout cas, si votre bibliothèque va utiliser argc et argv, le programme devrait être celui de les passer.

Answer 10

Cela devrait fonctionner sous Linux:

#include <stdio.h> 
#include <unistd.h> 

void findargs(int *argc, char ***argv) { 
    size_t i; 
    char **p = &__environ[-2]; 
    for (i = 1; i != *(size_t*)(p-1); i++) { 
     p--; 
    } 
    *argc = (int)i; 
    *argv = p; 
} 

int main(int argc, char **argv) { 
    printf("got argc=%d, argv=%p\n", argc, argv); 
    findargs(&argc, &argv); 
    printf("found argc=%d, argv=%p\n", argc, argv); 
    return 0; 
} 

Note: échoue si setenv() a été appelé.