Comment puis-je lire une entrée de chaîne de longueur inconnue?

Si je ne sais pas combien de temps le mot est, je ne peux pas écrire char m[6];,

La longueur du mot est peut-être dix ou vingt de long.
Comment puis-je utiliser scanf pour obtenir l'entrée à partir du clavier?

#include <stdio.h>
int main(void)
{
    char  m[6];
    printf("please input a string with length=5\n");
    scanf("%s",&m);
    printf("this is the string: %s\n", m);
    return 0;
}

veuillez saisir une chaîne de longueur=5

bonjour

c'est la chaîne: bonjour

utilisez le pointeur de realloc combinaison
Vous pouvez déposer le & dans scanf("%s",&m) depuis m est déjà un pointeur vers le premier élément de m[] dans cette expression.

InformationsquelleAutor it_is_a_literature | 2013-06-01

c scanf

82

Entrée lors de la sécurisation d'une zone dynamiquement

E. G.
```
#include <stdio.h>
#include <stdlib.h>

char *inputString(FILE* fp, size_t size){
//The size is extended by the input with the value of the provisional
    char *str;
    int ch;
    size_t len = 0;
    str = realloc(NULL, sizeof(char)*size);//size is start size
    if(!str)return str;
    while(EOF!=(ch=fgetc(fp)) && ch != '\n'){
        str[len++]=ch;
        if(len==size){
            str = realloc(str, sizeof(char)*(size+=16));
            if(!str)return str;
        }
    }
    str[len++]='#include <stdio.h>
#include <stdlib.h>
char *inputString(FILE* fp, size_t size){
//The size is extended by the input with the value of the provisional
char *str;
int ch;
size_t len = 0;
str = realloc(NULL, sizeof(char)*size);//size is start size
if(!str)return str;
while(EOF!=(ch=fgetc(fp)) && ch != '\n'){
str[len++]=ch;
if(len==size){
str = realloc(str, sizeof(char)*(size+=16));
if(!str)return str;
}
}
str[len++]='\0';
return realloc(str, sizeof(char)*len);
}
int main(void){
char *m;
printf("input string : ");
m = inputString(stdin, 10);
printf("%s\n", m);
free(m);
return 0;
}
';

    return realloc(str, sizeof(char)*len);
}

int main(void){
    char *m;

    printf("input string : ");
    m = inputString(stdin, 10);
    printf("%s\n", m);

    free(m);
    return 0;
}
```
- En multipliant par sizeof(char)? Ugh.
- zone pour le '\ 0' est sécurisé.
- Pfff, qui sera probablement optimisé loin. Pas de problèmes. Mais si vous le faites une recherche globale et remplacement de char avec wchar_t, cette solution fonctionne encore, contrairement à d'autres solutions, qui aurait besoin de plus de bricoler!
- J'aime écrire de cette façon que est définie comme sizeof(char) est 1.
- Il n'est pas supposé size spécifié pour le premier est de 0, car il est un non-sens. Et si nous pouvons le vérifier.
- Si à tout, vous devez multiplier par sizeof (*str). Mais encore, c'est de la paranoïa galopante et une odeur de code.
- C'est pourquoi la bonne façon, si à tous, c'est à se multiplier avec sizeof (*str) de sorte que vous n'avez même pas à modifier la multiplication lorsque le type de changements.
- C'est certainement le cas que str[len]='\0'; return realloc(str, len); entraînera la terminaison d'être mis au rebut. Je pense que vous vouliez dire str[len++] = '\0'.
- j'avais été mal compris. Fixe. Merci
- Aussi, la même erreur avec if (len>size). Et sizeof(char) est toujours 1.
- assurez-vous. fixe. merci.
- OK, maintenant c'est (et tout malloc()à base de solution) est confrontée au problème de savoir quoi faire quand nous sommes à court de mémoire. main() besoins d'une gestion d'erreur lorsque inputString() retourne NULL.
- besoins une gestion d'erreur lorsque inputString() renvoie la valeur NULL. je m'en remets à lui(elle).
- (*taille= 2), c'est mieux.
- elle dépend des caractéristiques des données manipulées par l'optimisation.
- pourquoi est -size_t size = 10 ?
- Une valeur qui est à peu près de la nécessaire valeur initiale, mais peut être n'importe quelle valeur.
- Il est possible d'éviter ces frais en cas de traitement à l'intérieur de la taille de ce qui est attendu puisque parce que coûteux en tant que tel est réalisée dans le realloc.
- N'est-ce pas realloc(NULL, sizeof(char)*size); le même que malloc(sizeof(char) * size)? Quelle est la raison qui realloc est préféré ici?
- Veut simplement dire que l'unification du format. Il n'y a pas de problème avec malloc(sizeof(char) * size).
- non, realloc ne peut pas être remplacé par malloc. Si vous l'avez modifiée, vous auriez à free la mémoire avant.
- Je ne suis pas vous.
- crée de la mémoire. Si vous avez créé de nouvelles de la mémoire et de ne pas libérer de l'ancienne vous auriez une fuite de mémoire. realloc se charge de tout malloc ne l'est pas.
- Il n'est pas associée à un. Je dis à propos de realloc(NULL, sizeof(char)*size); the same as malloc(sizeof(char) * size)
- non, ce n'est pas la même. En remplacement de la première à la deuxième serait de conduire à des fuites de mémoire.
- Où est la mémoire de morceau à cause d'une fuite de mémoire?
- ce mémoire morceau? Je parle de ce que vous avez dit. Vous avez dit que le remplacement de realloc(...) avec malloc(...) conduit à le même comportement, alors que c'est faux. Lorsque vous realloc avec succès, il libère la mémoire précédent, tandis que malloc ne l'est pas. Ils ne sont donc pas interchangeables comme vous l'avez dit.
- Pas de. J'ai dit à propos de realloc(NULL, sizeof(char)*size); the same as malloc(sizeof(char) * size). Je ne dis pas la même chose de malloc et realloc.
- ok je obtenir de vous. Je n'ai pas remarqué les NULL 🙂
- Que dites-vous de pointage à quoi que ce soit à faire avec vieux ( "la vieille, vous auriez une fuite de mémoire")?
- C'était une perte de temps.
- rien. Je n'ai pas remarqué de la valeur NULL, alors j'ai pensé de vous en parler sur le remplacement de tous les realloc avec malloc, pas seulement la première. Je suis désolé.
- est le dernier realloc dans inputString vraiment nécessaire ?
- Pas de. Il fait juste la taille de la mémoire tampon égale à la taille de la chaîne d'entrée (plus un pour le caractère nul).
- Pouvez-vous expliquer pourquoi inputString() n'est pas juste de retour str? Est-ce gratuit la les octets non utilisés si la longueur de la chaîne entrée stdin est inférieure à la taille (taille initiale)?
- Yup, Il est prévu de n'inclure des espaces inutilisés.
- Je ne m'aime certains de large wchar_tacters à l'aide de wwchar_t_t! Je les utilise tout le temps dans ma pile wchar_tger pour afficher un message d'erreur si la batterie est trop loin diswchar_tged ou a un unwchar_tacteristic wchar_tging courbe. (Les batteries endommagées sont dangereux pour rechar_tge et peut coûter un surwchar_tge à recycler)
- Vous avez oublié d'appuyer sur Alt+W pour rechercher les mots entiers seulement.
- Il peut présenter une fuite de mémoire si la realloc échoue dans return realloc(str, sizeof(char)*len);. Cet appel est une perte de temps de toute façon puisque je doute qu'un système a plus fines malloc granularith de 16 octets
InformationsquelleAutor BLUEPIXY
13

