Segmentatiefout (kern gedumpt) als gevolg van FGETS – ik denk

Maar ik krijg deze foutmelding wanneer ik dit programma uitvoer. Ik denk dat het vanwege de FUNS-functie is. Ik heb geprobeerd de inputvariabele te initialiseren om te zien of dat zal helpen, maar het niet. Ik heb ook een hut die ik misschien nodig heb om het probleem op te lossen. Maar uw hulp wordt zeer op prijs gesteld.

int main(int argc, char* argv[])
{
    char* input = NULL;
    // ensure one and only one command line argument
    if (argc != 2)
    {
        printf("Usage: %s [name of document]\n", argv[0]);
        return 1;
    }
    // open a new document for writing
    FILE* fp = fopen(argv[1], "w");
    // check for successful open
    if(fp == NULL)
    {
        printf("Could not create %s\n", argv[1]);
        return 2;
    }
    // get text from user and save to file
    while(true)
    {
        // get text from user
        printf("Enter a new line of text (or \"quit\"):\n");
        fgets(input, 50, stdin);
        // if user wants to quit
        if (input != NULL && strcmp(input, "quit") == 0)
        {
            free(input);
            break;
        }
        // if user wants to enter text
        else if (input != NULL)
        {
            fputs(input, fp);
            fputs("\n", fp);
            printf("CHA-CHING!\n\n");
            free(input);
        }
    }
    // close the file and end successfuly
    fclose(fp);
    return 0;
}

Antwoord 1

Terwijl u malloc()hier kunt gebruiken, is het niet echt nodig. U kunt #defineeen redelijke maximale lijnlengte en verklaren een tekenreeks om de invoer vast te houden. Als u dit doet, kunt u de frees uit uw code verwijderen.

Je hebt ook een probleem met de manier waarop je fgets()gebruikt. De achterliggende \nwordt bewaard door fgets(), maar uw vergelijkingen negeren dit. Bijgevolg is inputnooit gelijk aan "quit", en zeker nooit NULL. Ik heb wat code toegevoegd die de laatste nieuwe regel verwijdert na het lezen in input; de code wist ook alle resterende tekens uit de invoerstroom, wat mogelijk is in het geval dat de gebruiker meer dan MAXLINE - 1tekens invoert. De test voor tekstinvoer is dan gewoon if (input[0]). Als alternatief kunt u uw tests wijzigen om rekening te houden met het extra ‘\n’-teken.

#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#define MAXLINE  1000
int main(int argc, char* argv[])
{
    char input[MAXLINE];
    char *ch;                       // used to remove newline
    char c;                         // used to clear input stream
    // ensure one and only one command line argument
    if (argc != 2)
    {
        printf("Usage: %s [name of document]\n", argv[0]);
        return 1;
    }
    // open a new document for writing
    FILE* fp = fopen(argv[1], "w");
    // check for successful open
    if(fp == NULL)
    {
        printf("Could not create %s\n", argv[1]);
        return 2;
    }
    // get text from user and save to file
    while(true)
    {
        // get text from user
        printf("Enter a new line of text (or \"quit\"):\n");
        fgets(input, MAXLINE, stdin);
        //  remove trailing newline
        ch = input;
        while (*ch != '\n' &&  *ch != '\0') {
            ++ch;
        }
        if (*ch) {
            *ch = '\0';
        } else {         // remove any extra characters in input stream
            while ((c = getchar()) != '\n' && c != EOF)
                continue;
        }
        // if user wants to quit
        if (strcmp(input, "quit") == 0)
        {
            break;
        }
        // if user wants to enter text
        else if (input[0])
        {
            fputs(input, fp);
            fputs("\n", fp);
            printf("CHA-CHING!\n\n");
        }
    }
    // close the file and end successfuly
    fclose(fp);
    return 0;
}

Antwoord 2, autoriteit 90%

Je malloc-ed nooit input, dus ja, fgetsverwijst naar de NULL-aanwijzer als buffer , en dat gaat dood. Verander inputin een stackarray (en verwijder de freeervoor) of bel mallocom geheugen toe te wijzen zodat inputverwijst niet naar NULL.

Antwoord 3

Ik denk dat het komt door de fgets-functie.

Ja: het doorgeven van de NULL-aanwijzer aan fgetsheeft geen zin, is niet toegestaan en veroorzaakt een crash.

Misschien moet ik een malloc gebruiken om het probleem op te lossen.

Je moet een aanwijzer doorgeven aan een geschiktebuffer voor fgetsom invoer in te lezen. Of die buffer nu malloced, een lokale of een globale array is, is irrelevant.

TL;DR: denk naover wat je doet.

Antwoord 4

Er zijn enkele problemen in uw code.

1. Je hebt geen geheugen toegewezen aan de invoertekenaanwijzer. Daarom kun je er geen karakters in opslaan, dus krijg je een segmentatiefout.

2. U bent ook vrijmeer dan eens, wat niet klopt.

Dus, een code, met de bovenstaande modificatie zou zoiets zijn als deze:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char* argv[])
{
      char* input = malloc(sizeof(char) * 50);
      // ensure one and only one command line argument
      if (argc != 2)
      {
          printf("Usage: %s [name of document]\n", argv[0]);
          return 1;
      }
      // open a new document for writing
      FILE* fp = fopen(argv[1], "w");
      // check for successful open
      if(fp == NULL)
      {
          printf("Could not create %s\n", argv[1]);
          return 2;
      }
      // get text from user and save to file
      while(1)
      {
          // get text from user
          printf("Enter a new line of text (or \"quit\"):\n");
          fgets(input, 50, stdin);
          // if user wants to quit
          if (input != NULL && strcmp(input, "quit\n") == 0)
          {
              free(input);
              break;
          }
          // if user wants to enter text
          else if (input != NULL)
          {
              fputs(input, fp);
              fputs("\n", fp);
              printf("CHA-CHING!\n\n");
              // free(input);
          }
      }
      // close the file and end successfuly
      fclose(fp);
      return 0;
}

Ik hoop dat het uw probleem helpt.
Proost.