API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 26th, 2014
136
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 22.05 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. FILE* TabelleOeffnen(char*);
  6. FILE* TabelleErstellen(char*);
  7. void  TabelleAnzeigen(FILE*, char*);
  8. void  TabelleQuersummeHinzufuegen(FILE*, char*);
  9. void  TabelleLaengssummeHinzufuegen(FILE*, char*);
  10. void  TabelleZeileEinfuegen(FILE*, char*, char*, int);
  11. void  TabelleZeileAendern(FILE*, char*, char*, int);
  12. void  TabelleZeileEntfernen(FILE*, char*, int);
  13. void  TabelleLoeschen();
  14. void  Bubblesort(int[], int, int);
  15.  
  16. int main()
  17. {
  18.     FILE* paktuelletabelle = 0;
  19.     int iwahl = 0;
  20.     char sztabelle[50] = { 0 };
  21.  
  22.  
  23.     do
  24.     {
  25.         system("cls");
  26.         if(paktuelletabelle)
  27.         {
  28.             printf("Aktuelle Tabelle: %s\n", sztabelle);
  29.         }
  30.         else
  31.         {
  32.             puts("Willkommmen im Tabellenprogramm!");
  33.         }
  34.         puts("Bitte eine Funktion auswaehlen\n"
  35.              "[n] neue Tabelle erstellen\n"
  36.              "[o] eine Tabelle oeffnen\n"
  37.              "[l] eine Tabelle loeschen\n"
  38.              "[a] Tabelle anzeigen\n"
  39.              "[x] Programm beenden");
  40.         fflush(stdin);
  41.         iwahl = getch();
  42.         system("cls");
  43.         switch (iwahl)
  44.         {
  45.         case 'n':
  46.             if ( paktuelletabelle )
  47.             {
  48.                 fclose(paktuelletabelle);
  49.             }
  50.             paktuelletabelle = TabelleErstellen(sztabelle);
  51.             if ( !paktuelletabelle )
  52.             {
  53.                 puts("Fehler beim erstellen der Tabelle");
  54.                 system("pause");
  55.             }
  56.             break;
  57.         case 'o':
  58.             if ( paktuelletabelle )
  59.             {
  60.                 fclose(paktuelletabelle);
  61.             }
  62.  
  63.             paktuelletabelle = TabelleOeffnen(sztabelle);
  64.             if ( !paktuelletabelle )
  65.             {
  66.                 puts("Fehler beim laden der Tabelle");
  67.                 system("pause");
  68.             }
  69.             break;
  70.         case 'l':
  71.             TabelleLoeschen();
  72.             break;
  73.         case 'a':
  74.             if ( paktuelletabelle )
  75.             {
  76.                 TabelleAnzeigen(paktuelletabelle, sztabelle);
  77.             }
  78.             else
  79.             {
  80.                 puts("Keine Tabelle vorhanden");
  81.                 system("Pause");
  82.             }
  83.             break;
  84.         case 'x':
  85.         case 'X':
  86.         {
  87.             if (paktuelletabelle)
  88.             {
  89.                 fclose(paktuelletabelle);
  90.             }
  91.             return 0;
  92.         }
  93.         default:
  94.             puts("Falsche eingabe");
  95.             system("Pause");
  96.             break;
  97.         }
  98.     }
  99.     while(1);
  100.  
  101.  
  102.  
  103.     return 0;
  104. }
  105.  
  106. FILE* TabelleOeffnen(char* szdateiname)
  107. {
  108.     system("cls");
  109.     puts("Bitte Dateinamen eingeben:");
  110.     fflush(stdin);
  111.     gets(szdateiname);
  112.     strcat(szdateiname, ".txt");
  113.     return fopen(szdateiname, "r+");
  114. }
  115. FILE* TabelleErstellen(char* szdateiname)
  116. {
  117.     system("cls");
  118.     puts("Bitte Dateinamen eingeben:");
  119.     fflush(stdin);
  120.     gets(szdateiname);
  121.     strcat(szdateiname, ".txt");
  122.     FILE* fTabelle = 0;
  123.     fTabelle = fopen(szdateiname, "w+");
  124.     if(fTabelle)
  125.     {
  126.         int izeilen, ispalten;
  127.         puts("Bitte Anzahl Zeilen angeben (max. 99):");
  128.         fflush(stdin);
  129.         scanf("%i", &izeilen);
  130.         //TODO: prüfen ob max 99
  131.         fprintf(fTabelle, "%i ", izeilen);
  132.         puts("Bitte Anzahl Spalten angeben (max. 10):");
  133.         fflush(stdin);
  134.         scanf("%i", &ispalten);
  135.         //TODO: prüfen ob max 10
  136.         fprintf(fTabelle, "%i\n", ispalten);
  137.         int i;
  138.         for(i = 0; i < izeilen; i++)
  139.         {
  140.             int j;
  141.             for(j = 0; j < ispalten; j++)
  142.             {
  143.                 fprintf(fTabelle, "%6i", rand() % 20);
  144.             }
  145.             fprintf(fTabelle, "\n");
  146.         }
  147.     }
  148.     return fTabelle;
  149. }
  150.  
  151. void TabelleLoeschen()
  152. {
  153.     char szdateiname[50] = { 0 };
  154.     system("cls");
  155.     puts("Bitte Dateinamen eingeben:");
  156.     fflush(stdin);
  157.     gets(szdateiname);
  158.     strcat(szdateiname, ".txt");
  159.     remove(szdateiname);
  160. }
  161.  
  162. void TabelleAnzeigen(FILE* ptabelle, char* szdateiname)
  163. {
  164.     static int izeile = 1;
  165.     int izeilen, ispalten;
  166.     char szzeile[1024] = { 0 };
  167.     int iwahl;
  168.     do
  169.     {
  170.         int i;
  171.         system("cls");
  172.         rewind(ptabelle);
  173.         fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  174.         printf("Zeile %i bis %i von %i:\n\n", izeile, (izeile + 4 > izeilen) ? izeilen : izeile + 4, izeilen);
  175.         //Kopfzeile:
  176.         printf("      ");
  177.         for(i = 0; i < ispalten; i++)
  178.         {
  179.             printf("  [%2i]", i + 1);
  180.         }
  181.         printf("   |min| |max|\n");
  182.  
  183.  
  184.         fgets(szzeile, sizeof(szzeile), ptabelle); //headerzeile überspringen
  185.  
  186.         int izellen[10][99] = { 0 };
  187.  
  188.  
  189.         //komplette tabelle einlesen
  190.         for(i = 0; i < izeilen; i++)
  191.         {
  192.             char* sztoken = 0;
  193.             int iindex_token;
  194.  
  195.             fgets(szzeile, sizeof(szzeile), ptabelle);
  196.             sztoken = strtok(szzeile, " ");
  197.             iindex_token = -1;
  198.             while(sztoken != 0)
  199.             {
  200.                 iindex_token++;
  201.                 if(iindex_token >= 10)
  202.                 {
  203.                     break;
  204.                 }
  205.                 izellen[iindex_token][i] = atoi(sztoken);
  206.                 //nächste zahl lesen
  207.                 sztoken = strtok(0, " ");
  208.             }
  209.         }
  210.  
  211.  
  212.  
  213.         //auswahl anzeigen
  214.         for(i = izeile - 1; i < izeilen && i < izeile + 4; i++)
  215.         {
  216.             int imin = 9999;
  217.             int imax = 0;
  218.             int j;
  219.             printf(" [%2i] ", i + 1);
  220.             for(j = 0; j < ispalten; j++)
  221.             {
  222.                 printf("%6i", izellen[j][i]);
  223.  
  224.                 if(abs(izellen[j][i]) < imin)
  225.                 {
  226.                     imin = abs(izellen[j][i]);
  227.                 }
  228.                 if(abs(izellen[j][i]) > imax)
  229.                 {
  230.                     imax = abs(izellen[j][i]);
  231.                 }
  232.             }
  233.             printf("  %6i%6i\n", imin, imax);
  234.  
  235.         }
  236.  
  237.         printf("\n |min|");
  238.  
  239.         for(i = 0; i < ispalten; i++)
  240.         {
  241.             int imin = 9999;
  242.             int j;
  243.             for(j = 0; j < izeilen; j++)
  244.             {
  245.                 if(abs(izellen[i][j]) < imin)
  246.                 {
  247.                     imin = abs(izellen[i][j]);
  248.                 }
  249.             }
  250.             printf("%6i", imin);
  251.         }
  252.         printf("\n |max|");
  253.         for(i = 0; i < ispalten; i++)
  254.         {
  255.             int imax = 0;
  256.             int j;
  257.             for(j = 0; j < izeilen; j++)
  258.             {
  259.                 if(abs(izellen[i][j]) > imax)
  260.                 {
  261.                     imax = abs(izellen[i][j]);
  262.                 }
  263.             }
  264.             printf("%6i", imax);
  265.         }
  266.  
  267.  
  268.         puts("\nBitte eine Funktion auswaehlen\n"
  269.              "[PFEIL HOCH]   -1 Zeile\n"
  270.              "[PFEIL RUNTER] +1 Zeile\n"
  271.              "[BILD HOCH]    -1 Seite\n"
  272.              "[BILD RUNTER]  +1 Seite\n"
  273.              "[h] Zeile hinzufuegen\n"
  274.              "[a] Zeile aendern\n"
  275.              "[e] Zeile entfernen\n"
  276.              "[l] Laengssummen berechnen\n"
  277.              "[q] Quersummen berechnen\n"
  278.              "[s] Spalte sortieren\n"
  279.              "[x] Zurueck");
  280.         fflush(stdin);
  281.         iwahl = getch();
  282.  
  283.         switch (iwahl)
  284.         {
  285.         case 72: //pfeil hoch
  286.         {
  287.             if(izeile > 1) izeile--;
  288.         }
  289.         break;
  290.         case 80: //pfeil runter
  291.         {
  292.             if(izeile + 4 < izeilen) izeile++;
  293.         }
  294.         break;
  295.         case 73: //bild hoch
  296.         {
  297.             if(izeile - 5 >= 1 ) izeile -= 5;
  298.         }
  299.         break;
  300.         case 81: //bild runter
  301.         {
  302.             if(izeile + 4 + 5 <= izeilen) izeile += 5;
  303.         }
  304.         break;
  305.         case 'h':
  306.         {
  307.             char szeingabe[1024] = { 0 };
  308.             char szzeile[100] = { 0 };
  309.  
  310.             int izeile_neu = 0;
  311.             puts("Zeilennummer vor der eingefuegt werden soll eingeben\n"
  312.                  "oder nichts eingeben wenn automatisch am Ende eingefuegt werden soll:");
  313.             fflush(stdin);
  314.             gets(szeingabe);
  315.             if(strlen(szeingabe) == 0)
  316.             {
  317.                 puts("Zeile wird am Ende der Tabelle angefuegt");
  318.                 izeile_neu = izeilen + 1;
  319.             }
  320.             else if(sscanf(szeingabe, "%i", &izeile_neu) != 1)
  321.             {
  322.                 puts("Ungueltige Eingabe, Zeile wird am Ende der Tabelle angefuegt");
  323.                 izeile_neu = izeilen + 1;
  324.             }
  325.             else if(izeile_neu < 1)
  326.             {
  327.                 puts("Ungueltige Zeilennummer (< 1), Zeile wird am Anfang der Tabelle eingefuegt");
  328.                 izeile_neu = 1;
  329.             }
  330.             else if(izeile_neu > izeilen + 1)
  331.             {
  332.                 puts("Ungueltige Zeilennummer (> Anzahl Zeilen + 1), Zeile wird am Ende der Tabelle angefuegt");
  333.                 izeile_neu = izeilen + 1;
  334.             }
  335.             else
  336.             {
  337.                 printf("Neue Zeile wird vor Zeile %i eingefuegt\n", izeile_neu);
  338.             }
  339.             puts("Bitte Werte fuer neue Zeile eingeben:");
  340.             fflush(stdin);
  341.  
  342.  
  343.  
  344.             gets(szeingabe);
  345.             char* sztoken = 0;
  346.             int itoken;
  347.             char sztoken_neu[7] = { 0 };
  348.             sztoken = strtok(szeingabe, " ");
  349.             int ianzahl_token = 0;
  350.             while(sztoken != 0)
  351.             {
  352.                 ianzahl_token++;
  353.                 //zu viele Werte ignorieren
  354.                 if(ianzahl_token > ispalten)
  355.                 {
  356.                     break;
  357.                 }
  358.  
  359.                 itoken = atoi(sztoken);
  360.                 if(itoken > 9999)
  361.                 {
  362.                     itoken = 9999;
  363.                 }
  364.                 else if(itoken < -9999)
  365.                 {
  366.                     itoken = -9999;
  367.                 }
  368.                 sprintf(sztoken_neu, "%6i", itoken);
  369.                 strcat(szzeile, sztoken_neu);
  370.  
  371.                 //naechste Zahl lesen
  372.                 sztoken = strtok(0, " ");
  373.             }
  374.  
  375.             //zu wenige Werte mit 0 auffüllen
  376.             int inullen = 0;
  377.             while(inullen < (ispalten - ianzahl_token))
  378.             {
  379.                 strcat(szzeile, "     0");
  380.                 inullen++;
  381.             }
  382.  
  383.             strcat(szzeile, "\n");
  384.  
  385.             TabelleZeileEinfuegen(ptabelle, szdateiname, szzeile, izeile_neu);
  386.  
  387.         }
  388.         break;
  389.         case 'a':
  390.         {
  391.             char szeingabe[1024] = { 0 };
  392.             char szzeile[100] = { 0 };
  393.  
  394.             int izeile_neu = 0;
  395.             puts("Zeilennummer der zu editierenden Zeile:");
  396.             fflush(stdin);
  397.             scanf("%i", &izeile_neu);
  398.             puts("Bitte neue Werte eingeben:");
  399.             fflush(stdin);
  400.             gets(szeingabe);
  401.             char* sztoken = 0;
  402.             int itoken;
  403.             char sztoken_neu[7] = { 0 };
  404.             sztoken = strtok(szeingabe, " ");
  405.             int ianzahl_token = 0;
  406.             while(sztoken != 0)
  407.             {
  408.                 ianzahl_token++;
  409.                 //zu viele Werte ignorieren
  410.                 if(ianzahl_token > ispalten)
  411.                 {
  412.                     break;
  413.                 }
  414.  
  415.                 itoken = atoi(sztoken);
  416.                 if(itoken > 9999)
  417.                 {
  418.                     itoken = 9999;
  419.                 }
  420.                 else if(itoken < -9999)
  421.                 {
  422.                     itoken = -9999;
  423.                 }
  424.                 sprintf(sztoken_neu, "%6i", itoken);
  425.                 strcat(szzeile, sztoken_neu);
  426.  
  427.                 //naechste Zahl lesen
  428.                 sztoken = strtok(0, " ");
  429.             }
  430.  
  431.             //zu wenige Werte mit 0 auffüllen
  432.             int inullen = 0;
  433.             while(inullen < (ispalten - ianzahl_token))
  434.             {
  435.                 strcat(szzeile, "     0");
  436.                 inullen++;
  437.             }
  438.  
  439.             strcat(szzeile, "\n");
  440.  
  441.             TabelleZeileAendern(ptabelle, szdateiname, szzeile, izeile_neu);
  442.  
  443.  
  444.         }
  445.         break;
  446.         case 'e':
  447.         {
  448.             puts("Zeilennummer der zu loeschenden Zeile:");
  449.             int izeile_loeschen = 0;
  450.             fflush(stdin);
  451.             scanf("%i", &izeile_loeschen);
  452.             TabelleZeileLoeschen(ptabelle, szdateiname, izeile_loeschen);
  453.  
  454.         }
  455.         break;
  456.         case 'l':
  457.         {
  458.             TabelleLaengssummeHinzufuegen(ptabelle, szdateiname);
  459.         }
  460.         break;
  461.         case 'q':
  462.         {
  463.             TabelleQuersummeHinzufuegen(ptabelle, szdateiname);
  464.         }
  465.         break;
  466.         case 's':
  467.         {
  468.             puts("Bitte Spalte angeben die sortiert werden soll:");
  469.             int ispalte;
  470.             int iliste[1000] = { 0 };
  471.             fflush(stdin);
  472.             scanf("%i", &ispalte);
  473.             rewind(ptabelle);
  474.             fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  475.             fgets(szzeile, sizeof(szzeile), ptabelle); // headerzeile überspringen
  476.             if(ispalte < 1 || ispalte > ispalten)
  477.             {
  478.                 puts("Ungueltige Spaltennummer!");
  479.                 getch();
  480.             }
  481.             else
  482.             {
  483.                 int q;
  484.                 char* sztoken = 0;
  485.                 int iindex_token;
  486.                 for(q = 1; q <= izeilen; q++)
  487.                 {
  488.                     fgets(szzeile, sizeof(szzeile), ptabelle);
  489.                     sztoken = strtok(szzeile, " ");
  490.                     iindex_token = -1;
  491.                     while(sztoken != 0)
  492.                     {
  493.                         if(++iindex_token + 1 == ispalte)
  494.                         {
  495.                             //spalte gefunden
  496.                             iliste[q - 1] = atoi(sztoken);
  497.                             break;
  498.                         }
  499.                         //naechste Zahl lesen
  500.                         sztoken = strtok(0, " ");
  501.                     }
  502.                 }
  503.  
  504.                 Bubblesort(iliste, izeilen, 0);
  505.                 printf("Spalte %i sortiert:\n", ispalte);
  506.                 int in = 0;
  507.                 while(in < izeilen)
  508.                 {
  509.                     printf("%i ", iliste[in++]);
  510.                 }
  511.                 getch();
  512.             }
  513.         }
  514.         break;
  515.         case 'x':
  516.         {
  517.             return;
  518.         }
  519.         break;
  520.         default:
  521.         break;
  522.     }
  523.  
  524. }
  525. while(1);
  526. }
  527.  
  528. void TabelleQuersummeHinzufuegen(FILE* ptabelle, char* szdateiname)
  529. {
  530.     char szzeile[1024] = { 0 };
  531.     char sztemp[55] = { 0 };
  532.     strcpy(sztemp, szdateiname);
  533.     strcat(sztemp, ".temp");
  534.     FILE* ftemp = fopen(sztemp, "w");
  535.     if(ftemp)
  536.     {
  537.         char* sztoken = 0;
  538.         int izeilen, ispalten, isumme, itoken;
  539.         rewind(ptabelle);
  540.         fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  541.         fgets(szzeile, sizeof(szzeile), ptabelle); // headerzeile überspringen
  542.         fprintf(ftemp, "%i %i\n", izeilen, ispalten + 1);
  543.         int i;
  544.         for(i = 1; i <= izeilen; i++)
  545.         {
  546.             isumme = 0;
  547.             fgets(szzeile, sizeof(szzeile), ptabelle);
  548.  
  549.             //Quersumme berechnen
  550.             sztoken = strtok(szzeile, " ");
  551.             while(sztoken != 0)
  552.             {
  553.                 itoken = atoi(sztoken);
  554.                 isumme += itoken;
  555.                 fprintf(ftemp, "%6i", itoken);
  556.                 //naechste Zahl lesen
  557.                 sztoken = strtok(0, " ");
  558.             }
  559.  
  560.             //Quersumme hinzufügen
  561.             fprintf(ftemp, "%6i\n", isumme);
  562.         }
  563.  
  564.         //Originaldatei mit temporärer ersetzen
  565.         fclose(ptabelle);
  566.         fclose(ftemp);
  567.         remove(szdateiname);
  568.         rename(sztemp, szdateiname);
  569.         ptabelle = fopen(szdateiname, "r+");
  570.     }
  571.  
  572. }
  573.  
  574. void TabelleLaengssummeHinzufuegen(FILE* ptabelle, char* szdateiname)
  575. {
  576.     char szzeile[1024] = { 0 };
  577.     char sztemp[55] = { 0 };
  578.     strcpy(sztemp, szdateiname);
  579.     strcat(sztemp, ".temp");
  580.     FILE* ftemp = fopen(sztemp, "w");
  581.     if(ftemp)
  582.     {
  583.         char* sztoken = 0;
  584.         int izeilen, ispalten, isumme[13] = { 0 }, itoken;
  585.         rewind(ptabelle);
  586.         fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  587.         fgets(szzeile, sizeof(szzeile), ptabelle); // headerzeile überspringen
  588.         fprintf(ftemp, "%i %i\n", izeilen + 1, ispalten);
  589.         int i;
  590.         int iindex_token;
  591.         for(i = 1; i <= izeilen; i++)
  592.         {
  593.             fgets(szzeile, sizeof(szzeile), ptabelle);
  594.  
  595.             //Längssummen berechnen
  596.             sztoken = strtok(szzeile, " ");
  597.             iindex_token = -1;
  598.             while(sztoken != 0)
  599.             {
  600.                 //zu Lsumme addieren
  601.                 itoken = atoi(sztoken);
  602.                 isumme[++iindex_token] += itoken;
  603.                 //in neue Datei schreiben
  604.                 fprintf(ftemp, "%6i", itoken);
  605.                 //naechste Zahl lesen
  606.                 sztoken = strtok(0, " ");
  607.             }
  608.             fprintf(ftemp, "\n");
  609.         }
  610.         //Längssummen hinzufügen
  611.         for(i = 0; i <= iindex_token; i++)
  612.         {
  613.             fprintf(ftemp, "%6i", isumme[i]);
  614.         }
  615.         fprintf(ftemp, "\n");
  616.  
  617.         //Originaldatei mit temporärer ersetzen
  618.         fclose(ptabelle);
  619.         fclose(ftemp);
  620.         remove(szdateiname);
  621.         rename(sztemp, szdateiname);
  622.         ptabelle = fopen(szdateiname, "r+");
  623.     }
  624. }
  625.  
  626. void TabelleZeileLoeschen(FILE* ptabelle, char* szdateiname, int izeile)
  627. {
  628.     char sztemp[55] = { 0 };
  629.     char szzeile[55] = { 0 };
  630.     strcpy(sztemp, szdateiname);
  631.     strcat(sztemp, ".temp");
  632.     FILE* ftemp = fopen(sztemp, "w");
  633.     if(ftemp)
  634.     {
  635.         int izeilen, ispalten;
  636.         rewind(ptabelle);
  637.         fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  638.         fgets(szzeile, sizeof(szzeile), ptabelle); // headerzeile überspringen
  639.         izeilen -= 1;
  640.         fprintf(ftemp, "%i %i\n", izeilen, ispalten);
  641.         fflush(ftemp);
  642.         int i;
  643.         for(i = 1; i < izeile; i++)
  644.         {
  645.             fgets(szzeile, sizeof(szzeile), ptabelle);
  646.             fprintf(ftemp, "%s", szzeile);
  647.             fflush(ftemp);
  648.         }
  649.  
  650.         fgets(szzeile, sizeof(szzeile), ptabelle); //zu löschende zeile überspringen
  651.  
  652.         for(; i <= izeilen; i++)
  653.         {
  654.             fgets(szzeile, sizeof(szzeile), ptabelle);
  655.             fprintf(ftemp, "%s", szzeile);
  656.             fflush(ftemp);
  657.         }
  658.  
  659.         //Originaldatei mit temporärer ersetzen
  660.         fclose(ptabelle);
  661.         fclose(ftemp);
  662.         remove(szdateiname);
  663.         rename(sztemp, szdateiname);
  664.         ptabelle = fopen(szdateiname, "r+");
  665.     }
  666. }
  667.  
  668. void TabelleZeileAendern(FILE* ptabelle, char* szdateiname, char* szzeile_neu, int izeile)
  669. {
  670.     char sztemp[55] = { 0 };
  671.     char szzeile[55] = { 0 };
  672.     strcpy(sztemp, szdateiname);
  673.     strcat(sztemp, ".temp");
  674.     FILE* ftemp = fopen(sztemp, "w");
  675.     if(ftemp)
  676.     {
  677.         int izeilen, ispalten;
  678.         rewind(ptabelle);
  679.         fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  680.         fgets(szzeile, sizeof(szzeile), ptabelle); // headerzeile überspringen
  681.         fprintf(ftemp, "%i %i\n", izeilen, ispalten);
  682.         fflush(ftemp);
  683.         int i;
  684.         for(i = 1; i < izeile; i++)
  685.         {
  686.             fgets(szzeile, sizeof(szzeile), ptabelle);
  687.             fprintf(ftemp, "%s", szzeile);
  688.             fflush(ftemp);
  689.         }
  690.  
  691.  
  692.         fgets(szzeile, sizeof(szzeile), ptabelle); //alte zeile überspringen
  693.  
  694.         fprintf(ftemp, "%s", szzeile_neu);
  695.         fflush(ftemp);
  696.  
  697.         for(; i <= izeilen; i++)
  698.         {
  699.             fgets(szzeile, sizeof(szzeile), ptabelle);
  700.             fprintf(ftemp, "%s", szzeile);
  701.             fflush(ftemp);
  702.         }
  703.  
  704.         //Originaldatei mit temporärer ersetzen
  705.         fclose(ptabelle);
  706.         fclose(ftemp);
  707.         remove(szdateiname);
  708.         rename(sztemp, szdateiname);
  709.         ptabelle = fopen(szdateiname, "r+");
  710.     }
  711. }
  712.  
  713. void TabelleZeileEinfuegen(FILE* ptabelle, char* szdateiname, char* szzeile_neu, int izeile)
  714. {
  715.     char sztemp[55] = { 0 };
  716.     char szzeile[55] = { 0 };
  717.     strcpy(sztemp, szdateiname);
  718.     strcat(sztemp, ".temp");
  719.     FILE* ftemp = fopen(sztemp, "w");
  720.     if(ftemp)
  721.     {
  722.         int izeilen, ispalten;
  723.         rewind(ptabelle);
  724.         fscanf(ptabelle, "%i %i", &izeilen, &ispalten);
  725.         fgets(szzeile, sizeof(szzeile), ptabelle); // headerzeile überspringen
  726.         izeilen += 1;
  727.         fprintf(ftemp, "%i %i\n", izeilen, ispalten);
  728.         int i;
  729.         for(i = 1; i < izeile; i++)
  730.         {
  731.             fgets(szzeile, sizeof(szzeile), ptabelle);
  732.             fprintf(ftemp, "%s", szzeile);
  733.             fflush(ftemp);
  734.         }
  735.  
  736.         fprintf(ftemp, "%s", szzeile_neu);
  737.         fflush(ftemp);
  738.  
  739.         for(; i <= izeilen; i++)
  740.         {
  741.             fgets(szzeile, sizeof(szzeile), ptabelle);
  742.             fprintf(ftemp, "%s", szzeile);
  743.             fflush(ftemp);
  744.         }
  745.  
  746.         //Originaldatei mit temporärer ersetzen
  747.         fclose(ptabelle);
  748.         fclose(ftemp);
  749.         remove(szdateiname);
  750.         rename(sztemp, szdateiname);
  751.         ptabelle = fopen(szdateiname, "r+");
  752.     }
  753. }
  754.  
  755. void Bubblesort(int iliste[], int iliste_laenge, int absteigend)
  756. {
  757.     int i, j, itemp;
  758.     if(absteigend)
  759.     {
  760.         for (i = 0 ; i < ( iliste_laenge - 1 ); i++)
  761.         {
  762.             for (j = 0 ; j < iliste_laenge - i - 1; j++)
  763.             {
  764.                 if (iliste[j] < iliste[j+1])
  765.                 {
  766.                     itemp       = iliste[j];
  767.                     iliste[j]   = iliste[j+1];
  768.                     iliste[j+1] = itemp;
  769.                 }
  770.             }
  771.         }
  772.     }
  773.     else
  774.     {
  775.         for (i = 0 ; i < ( iliste_laenge - 1 ); i++)
  776.         {
  777.             for (j = 0 ; j < iliste_laenge - i - 1; j++)
  778.             {
  779.                 if (iliste[j] > iliste[j+1])
  780.                 {
  781.                     itemp       = iliste[j];
  782.                     iliste[j]   = iliste[j+1];
  783.                     iliste[j+1] = itemp;
  784.                 }
  785.             }
  786.         }
  787.     }
  788. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!