Avec les ordinateurs d'aujourd'hui, vous pouvez vous en sortir avec l'allocation de très grandes chaînes de caractères (des centaines de milliers de caractères) alors qu'à peine faire une brèche dans l'ordinateur de l'utilisation de la RAM. Donc, je ne m'inquiéterais pas trop.

Cependant, dans les vieux jours, quand la mémoire est à une prime, la pratique courante était de lire des cordes en morceaux. fgets lit jusqu'à un nombre maximum de caractères à partir de l'entrée, mais qui laisse le reste de la mémoire tampon d'entrée intacte, de sorte que vous pouvez lire le reste de celui-ci que vous aimez.

dans cet exemple, j'ai lu en morceaux de 200 caractères, mais vous pouvez utiliser n'importe quel morceau de la taille que vous voulez, bien sûr.
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readinput()
{
#define CHUNK 200
   char* input = NULL;
   char tempbuf[CHUNK];
   size_t inputlen = 0, templen = 0;
   do {
       fgets(tempbuf, CHUNK, stdin);
       templen = strlen(tempbuf);
       inputlen += templen;
       input = realloc(input, inputlen+1);
       strcat(input, tempbuf);
    } while (templen==CHUNK-1 && tempbuf[CHUNK-2]!='\n');
    return input;
}

