L'allocation de chaîne avec malloc

Je suis nouveau dans la programmation en C et maintenant, je suis étudiant en chaînes.
Ma question est: si j'alloue une aide de la chaîne de malloc (comme dans le code ci-dessous), est le caractère NULL automatiquement insérée à la fin de la chaîne?
Je trouve une réponse à une autre question, et il semble que le caractère NULL n'est pas automatiquement inclus.
Mais voici le problème: je sais que des fonctions comme strlen ne fonctionne pas s'il n'y a pas que le caractère NUL, et dans ce code je l'utilise et il fonctionne. Donc, je pense qu'il y a \0 à la fin de ma chaîne, même si je n'écris pas n'importe où.
Quelle est la réponse?

Voici le code:

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

int main(int argc, char** argv) {
    char *stringa1;
    int n;
    int i;

    printf("How many characters in the string? ");
    scanf("%d", &n);

    stringa1 = (char*) malloc(n*sizeof(char));

    printf("Insert the string: ");
    scanf("%s", stringa1);

    free(stringa1);

    return 0;
}

Votre code semble bien pour moi. scanf met le NUL (non NULLE) à la fin de la chaîne. Essayez d'appeler strlen juste avant free(stringa1).
Pour répéter ce que @MichaelWalz dit, et pour pinailler, un pointeur peut être NULL et un caractère peut être NUL.
Dans une version précédente, j'ai essayé et elle renvoie le nombre que j'ai mis dans le premier scanf().
Je ne vois pas de réel problème avec votre code, à l'exception de casting de la suite de malloc. Il n'a pas d'effets particulièrement négatifs ici, mais est considéré comme une mauvaise pratique et permet de cacher les erreurs.
Il n'y a pas de NULL caractère. NULL est une macro avec un null le pointeur constant, quelque chose de très différent. Et C n'a pas de type chaîne.

OriginalL'auteur FranzGoogle | 2017-01-24

c malloc string

11

malloc() renvoie une void* pointeur vers un bloc de mémoire stockée dans le tas. L'allocation avec malloc() ne pas initialiser une chaîne quelconque de l'espace en attente d'être occupé.Pour ajouter un null-caractère de terminaison, soit vous devez le faire vous-même, ou l'utilisation d'une fonction comme scanf(), qui ajoute ce personnage pour vous. Cela dit, vous avez besoin d'allouer de l'espace pour cette \0 caractère à l'avance.

Votre malloc() appel doit être plutôt ceci:
```
stringa1 = (char*) malloc((n+1)*sizeof(char)); /*+1 for 'stringa1 = (char*) malloc((n+1)*sizeof(char)); /*+1 for '\0' character */
' character */
```
Remarque: Vous n'avez pas besoin de jeter le retour de malloc. Pour plus d'informations, lire cette.

Une autre chose à remarquer est sizeof(char) est 1, donc en multipliant ce dans votre malloc() appel n'est pas nécessaire.

Vous devez également vérifier si malloc() retourne NULL. Cela peut être fait comme ceci:
```
if (stringa1 == NULL) {
    /* handle exit */
```
Aussi, vous pouvez uniquement utiliser strlen() sur une chaîne se terminant par null, sinon cela finit par être comportement indéfini.

Une fois scanf() est appelé, et le stringa1 contient certains caractères, vous pouvez appeler strlen() sur elle.

En outre, la vérification de retour de scanf() est aussi une bonne idée. Vous pouvez le vérifier comme ceci:
```
if (scanf("%d", &n) != 1) {
    /* handle exit */
```
Votre code avec ces modifications:
```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void) {
    char *stringa1 = NULL;
    size_t n, slen;

    printf("How many characters in the string? ");
    if (scanf("%zu", &n) != 1) {
        printf("Invalid input\n");
        exit(EXIT_FAILURE);
    }

    stringa1 = malloc(n+1);
    if (stringa1 == NULL) {
        printf("Cannot allocate %zu bytes for string\n", n+1);
        exit(EXIT_FAILURE);
    }

    printf("Insert the string: ");
    scanf("%s", stringa1);

    slen = strlen(stringa1);
    printf("String: %s Length: %zu\n", stringa1, slen);

    free(stringa1);
    stringa1 = NULL;

    return 0;
}
```
Ok, ça fonctionne. Je vous remercie beaucoup. Maintenant, j'ai seulement une question de plus: je ne comprends pas comment if(scanf("%zu", &n) != 1) { fonctionne... Désolé pour la question stupide: si j'insère une valeur différente de '1' il devrait revenir "entrée non Valide". Ou pas?
Il retourne uniquement la saisie de données incorrectes si un nombre n'a pas été lu. Donc, fondamentalement, il fait que seul 1 nombre est lu en n. scanf() vérifie juste la façon dont beaucoup de valeurs ont été lus. Dans ce cas, vous souhaitez uniquement une valeur de lecture, de Sorte que scanf() vérifie que. si vous saisissez quelque chose comme c, cela permettra de signaler une erreur, car un certain nombre n'a pas été lu. Si vous saisissez quelque chose comme 5, puis scanf a été un succès.

