SHARE
TWEET

funktionen.cpp

a guest Apr 3rd, 2019 76 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "funktionen.h"
  2. #include "fhswf_service.h"
  3. #include "service.h"
  4.  
  5.  
  6.  
  7. void dateiinhalt_loeschen(struct Student *person, int anzahl, FILE* meine_datei)
  8. {
  9.     int nummer, ueberspringen, fehler, auswahl = -1;
  10.     char eingabem[EINGABELIMIT] = { 0 };
  11.     char ende[5] = { "ende" };
  12.     char beenden[20];
  13.  
  14.     do
  15.     {
  16.         printf("\nGeben sie 'ende' ein um abzubrechen");
  17.         printf("\nWelcher Eintrag soll geloescht werden [matrikelnummer]   ", anzahl - 1);
  18.         scanf("%s", eingabem);
  19.         tastaturpuffer_leeren();
  20.  
  21.         strcpy(beenden, eingabem);
  22.  
  23.         fehler = checkInput_int(eingabem, strlen(eingabem)); // fehleingaben abfangen
  24.  
  25.         nummer = atoi(eingabem);
  26.  
  27.         rewind(meine_datei);
  28.  
  29.         for (int index = 0; index < anzahl; index++)
  30.         {
  31.             datei_lesen(person, meine_datei);
  32.  
  33.             if (person->matrikelnummer == nummer)
  34.             {
  35.                 auswahl = index;
  36.                 index = anzahl;
  37.             }
  38.         }
  39.  
  40.         if (strcmp(beenden, ende) == 0)
  41.         {
  42.             fehler = 0;
  43.             auswahl = 1;
  44.         }
  45.  
  46.         if (fehler > 0 || auswahl < 0)
  47.         {
  48.             printf("Fehler in der Eingabe !\n");
  49.  
  50.  
  51.             getchar();
  52.         }
  53.     } while (fehler > 0 || auswahl < 0);
  54.  
  55.  
  56.     // überspringt die zeichen die nicht verändert werden sollen
  57.     ueberspringen = (auswahl * MAXBYTES);
  58.  
  59.     rewind(meine_datei);
  60.     fseek(meine_datei, ueberspringen, SEEK_SET);
  61.  
  62.     strcpy(person->name, "GELOESCHT");
  63.     strcpy(person->vorname, "GELOESCHT");
  64.     person->mathe_z = 0;
  65.     person->programmieren_z = 0;
  66.     person->datenstrukturen_z = 0;
  67.     person->matrikelnummer = -1;
  68.  
  69.     fwrite(person, 76, 1, meine_datei);
  70.  
  71.  
  72. }
  73.  
  74.  
  75.  
  76. //-------------------Datei oeffnen zum Lesen und Schreiben -----------------------
  77. FILE* datei_oeffnen()
  78. {
  79.     FILE* meine_datei;
  80.  
  81.     meine_datei = fopen(DATEINAME, "ab+");
  82.  
  83.     // wenn nicht erfolgreich --> Fehler zurückgeben und Programm beenden
  84.     if (!meine_datei)
  85.     {
  86.         return(NULL);
  87.     }
  88.  
  89.     return(meine_datei);
  90. }
  91.  
  92.  
  93. //-------------------Datei oeffnen zum Lesen und Schreiben -----------------------
  94. FILE* datei_oeffnen_aendern()
  95. {
  96.     FILE* meine_datei;
  97.  
  98.     meine_datei = fopen(DATEINAME, "rb+");
  99.  
  100.     // wenn nicht erfolgreich --> Fehler zurückgeben und Programm beenden
  101.     if (!meine_datei)
  102.     {
  103.         return(NULL);
  104.     }
  105.  
  106.     return(meine_datei);
  107. }
  108.  
  109.  
  110. //-------------------Dateigroesse bestimmen ----------------------
  111. int get_dateigroesse(FILE* meine_datei)
  112. {
  113.     int dummy = 0, anzahl = 0;
  114.  
  115.     // da beim Öffnen Dateipositionszeiger ggf. am Ende
  116.     rewind(meine_datei);
  117.  
  118.     // Datei lesen und Einträge zählen
  119.     do
  120.     {
  121.         fread(&dummy, 1, 1, meine_datei);
  122.         anzahl++;
  123.     } while (!feof(meine_datei));
  124.  
  125.     dummy = 0;
  126.  
  127.     // da feof() erst nach Zugriff über Dateiende Wert ändert
  128.     anzahl--;
  129.     anzahl = anzahl / MAXBYTES;
  130.     // Dateipositionszeiger wieder auf Anfang
  131.     rewind(meine_datei);
  132.     return(anzahl);
  133. }
  134.  
  135.  
  136. //----------------------Daten aus Datei lesen -----------------------------
  137. void datei_lesen(struct Student *person1, FILE* meine_datei)
  138. {
  139.     int index, groesse;
  140.  
  141.     groesse = sizeof(struct Student);
  142.  
  143.     // Daten aus Datei lesen  und in Feld schreiben
  144.     fread(person1, groesse, 1, meine_datei);
  145. }
  146.  
  147. //-----------------------------Daten eingeben -------------------------------
  148. int daten_eingeben(struct Student *person, FILE* meine_datei, int fall)
  149. {
  150.     int laenge;
  151.     int anzahl1;
  152.     char eingabeN[EINGABELIMIT] = { 0 };
  153.     char eingabeV[EINGABELIMIT] = { 0 };
  154.     char eingabe_matrikelnummer[EINGABELIMIT] = { 0 };
  155.     char eingabe_zensuren[EINGABELIMIT] = { 0 };
  156.     char matrikelnummer_feld[EINGABELIMIT] = { 0 };
  157.     int matrikelnummer, input, fehler;
  158.     float mathe_z;
  159.     float datenstruktur_z;
  160.     float programmieren_z;
  161.     char ende[5] = { "ende" };
  162.     int restart = 0; int index = 0;
  163.     if (fall == 1)
  164.     {
  165.         printf("Die Eingabe wird mit \"ende\" beendet.");
  166.         do
  167.         {
  168.             restart = 0;
  169.  
  170.             for (int index = 0; index < EINGABELIMIT; index++)
  171.             {
  172.                 eingabeN[index] = 0;
  173.                 eingabeV[index] = 0;
  174.             }
  175.  
  176.             printf("\nName eingaben: ");
  177.             gets_s(eingabeN);
  178.  
  179.             if (!strcmp(eingabeN, ende))
  180.                 continue;
  181.  
  182.             printf("Vorname eigeben: ");
  183.             gets_s(eingabeV);
  184.  
  185.             if (eingabeN[0] == 0 || eingabeV == 0)
  186.             {
  187.                 printf("Fehleingabe!");
  188.                 restart = 1;
  189.             }
  190.  
  191.             do
  192.             {
  193.                 printf("Matrikelnummer eingeben: ");
  194.                 scanf("%s", eingabe_matrikelnummer);
  195.                 tastaturpuffer_leeren();
  196.  
  197.                 fehler = checkInput_int(eingabe_matrikelnummer, strlen(eingabe_matrikelnummer));
  198.  
  199.                 laenge = strlen(eingabe_matrikelnummer);
  200.  
  201.                 if (laenge != maximum)
  202.                 {
  203.                     printf("\nMatrikelnummer muss aus %i Zahlen bestehen!\n", maximum);
  204.                     fehler++;
  205.                 }
  206.  
  207.                 matrikelnummer = atoi(eingabe_matrikelnummer);
  208.  
  209.                 anzahl1 = get_dateigroesse(meine_datei);
  210.  
  211.                 for (int index = 0; index < anzahl1; index++)
  212.                 {
  213.                     datei_lesen(person, meine_datei);
  214.  
  215.                     if (person->matrikelnummer == matrikelnummer)
  216.                     {
  217.                         index = anzahl1;
  218.                         fehler++;
  219.                         printf("\nIdentische Matrikelnummer existiert bereits!\n");
  220.                     }
  221.                 }
  222.  
  223.                 for (int index = 0; index < get_dateigroesse(meine_datei) + 1; index++)
  224.                 {
  225.                     if (matrikelnummer_feld[index] == matrikelnummer)
  226.                     {
  227.                         printf("\nLeider Falsche Matrikelnummer! \n");
  228.                         printf("Jede Matrikelnummer darf nur einmal vorhanden sein!! \n\n");
  229.                         fehler++;
  230.                     }
  231.                     if (matrikelnummer_feld[index] == 0 && fehler == 0)
  232.                     {
  233.                         matrikelnummer_feld[index] = matrikelnummer;
  234.                     }
  235.                 }
  236.             } while (fehler > 0);
  237.  
  238.  
  239.             do
  240.             {
  241.                 printf("Mathe Zensur eingeben: ");
  242.                 scanf("%s", eingabe_zensuren);
  243.                 tastaturpuffer_leeren();
  244.  
  245.                 fehler = checkInput_float(eingabe_zensuren, strlen(eingabe_zensuren));
  246.  
  247.                 mathe_z = atof(eingabe_zensuren);
  248.             } while (fehler > 0);
  249.             do
  250.             {
  251.                 printf("Programmieren Zensur eingeben: ");
  252.                 scanf("%s", eingabe_zensuren);
  253.                 tastaturpuffer_leeren();
  254.  
  255.                 fehler = checkInput_float(eingabe_zensuren, strlen(eingabe_zensuren));
  256.  
  257.                 programmieren_z = atof(eingabe_zensuren);
  258.             } while (fehler > 0);
  259.             do
  260.             {
  261.                 printf("Datenstruktur Zensur eingeben: ");
  262.                 scanf("%s", eingabe_zensuren);
  263.                 tastaturpuffer_leeren();
  264.  
  265.                 fehler = checkInput_float(eingabe_zensuren, strlen(eingabe_zensuren));
  266.  
  267.                 datenstruktur_z = atof(eingabe_zensuren);
  268.             } while (fehler > 0);
  269.  
  270.             if (restart == 0)
  271.             {
  272.                 strcpy(person->vorname, eingabeV);
  273.                 strcpy(person->name, eingabeN);
  274.                 person->matrikelnummer = matrikelnummer;
  275.  
  276.                 person->mathe_z = mathe_z;
  277.                 person->programmieren_z = programmieren_z;
  278.                 person->datenstrukturen_z = datenstruktur_z;
  279.  
  280.                 datei_schreiben(person, meine_datei);
  281.  
  282.             }
  283.  
  284.         } while (restart == 1 || strcmp(eingabeN, ende));
  285.         return 0;
  286.     }
  287.     else
  288.     {
  289.         do
  290.         {
  291.             restart = 0;
  292.             for (index = 0; index < EINGABELIMIT; index++)
  293.             {
  294.                 eingabeN[index] = 0;
  295.                 eingabeV[index] = 0;
  296.             }
  297.  
  298.             do
  299.             {
  300.                 printf("Mathe Zensur eingeben: ");
  301.                 scanf("%s", eingabe_zensuren);
  302.                 tastaturpuffer_leeren();
  303.  
  304.                 fehler = checkInput_float(eingabe_zensuren, strlen(eingabe_zensuren));
  305.  
  306.                 mathe_z = atof(eingabe_zensuren);
  307.             } while (fehler > 0);
  308.             do
  309.             {
  310.                 printf("Programmieren Zensur eingeben: ");
  311.                 scanf("%s", eingabe_zensuren);
  312.                 tastaturpuffer_leeren();
  313.  
  314.                 fehler = checkInput_float(eingabe_zensuren, strlen(eingabe_zensuren));
  315.  
  316.                 programmieren_z = atof(eingabe_zensuren);
  317.             } while (fehler > 0);
  318.             do
  319.             {
  320.                 printf("Datenstruktur Zensur eingeben: ");
  321.                 scanf("%s", eingabe_zensuren);
  322.                 tastaturpuffer_leeren();
  323.  
  324.                 fehler = checkInput_float(eingabe_zensuren, strlen(eingabe_zensuren));
  325.  
  326.                 datenstruktur_z = atof(eingabe_zensuren);
  327.             } while (fehler > 0);
  328.             person->mathe_z = mathe_z;
  329.             person->programmieren_z = programmieren_z;
  330.             person->datenstrukturen_z = datenstruktur_z;
  331.  
  332.         } while (restart == 1);
  333.         return(1);
  334.  
  335.     }
  336.  
  337.  
  338.  
  339. }
  340.  
  341.  
  342. //Daten in Datei schreiben
  343. void datei_schreiben(struct Student *person, FILE* meine_datei)
  344. {
  345.     // Dateipositionszeiger ans Ende
  346.     fseek(meine_datei, 0, SEEK_END);
  347.     // Feldelemente in Datei schreiben
  348.     fwrite(person, 76, 1, meine_datei);
  349. }
  350.  
  351. //Schreibt neuen zensuren in die Datei
  352. void datei_schreiben_ersetzen(struct Student *person, FILE* meine_datei)
  353. {
  354.  
  355.     fwrite(&person->mathe_z, 4, 1, meine_datei);
  356.     fwrite(&person->programmieren_z, 4, 1, meine_datei);
  357.     fwrite(&person->datenstrukturen_z, 4, 1, meine_datei);
  358.  
  359.  
  360. }
  361.  
  362.  
  363. //Dateiinhalt  ändern
  364. void dateiinhalt_aendern(struct Student *person, int anzahl, FILE* meine_datei)
  365. {
  366.  
  367.     int position_neu, position, ueberspringen, auswahl = -1;// Variable zum Navigieren in der Datei
  368.  
  369.     int nummer, neuer_wert, fehler = 0;             // Variablen für neuen Wert
  370.     char zeichen, eingabem[EINGABELIMIT] = { 0 };
  371.     int durchlauf = 0;
  372.     char beenden[20];
  373.     char ende[5] = { "ende" };
  374.  
  375.     rewind(meine_datei);                   // Dateipositionszeiger auf Anfang    
  376.  
  377.     position = 0;
  378.  
  379.     // Schleife für mehrere Änderungen
  380.     do
  381.     {
  382.         // Schleife für Fehleingaben  
  383.         do
  384.         {
  385.             printf("\nGeben sie 'ende' ein um abzubrechen");
  386.             printf("\nWelcher Eintrag soll veraendert werden [matrikelnummer]   ", anzahl - 1);
  387.             scanf("%s", eingabem);
  388.             tastaturpuffer_leeren();
  389.  
  390.             strcpy(beenden, eingabem);
  391.  
  392.             fehler = checkInput_int(eingabem, strlen(eingabem)); // fehleingaben abfangen
  393.  
  394.             nummer = atoi(eingabem);
  395.  
  396.             rewind(meine_datei);
  397.  
  398.             for (int index = 0; index < anzahl; index++)
  399.             {
  400.                 datei_lesen(person, meine_datei);
  401.  
  402.                 if (person->matrikelnummer == nummer)
  403.                 {
  404.                     auswahl = index;
  405.                     index = anzahl;
  406.                 }
  407.             }
  408.  
  409.             if (strcmp(beenden, ende) == 0)
  410.             {
  411.                 fehler = 0;
  412.                 auswahl = 1;
  413.             }
  414.  
  415.             if (fehler > 0 || auswahl < 0)
  416.             {
  417.                 printf("Fehler in der Eingabe !\n");
  418.  
  419.                 getchar();
  420.             }
  421.  
  422.  
  423.  
  424.         } while (fehler > 0 || auswahl < 0);
  425.  
  426.         if (strcmp(beenden, ende) == 0)
  427.         {
  428.             zeichen = 'N';
  429.             continue;
  430.         }
  431.  
  432.         ueberspringen = (auswahl * MAXBYTES) + 64;
  433.  
  434.         rewind(meine_datei);
  435.         fseek(meine_datei, ueberspringen, SEEK_SET);
  436.  
  437.         daten_eingeben(person, meine_datei, 2);
  438.  
  439.         datei_schreiben_ersetzen(person, meine_datei);
  440.  
  441.         printf("\nNoch eine Aenderung ? J/N   ");
  442.         scanf("%c", &zeichen);
  443.         tastaturpuffer_leeren();
  444.  
  445.  
  446.  
  447.         // wandeln in Großbuchstaben
  448.         zeichen = toupper(zeichen);
  449.  
  450.         durchlauf++;
  451.     } while (zeichen == 'J');
  452. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top