int main()
{
    char* result = readinput();
    printf("And the result is [%s]\n", result);
    free(result);
    return 0;
}
```
Remarque que c'est un exemple simplifié avec aucune vérification d'erreur; dans la vraie vie, vous devrez assurez-vous que l'entrée est OK, vérifier la valeur de retour de fgets.

Également noter qu'à la fin si le readinput de routine, pas d'octets sont perdues; la chaîne a exactement la taille de la mémoire dont il a besoin.
- Les besoins de la gestion d'erreur realloc() retour NULL (et, par conséquent, pour readinput() retour NULL).
- Besoin de vérifier la valeur de retour de fgets(), d'autre code peut entrer dans une boucle infinie.
- OK, a ajouté une note à ce sujet.
InformationsquelleAutor Mr Lister
9

J'ai vu qu'un simple façon de lire un arbitrairement long de la chaîne, mais je n'ai jamais utilisé. Je pense qu'il va comme ceci:
```
char *m = NULL;
printf("please input a string\n");
scanf("%ms",&m);
if (m == NULL)
    fprintf(stderr, "That string was too long!\n");
else
{
    printf("this is the string %s\n",m);
    /* ... any other use of m */
    free(m);
}
```
La m entre % et s dit scanf() à mesure de la chaîne et de l'allouer de la mémoire et de copier la chaîne, et à stocker l'adresse de la mémoire allouée dans l'argument correspondant. Une fois que vous avez fini avec elle, vous avez à free() il.

Ce n'est pas pris en charge sur chaque mise en œuvre de scanf(), si.

Comme d'autres l'ont souligné, la solution la plus simple est de définir une limite sur la longueur de l'entrée. Si vous voulez toujours utiliser scanf() alors vous pouvez le faire de cette façon:
```
char m[100];
scanf("%99s",&m);
```
Noter que la taille de m[] doit être d'au moins un octet de plus grand que le nombre entre % et s.

Si la chaîne d'entrée est de plus de 99, puis le reste des personnages attendre à être lu par un autre appel ou par le reste de la chaîne de format transmis à scanf().

Généralement scanf() n'est pas recommandé pour la manipulation de la saisie de l'utilisateur. Il est préférable d'appliquer à la base de fichiers texte structurés qui ont été créé par une autre application. Même alors, vous devez être conscient que l'entrée peut ne pas être formaté comme il faut que quelqu'un peut avoir interféré avec elle pour essayer de casser votre programme.
- J'ai aussi négligé de vérifier les échecs d'allocation à l'origine.
- Notez que "%ms" n'est pas la norme C --- c'est probablement l'une extension POSIX ou une extension GNU.
- Il fait partie de la norme Posix 2008, qui est un standard. Il y avait un précédent similaire extension GNU et BSD extension; la norme Posix est destiné à unifier les différentes implémentations. C'est tout à fait possible qu'il va trouver son chemin vers un avenir C standard.
InformationsquelleAutor sh1
5

Si je peut suggérer une approche plus sûre:

Déclarer un tampon assez grand pour contenir la chaîne:

char user_input[255];

Obtenir la saisie de l'utilisateur dans un sûr façon:

fgets(user_input, 255, stdin);

Un moyen sûr pour obtenir l'entrée, le premier argument un pointeur vers une mémoire tampon dans lequel les données seront stockées, la seconde le maximum d'entrée de la fonction devrait lire, et le troisième est un pointeur sur l'entrée standard - par exemple, lorsque l'entrée utilisateur vient de.

Et en particulier la sécurité vient de la deuxième argument de la limitation de combien sera de lire ce qui empêche les dépassements de la mémoire tampon. Aussi, fgets prend soin de null-résiliation du traité de chaîne.

Plus d'informations sur cette fonction ici.

EDIT: Si vous avez besoin de faire toute la mise en forme (par exemple convertir une chaîne en nombre), vous pouvez utiliser atoi une fois que vous avez entrée.
- mais l'OP demandant qu'il ne sait pas combien il va de saisie que si il au hasard veut d'entrée avec > 255
- OMI fgets(user_input, sizeof user_input, stdin); est plus sûr.
InformationsquelleAutor Nobilis

Plus sûr et le plus rapide (doublement de la capacité) version:

char *readline(char *prompt) {
  size_t size = 80;
  char *str = malloc(sizeof(char) * size);
  int c;
  size_t len = 0;
  printf("%s", prompt);
  while (EOF != (c = getchar()) && c != '\r' && c != '\n') {
    str[len++] = c;
    if(len == size) str = realloc(str, sizeof(char) * (size *= 2));
  }
  str[len++]='char *readline(char *prompt) {
size_t size = 80;
char *str = malloc(sizeof(char) * size);
int c;
size_t len = 0;
printf("%s", prompt);
while (EOF != (c = getchar()) && c != '\r' && c != '\n') {
str[len++] = c;
if(len == size) str = realloc(str, sizeof(char) * (size *= 2));
}
str[len++]='\0';
return realloc(str, sizeof(char) * len);
}
';
  return realloc(str, sizeof(char) * len);
}

Habituellement, l'invite est fourni par le programmeur. Vous ne pouvez donc pas dire que c'est dangereux. Il peut être dangereux si le programmeur indique certains spécificateur de format dans l'invite de commandes. Mais je l'ai changé.
En multipliant par sizeof (char) est redondant; sizeof (char) est de 1 par définition.
prompt devrait être un const char *.
Vous devez vérifier tous malloc et realloc appels d'erreurs.
La multiplication incontrôlée size *= 2 risque de déborder.

InformationsquelleAutor KIM Taegyoon

1

Prendre un pointeur de caractère pour stocker la chaîne voulue.Si vous avez une idée sur une taille de chaîne puis utiliser la fonction
```
char *fgets (char *str, int size, FILE* file);`
```
autre chose que vous pouvez allouer de la mémoire à l'exécution trop l'utilisation de malloc() fonction de manière dynamique, offre mémoire demandée.

