Comment puis-je passer argv [1] à une fonction qui prend 0 arguments?

Question

Que dois-je faire pour obtenir le contenu de argv [1] dans une fonction qui n'utilise aucun argument?

Comment ça marche?

const char *cPtr = argv[1]; 

et passez-le à someFunction() qui prend 0 arguments!

Answer 1

Si vous ne voulez pas passer comme argument, vous aurez besoin de le fourrer dans un monde de sorte que la fonction peut accéder à cette façon. Je ne connais aucun autre moyen (autres que des choses stupides comme l'écrire dans un fichier main() et de la lecture dans la fonction):

static char *x; 
static void fn(void) { 
    char *y = x; 
} 
int main (int argc, char *argv[]) { 
    x = argv[1]; 
    fn(); 
    return 0; 
} 

Ce n'est pas comment je le ferais. Puisque vous devez être en mesure de changer fn() pour obtenir l'accès à x de toute façon, je réécris pour passer le paramètre:

static void fn(char *x) { 
    char *y = x; 
} 
int main (int argc, char *argv[]) { 
    fn(argv[1]); 
    return 0; 
} 

À moins, bien sûr, c'est des devoirs, ou un casse-tête, ou une question d'entrevue .

Answer 2

La seule façon de le faire serait de stocker argv [1] dans une variable globale et l'accès de l'intérieur de la fonction.

Answer 3

Seule façon que je peux penser est de faire « const char * cPtr » une variable globale.

par exemple.

char *cPtr; 

main(int argc, char **argv) 
{ 
    cPtr = argv[1]; 
} 
void someFunction() 
{ 
    printf("%s\n", cPtr); 
} 

Answer 4

Je me demande pourquoi vous voulez faire cela. Mais il peut être fait en utilisant un code pas si joli. Appelez essentiellement la méthode comme s'il s'agissait d'une méthode prenant le paramètre char *. Ensuite, dans la méthode, utilisez l'assemblage en ligne pour accéder au paramètre. Voici un exemple avec someFunction implémenté avec la convention d'appel __cdecl.

#include "stdafx.h" 

void someFunction() 
{ 
    TCHAR *x = NULL; 
    __asm 
    { 
     mov eax, dword ptr[ebp + 8] 
     mov x, eax 
    } 

#ifdef _UNICODE 
    printf("%ws\n", x); 
#else 
    printf("%s\n", x); 
#endif 
} 


int _tmain(int argc, TCHAR* argv[]) 
{ 
    if (argc < 2) 
     return 1; 

    const TCHAR *message = argv[1]; 

    typedef void (*FuncPtr)(const TCHAR*); 

    FuncPtr p = (FuncPtr)someFunction; 

    p(message); 

    return 0; 
} 

Answer 5

Il serait utile si nous comprenions plus pourquoi vous voulez passer un argument à une fonction qui ne prend aucun paramètre.
Par exemple, essayez-vous d'appliquer une fonction aux éléments d'un conteneur?

D'autres ont mentionné les variables globales, voici une approche « triche » en passant l'argument à un constructeur d'une classe ou d'une structure:

struct fnstruct { 
    const char* p_; 
    fnstruct(const char* p) : p_(p) { } 
    void operator()() { printf(p_); } 
}; 

int main(int argc, char* argv[]) { 
    if(argc < 2) 
     return 0; 

    fnstruct fn(argv[1]); //argument passed to constructor 

    fn(); //function called with no argument! 
    return 0; 
}