OriginalL'auteur RoadRunner
8

si j'affecter une chaîne à l'aide de malloc (comme dans le code ci-dessous), est le caractère NULL automatiquement insérée à la fin de la chaîne?

Pas. malloc() retourne d'un bloc de mémoire non initialisée.

Je sais que des fonctions comme 'strlen' ne fonctionne pas s'il n'y a pas que le caractère NUL, et dans ce code je l'utilise et il fonctionne. Donc, je pense qu'il est '\0' à la fin de ma chaîne, même si je n'ai pas écrit nulle part.

scanf() insère l'octet nul ('\0') pour vous lorsque vous utilisez %s spécificateur de format (en supposant que scanf() réussi).

De man scanf():

s Correspond à une séquence de non-caractères d'espacement, la prochaine
pointeur doit être un pointeur vers le premier élément d'un
tableau de caractères qui est assez long pour contenir la séquence d'entrée
et l'octet nul final ('\0'), qui est ajouté
automatiquement. La chaîne d'entrée s'arrête à un espace ou à
le maximum de la largeur de champ, selon la première éventualité.

(l'emphase est mienne).

Par le chemin, vous devriez faire la vérification des erreurs pour scanf() et malloc() appels.

Et il devrait aussi être sûr d'inclure un espace pour le null de fin d'octets dans son allocation, et il devrait protéger à l'encontre de la chaîne de la fed comme entrée pour le programme étant de plus que ce qui était promis.
Merci, mais je ne comprends pas quand vous parlez de la vérification des erreurs pour scanf() et malloc()...
renvoie le nombre d'éléments analysés avec succès; sinon, il est tombé en panne. malloc() retourne NULL si il n'a pas pu allouer de la mémoire. Donc, ce que je disais était à vous de vérifier le code de retour de ces fonctions pour vérifier si ils ont échoué. Tels que: if (scanf("%d", &n) != 1) { /* failure */} et stringa1 = (char*) malloc(n*sizeof(char)); if (stringa1 == NULL) { /* failure */} etc.
OK. Et comment puis-je le faire? Désolé, mais je suis un débutant... puis-je le vérifier avec un strlen()?
Voir la fin de mon commentaire précédent sur la façon de le faire. Vous ne savez pas comment strlen() est pertinent. strlen() retourne simplement la longueur de la chaîne (et strlen() il faut un octet null terminated string en entrée). Donc, si malloc() pas alors vous ne pouvez pas appeler strlen() sur stringa1. Vous devez juste vérifier chaque fonction de son échec.

OriginalL'auteur P.P.
1

La définition de la "chaîne" C est une séquence de caractères terminée par un caractère nul.

D'allouer de la mémoire pour une chaîne de caractères, le comte de la chracters (par exemple strlen) et ajouter 1 pour ce caractère de fin null.

Fonctions comme scanf et strcpy ajouter le caractère null; une fonction comme strncpy n'est pas toujours le faire.

Donc, c'est mon code correct? Je comprends donc...

OriginalL'auteur Paul Ogilvie
1

malloc renvoie un pointeur vers une mémoire non initialisée mesure.

Si vous voulez que la mémoire mesure serait initialisé par des zéros, alors vous pouvez utiliser une autre fonction standard calloc au lieu de malloc.

Prendre en compte généralement que ces une question comme ça
```
printf("How many characters in the string? ");
```
implique que la terminaison zéro n'est pas compté. Donc, vous devez allouer un octet de plus de mémoire. Par exemple
```
stringa1 = ( char* )malloc( ( n + 1 ) *sizeof( char ) );
```
ou
```
stringa1 = ( char* )calloc( n + 1, sizeof( char ) );
```
Dans le dernier cas, vous pouvez appliquer la fonction strlen qui renvoie 0 car la mémoire mesure est initialisé à zéro.

Cet appel de scanf
```
scanf("%s", stringa1);
```
est dangereux. Il est préférable d'utiliser fgets à la place. Par exemple
```
fgets( stringa1, n + 1, stdin );
```
Cette fonction peut ajouter la chaîne avec le caractère de nouvelle ligne. Pour la retirer de la chaîne, vous pouvez écrire
```
stringa1[strcspn( stringa1, "\n" )] = 'stringa1[strcspn( stringa1, "\n" )] = '\0';
';
```
OriginalL'auteur Vlad from Moscow

Vous devez vous connecter pour publier un commentaire.