InformationsquelleAutor Dayal rai

Lire directement dans l'espace alloué avec fgets().

Une attention particulière est nécessaire de distinguer une réussite en lecture, en fin de fichier, erreur d'entrée et de sortie de la mémoire. La bonne gestion de la mémoire nécessaire sur les expressions du FOLKLORE.

Cette méthode conserve une ligne '\n'.

#include <stdio.h>
#include <stdlib.h>

#define FGETS_ALLOC_N 128

char* fgets_alloc(FILE *istream) {
  char* buf = NULL;
  size_t size = 0;
  size_t used = 0;
  do {
    size += FGETS_ALLOC_N;
    char *buf_new = realloc(buf, size);
    if (buf_new == NULL) {
      //Out-of-memory
      free(buf);
      return NULL;
    }
    buf = buf_new;
    if (fgets(&buf[used], (int) (size - used), istream) == NULL) {
      //feof or ferror
      if (used == 0 || ferror(istream)) {
        free(buf);
        buf = NULL;
      }
      return buf;
    }
    size_t length = strlen(&buf[used]);
    if (length + 1 != size - used) break;
    used += length;
  } while (buf[used - 1] != '\n');
  return buf;
}

Exemple d'utilisation

int main(void) {
  FILE *istream = stdin;
  char *s;
  while ((s = fgets_alloc(istream)) != NULL) {
    printf("'%s'", s);
    free(s);
    fflush(stdout);
  }
  if (ferror(istream)) {
    puts("Input error");
  } else if (feof(istream)) {
    puts("End of file");
  } else {
    puts("Out of memory");
  }
  return 0;
}

