Comment utiliser char * en C

Question

J'ai la principale fonction comme ceci:

void main() 
{ 
    char *s; 
    inputString(s); 
    printf("%s",s); 

} 

et la fonction inputString:

void inputString(char *&s) 
{ 

    //Some code line to input a string and set s point to this string 

} 

Y at-il une fonction d'auto chaîne de magasin assez de mémoire malloc qui inputed (I besoin d'une chaîne d'entrée dans la fonction inputString).

Answer 1

Vous mixez C et C++ dans votre exemple.

Dans votre cas, avant de pouvoir utiliser s, il doit être initialisé. Par exemple, comme ceci:

void inputString(char *&s) 
{ 
    s = strdup(xxx); // or malloc, calloc, etc. 

} 

Mais vraiment, alors il est préférable d'utiliser simplement bon vieux C:

char* inputString(void) 
{ 
    char* s = strdup(xxx); 
    return s; 
} 

Answer 2

Si vous continuez à utiliser cette approche de style C, alors non, vous devrez faire des hypothèses et allouer vous-même assez de mémoire. L'approche C est de beaucoup plus supérieure, utilisez std :: chaînes et ne pas faire les allocations manuelles:

#include <string> 
#include <iostream> 
void inputString(std::string& s) 
{ 

    //Don't bother for the memory management 

} 
int main() 
{ 
    std::string s; 
    inputString(s); 
    std::cout << s ; 
} 

également ne Notez que votre code est pas légal C++. void main() est illégale !!!

Edit: Au moment de cette réponse à la question a été étiqueté C++. Plus tard, la question a été retagged pas par l'OP, et je ne suis pas d'accord avec elle ...

Answer 3

seulement 3 lignes de code (mettre ces int main() à l'intérieur) sont assez

std::string s; 
std::cin >> s; //or getline() as desired 
std::cout << s; 

Answer 4

En supposant que vous faites cela est C et non C++.

Il existe deux approches, soit inputString doit allouer la mémoire ou l'appelant de inputString doit allouer la mémoire.

si inputString alloue la mémoire de votre fonction sera probablement quelque chose comme:

char* inputString(void) 
{ 
    int len = strlen (MyInternalString) + 1; 
    char* s = malloc (len); 
    strncpy(s, MyInternalString, len); 
    return s; 
} //similar to what Rustram illustrated 

vous devez également inclure: freeString void (char * str) { libre (str); } également. Ceci indique clairement à l'utilisateur qu'il doit gérer lui-même la mémoire de la chaîne renvoyée.

Vous pouvez également écrire inputString où l'utilisateur doit fournir la mémoire requise. Cela ressemblera à ça

int inputString(char* str, int maxLen) // 
{ 
    if (maxLen >= myInternalStringLength + 1) 
    { 
    strncpy(str, myInternalString, maxLen) 

    } 
    return myInternalStringLength + 1; 
} 

Ici, l'utilisateur de ma chaîne peut vérifier le code de retour pour voir si le tampon qu'il a alloué était assez grand.Si elle était trop petite, alors il peut toujours réallouer un plus grand

Votre principal devient maintenant:

int main() 
{ 
    char *s = NULL; 
    int len = inputString(s, 0); 
    s = alloca(len); //allocates the memory on the stack 
    len = inputstring(s, len); 
    printf("%s",s); 
} //no need to free the memory because the memory alloca'ed gets 
    //freed at the end of the stack frame 

Answer 5

int main() 
{ 
    std::string s; 
    inputString(s); 
    printf("%s",s.c_str()); 
} 

et la fonction inputString:

void inputString(std::string& s) 
{ 
    //Some code line to input a string and set s point to this string 
    std::cin >> s; 
}