erreur: invalid conversion from ‘void*’ to ‘char*’ [-fpermissive]==> char *buf_new = realloc(buf, size);
Gc Quel compilateur que vous utilisez? un compilateur C ou C++ compilateur? Vous commentaire est compatible avec un compilateur C++ à l'aide de -fpermissive, mais une plainte compilateur C pas donner ce message et ce post est marqué C.
Je suis à l'aide d'un compilateur C++. Désolé, j'étais un peu confus. Mon erreur

InformationsquelleAutor chux

Je sais que je suis arrivé après 4 ans et je suis trop en retard, mais je pense que j'ai une autre façon que quelqu'un peut utiliser. J'avais utilisé getchar() Fonction comme ceci:-

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//I had putten the main Function Bellow this function.
//d for asking string,f is pointer to the string pointer
void GetStr(char *d,char **f)
{
    printf("%s",d);

    for(int i =0;1;i++)
    {    
        if(i)//I.e if i!=0
            *f = (char*)realloc((*f),i+1);
        else
            *f = (char*)malloc(i+1);
        (*f)[i]=getchar();
        if((*f)[i] == '\n')
        {
            (*f)[i]= '#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//I had putten the main Function Bellow this function.
//d for asking string,f is pointer to the string pointer
void GetStr(char *d,char **f)
{
printf("%s",d);
for(int i =0;1;i++)
{    
if(i)//I.e if i!=0
*f = (char*)realloc((*f),i+1);
else
*f = (char*)malloc(i+1);
(*f)[i]=getchar();
if((*f)[i] == '\n')
{
(*f)[i]= '\0';
break;
}
}   
}
int main()
{
char *s =NULL;
GetStr("Enter the String:- ",&s);
printf("Your String:- %s \nAnd It's length:- %lu\n",s,(strlen(s)));
free(s);
}
';
            break;
        }
    }   
}

int main()
{
    char *s =NULL;
    GetStr("Enter the String:- ",&s);
    printf("Your String:- %s \nAnd It's length:- %lu\n",s,(strlen(s)));
    free(s);
}

voici l'exemple d'exécution de ce programme:-

Enter the String:- I am Using Linux Mint XFCE 18.2 , eclispe CDT and GCC7.2 compiler!!
Your String:- I am Using Linux Mint XFCE 18.2 , eclispe CDT and GCC7.2 compiler!! 
And It's length:- 67

InformationsquelleAutor

j'ai aussi une solution standard d'entrées et de sorties

#include<stdio.h>
#include<malloc.h>
int main()
{
    char *str,ch;
    int size=10,len=0;
    str=realloc(NULL,sizeof(char)*size);
    if(!str)return str;
    while(EOF!=scanf("%c",&ch) && ch!="\n")
    {
        str[len++]=ch;
        if(len==size)
        {
            str = realloc(str,sizeof(char)*(size+=10));
            if(!str)return str;
        }
    }
    str[len++]='#include<stdio.h>
#include<malloc.h>
int main()
{
char *str,ch;
int size=10,len=0;
str=realloc(NULL,sizeof(char)*size);
if(!str)return str;
while(EOF!=scanf("%c",&ch) && ch!="\n")
{
str[len++]=ch;
if(len==size)
{
str = realloc(str,sizeof(char)*(size+=10));
if(!str)return str;
}
}
str[len++]='\0';
printf("%s\n",str);
free(str);
}
';
    printf("%s\n",str);
    free(str);
}

valeur de retour de scanf devraient être comparées pour le nombre d'éléments que vous lisez, pas EOF

InformationsquelleAutor Priyanshu Agrawal

Vous devez vous connecter pour publier un commentaire.