PROGRAMMSAMMLUNG

Tutorials.at
Verfügbare Informationen zu "PROGRAMMSAMMLUNG"

  • Qualität des Beitrags: 0 Sterne
  • Beteiligte Poster: DrPhil_Guth - r00tnix - progger - Dragorad - exbs - CRASH - Dirty Oerty - rattenfan - AQE89 - detewe89 - Moritz - The Dust - Xin - dani93
  • Forum: Tutorials.at
  • Forenbeschreibung: Programmierforum
  • aus dem Unterforum: Allgemeines
  • Antworten: 96
  • Forum gestartet am: Mittwoch 19.04.2006
  • Sprache: deutsch
  • Link zum Originaltopic: PROGRAMMSAMMLUNG
  • Letzte Antwort: vor 15 Jahren, 17 Tagen, 22 Stunden, 6 Minuten
  • Alle Beiträge und Antworten zu "PROGRAMMSAMMLUNG"

    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 25.08.2006, 12:12

    PROGRAMMSAMMLUNG
    Das ist ein Thread, in dem ihr eure Programme veröffentlicht, von denen ihr denkt dass sie gut gelungen sind und anderen Programmierern helfen könnt.

    Allerdings sind hierzu ein paar Regeln zu beachten:

    - Postet nur Programme die sicher Funktionieren. Es sollen weder Compiler- noch Laufzeitfehler vorkommen.

    - Falls die Programme nur auf einem Betriebssystem funktionieren, kennzeichnet das Bitte

    - Schreibt am Anfang eures Posts den zweck eures Programms

    - Schreibt den Quellcode bitte in ein Code- fenster: {code} /* programmcode */ {/code} wobei ihr die geschwungen Klammern ( {} ) durch eckige ( [] ) ersetzen müsst.

    - Bitte schreibt leserlich! Das bedeutet ejer einmal zuviel absätze und Tabulatoren machen als zuwenig. Schreibt auch ab und zu Kommentare hin, und bennent eure Variablen sinnvoll (ein kleine Hilfe zur lesbarkeit: http://www.engr.iupui.edu/%7Efernande/cpt262/notes/Styleguide.html)

    - BITTE BITTE Stellt euren Compilereditor so um, dass Tabulatoren als leerzeichen dargestellt werden. Warum? Hier im forum werden Tabulatoren nicht erkannt


    Falls ihr Kritik, Anregungen oder Fragen zu einem Programm eines anderen habt, bitte postet es in einem Anderen Thread.



    Re: PROGRAMMSAMMLUNG

    r00tnix - 28.08.2006, 19:58


    Hier ein Programm, das ich vor ein paar Monaten gemacht habe.
    DOS Explorer.
    http://infection93.org/gui.exe

    Es ist eine GUI für MS-DOS, FreeDOS, DR-DOS und OpenDOS.
    Die Dateien und Verzeichnisse werden in Fenstern angezeigt und können per
    Mausklick gelöscht, umbenannt, verschoben, kopiert werden. Außerdem wurde die von
    Windows bekannte Verknüpfungsfunktion eingebaut!
    EXEs und COMs können per Mausklick ausgeführt werden, aber vorher kann man in das praktische
    Fenster die gewünschten Parameter eingeben.

    Achtung! Läuft nur unter Windows und DOS!



    Re: PROGRAMMSAMMLUNG

    progger - 29.08.2006, 20:28


    Veratest du uns auch den quelltext?Oder zumindest ein paar infos?



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 29.08.2006, 21:07


    ja, das war eigentlich der sinn der ganzen sache



    Re: PROGRAMMSAMMLUNG

    Dragorad - 26.10.2006, 17:06


    Hier ist eins von meinigen :D !



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 26.10.2006, 18:21


    äh, und wo? löl



    Re: PROGRAMMSAMMLUNG

    Dragorad - 26.10.2006, 18:37


    auf "hier" klicken, da ist etwas weiter unten der Quelltext und noch weiter unten der Link zum Download der Dateien.



    Re: PROGRAMMSAMMLUNG

    exbs - 26.10.2006, 19:30


    Hier mal ein kleines aber nettes Programm. Es errechnet die Quersumme einer Zahl.

    Ob es auf anderen Betriebssystemen funktioniert, außer Windows, kann ich nicht sagen (noch nicht probiert) ... ich habe allerdings keine "exotischen" Header oder windowsspeziefische Befehle verwendet.

    Code: #include <stdio.h>

    #define FALSE 0
    #define TRUE !FALSE

    int main()
    {
        /*Deklarationsteil*/
       
        int quersumme = 0, eing_pruef = 0, stellen = -1, fertig, text_ausg, x = 0, zahl_eing, teiler = 1, einzel[20], rest;
        float temp = 1;
        fertig = FALSE;
        text_ausg = FALSE;
       
        /******************/
       
        eing_pruef = scanf("%i", &zahl_eing);
       
        if (eing_pruef != 1)
                       exit(0);
       
        if (zahl_eing < 0) //Betrag der Zahl
                 zahl_eing *= -1;
       
        while(fertig != TRUE) //Anzahl der Stellen ermitteln
        {                         
                     temp = zahl_eing / teiler;
                     
                     if (temp < 1)
                     {
                              fertig = TRUE;
                              text_ausg = TRUE;
                     }
                     stellen++;
                     teiler *= 10;
        }
       
        teiler = 10;
       
        for (;x < stellen; x++) //Zahl teilen
        {
            rest = zahl_eing % teiler;
            zahl_eing /= teiler;
            einzel[x] = rest; 
        }
         
        for (x = 0; x < stellen; x++) //Quersumme errechnen
            quersumme += einzel[x];
       
        if (text_ausg == TRUE)
        {
                      printf("\n\nDie Zahl hat %i Stellen. Quersumme = %i !!!" ,stellen, quersumme);
                      printf("\n\nErgibt sich aus: ");
                      for (x = (stellen - 1); x >= 0; x--)
                      {
                          printf("%i", einzel[x]);
                          if (x > 0)
                             printf(" + ");
                     
                      }
                      printf(" = %i !!!", quersumme);
        }
                   
        fflush(stdin);
        getchar();
    }

    ... wenn ich ehrlich bin, wäre ich euch sehr verbunden, wenn ihr mir Verbesserungsvorschläge liefern würde (falls es denn welche gibt :wink: ) ... ich weiß nämlich, dass ich manchmal zu sehr unkonventionellen Lösungen neige. :roll:

    hier noch der Link zum DL: http://bachi55.ba.funpic.de/Proggs/C/Mathe/quersum.exe

    greetzz and thx exbs



    Re: PROGRAMMSAMMLUNG

    Dragorad - 26.10.2006, 19:47


    Eine Hilfestellung, was man eingeben muss und was bei rauskommt, wär nicht schlecht.



    Re: PROGRAMMSAMMLUNG

    exbs - 26.10.2006, 20:05


    Nja ich wollt das Programm eigl kompakt halten, geht nur um die Funktion :D ! Aber du hast natürlich Recht ... hier neu gemacht.

    http://bachi55.ba.funpic.de/Proggs/C/Mathe/quersum.exe

    greetzz exbs



    Re: PROGRAMMSAMMLUNG

    Dragorad - 31.10.2006, 00:05


    Will ich auch mal auf das TP-Projekt verweisen (an dem natürlich jeder mitmachen kann :D ).



    Re: PROGRAMMSAMMLUNG

    Dragorad - 08.11.2006, 22:05


    Hier ist ein kleiner Deutschland_Screensaver - die nächste WM kommt bestimmt!

    Code:
    program   dtl_screensaver;
    uses      crt,ucolor,uminout;
    const     esc=#27;

    begin     repeat
               b_schwarz;
               clrscr;
               window(1,9,80,25);
               b_rot;
               clrscr;
               textcolor(15+blink);
               writexy(2,3,'++++   +++++  +    +  +++++   ++++   ++++  +   +  +       +++   +   +  ++++ ');
               writexy(2,4,'+   +  +      +    +    +    +      +      +   +  +      +   +  ++  +  +   +');
               writexy(2,5,'+   +  +++    +    +    +     +++   +      +++++  +      +++++  + + +  +   +');
               writexy(2,6,'+   +  +      +    +    +        +  +      +   +  +      +   +  +  ++  +   +');
               writexy(2,7,'++++   +++++   ++++     +    ++++    ++++  +   +  +++++  +   +  +   +  ++++ ');
               window(1,18,80,25);
               b_gelb;
               clrscr;
              until readkey=esc;
    end.

    und hier die Units:
    Code:
    unit      ucolor;

    {----------------------------------------------------------------------------}

    interface
    uses      crt;

    procedure rot;
    procedure gruen;
    procedure blau;
    procedure gelb;
    procedure weiss;
    procedure schwarz;
    procedure grau;
    procedure b_rot;
    procedure b_gruen;
    procedure b_blau;
    procedure b_gelb;
    procedure b_weiss;
    procedure b_schwarz;
    procedure b_grau;

    {----------------------------------------------------------------------------}

    implementation
    procedure rot;
              begin
               textcolor(red);
              end;
    procedure gruen;
              begin
               textcolor(green);
              end;
    procedure blau;
              begin
               textcolor(blue);
              end;
    procedure gelb;
              begin
               textcolor(yellow);
              end;
    procedure weiss;
              begin
               textcolor(white);
              end;
    procedure schwarz;
              begin
               textcolor(black);
              end;
    procedure grau;
              begin
               textcolor(8);
              end;
    procedure b_rot;
              begin
               textbackground(red);
              end;
    procedure b_gruen;
              begin
               textbackground(green);
              end;
    procedure b_blau;
              begin
               textbackground(blue);
              end;
    procedure b_gelb;
              begin
               textbackground(yellow);
              end;
    procedure b_weiss;
              begin
               textbackground(white);
              end;
    procedure b_schwarz;
              begin
               textbackground(black);
              end;
    procedure b_grau;
              begin
               textbackground(8);
              end;
    end.

    Code:
    unit      uMInOut;

    {----------------------------------------------------------------------------}

    interface
    uses      crt,ucolor;
    type      datensatztyp=record
               voc_engl:string[27];
               voc_d:string[27];
              end;
              karteityp=file of datensatztyp;
    var       karteidaten:datensatztyp;
              kartei:karteityp;
              karteinr:integer;
              ini:text;

    procedure writexy(x,y:byte;text:string);
    procedure writexynr(x,y:byte;zahl:integer);
    procedure openwindow(xl,yl,xr,yr:integer);
    procedure openwindowende;
    procedure programmende;
    procedure stringlesen(var lesstr:string;maxlen:byte);
    procedure fehler;
    procedure karteioeffnen;
    procedure karteischliessen;
    procedure inioeffnen;
    procedure inischliessen;

    {----------------------------------------------------------------------------}

    implementation
    procedure writexy(x,y:byte;text:string);
              begin
               gotoxy(x,y);
               write(text);
              end;

    procedure writexynr(x,y:byte;zahl:integer);
              begin
               gotoxy(x,y);
               write(zahl);
              end;

    procedure openwindow(xl,yl,xr,yr:integer);
              type zaehler=array[1..4] of byte;
              var  zahl:zaehler;
              begin
               writexy(xl,yl,'É');
               writexy(xl,yr,'È');
               writexy(xr,yl,'»');
               writexy(xr,yr,'¼');
               for zahl[1]:=xl+1 to xr-1 do writexy(zahl[1],yl,'Í');
               for zahl[2]:=xl+1 to xr-1 do writexy(zahl[2],yr,'Í');
               for zahl[3]:=yl+1 to yr-1 do writexy(xl,zahl[3],'º');
               for zahl[4]:=yl+1 to yr-1 do writexy(xr,zahl[4],'º');
               window(xl+1,yl+1,xr-1,yr-1);
               blau;
              end;

    procedure openwindowende;
              type zaehler=array[1..4] of byte;
              var  zahl:zaehler;
                   x,y:integer;
              begin
               x:=30;y:=8;
               writexy(x,y,'É');
               writexy(x,y+4,'È');
               writexy(x+20,y,'»');
               writexy(x+20,y+4,'¼');
               for zahl[1]:=x+1 to x+19 do writexy(zahl[1],y,'Í');
               for zahl[2]:=x+1 to x+19 do writexy(zahl[2],y+4,'Í');
               for zahl[3]:=y+1 to y+3 do writexy(x,zahl[3],'º');
               for zahl[4]:=y+1 to y+3 do writexy(x+20,zahl[4],'º');
               window(x,y,x+19,y+3);
               schwarz;
              end;

    procedure programmende;
              begin
               openwindowende;
               writexy(2,2,' Wirklich beenden?');
               writexy(2,4,' Ja           Nein');
              end;

    procedure stringlesen(var lesstr:string;maxlen:byte);
              const ret=#13;
              var   ch:char;
                    i,x,y:byte;
              begin
               x:=wherex;
               y:=wherey;
               lesstr:='';
               repeat
                gotoxy(x,y);
                write(lesstr);
                for i:=length(lesstr)+1 to maxlen do write('_');
                gotoxy(x+length(lesstr),y);
                ch:=readkey;
                if (length(lesstr)<maxlen) and (ch<>ret) then lesstr:=lesstr+ch;
               until ch=ret;
               writeln;
              end;

    procedure fehler;
              begin
               sound(440);
               delay(250);
               nosound;
              end;

    procedure karteioeffnen;
              begin
               assign(kartei,'vokabeln.dat');
               {$I-}reset(kartei);{$I+}
               if IOresult<>0 then
               begin
                gotoxy(1,25);
                fehler;
                write('Programmfehler: die Kartei konnte nicht ge”ffnet werden - Das Programm wurde beendet.');
                halt;
               end;
              end;

    procedure karteischliessen;
              begin
               close(kartei);
              end;

    procedure inioeffnen;
              begin
               assign(ini,'engl.ini');
               {$I-}reset(ini);{$I+}
               if IOresult<>0 then
               begin
                gotoxy(1,25);
                fehler;
                write('Programmfehler: die Kartei konnte nicht ge”ffnet werden - Das Programm wurde beendet.');
                halt;
               end;
              end;

    procedure inischliessen;
              begin
               close(ini);
              end;
    end.



    Re: PROGRAMMSAMMLUNG

    exbs - 14.11.2006, 22:16


    Hier mal ein prog, welches die Buchstaben in einem String zählen kann. Viel fun damit.

    Code: #include <stdio.h>

    #define MAX 1024
    #define FALSE 0
    #define TRUE !FALSE

    int main()
    {
        char string[MAX], c, eingabe;
        int x = 0, y, anzahl[255], machn = FALSE;
       
        system("cls");
       
        printf("--> Buchstabenzaehler <--\n\n");
        printf("Geben Sie Ihren Text ein [MAX 1024 Zeichen].\n\n");
        printf("Text:\n");
       
        fgets(string, MAX, stdin);
       
        do
        {
                      system("cls");
       
                      printf("Soll die Gross- und Kleinschreibung beachtet werden ?\n");
                      printf("[j]a / [n]ein --> ");
       
                      eingabe = (char)tolower(getchar());
        }while (eingabe != 'j' && eingabe != 'n');
       
        if (eingabe == 'n')
                    machn = TRUE;
       
        if (machn == TRUE)   
                  do
                  {       
                          c = string[x];
                          c = (char)tolower(c);
                          string[x] = c;
                          x++;
                  }while (x < strlen(string));

        for (x = 0; x <= 255; x++)
            anzahl[x] = 0;
       
        for (x = 0; x < strlen(string); x++)
            for (y = 0; y <= 255; y++)
                if (string[x] == (char)y)
                              anzahl[y] += 1;
                             
        system("cls");
        printf("Auswertung\n");
        printf("----------\n\n");
        printf("Text:\n");
        printf("-----\n");
        puts(string);
        printf("\n\n");
       
                   
        for (x = 0; x <= 255; x++)
        {
            if (anzahl[x] == 0);
           
            else if ((char)x == '\n');
           
            else if ((char)x == ' ')
                printf("Leerzeichen - %i\n", anzahl[x]);
           
            else
                printf("%c           - %i\n", x, anzahl[x]);
        }
       
        printf("_______________\n");   
        printf("Gesammt:%7i", (strlen(string) - 1));     
                                 
        fflush(stdin);
        getchar();         
    }

    Exe hier ---> http://bachi55.ba.funpic.de/Proggs/C/Strings/buchstaben.exe !!

    auch hier würde ich mich freun wenn ihr mir verbesserungsvorschläge geben würdet.

    greetzz exbs



    Re: PROGRAMMSAMMLUNG

    Dragorad - 16.11.2006, 10:53


    Hier das TP-Standartprogramm, welches sicherlich in jeder Schule behandelt wird: das Galtonbrett!

    Code: program   galton_fast_fertig;
    uses      graph,crt;
    var       pos_x,pos_y,zufall,richtung,i,k,j,n:integer;

    procedure grafikein;
              var driver,mode:integer;
              begin
               driver:=0;
               initgraph(driver,mode,'c:\mike\mike\turbo pascal\bgi');
              end;

    procedure naegel;
              var i,k:integer;
              begin
               for i:=0 to 3 do
                for k:=0 to i do
                 circle(320-50*i+50*2*k,200+50*i,5);
              end;

    procedure faecher;
              var i:integer;
              begin
               setlinestyle(1,1,9);
               line(170-100,410,470+100,410);
               for i:=0 to 5 do
                line(170-100+100*i,410,170-100+100*i,390);
              end;

    procedure kugelfall(x,y,richtung:integer);
              var i:integer;
              begin
               for i:=0 to 50 do
               begin
                setcolor(white);
                circle(x+richtung*i,y-round(sqrt(50*50-i*i)),10);
                delay(10);
                setcolor(black);
                circle(x+richtung*i,y-round(sqrt(50*50-i*i)),10);
               end;
              end;

    begin     {for i:=0 to 5 do zaehler[i]:=0;}
              clrscr;
              randomize;
              grafikein;
              naegel;
              faecher;
              settextstyle(1,0,5);
              outtextxy(155,410,'Das Galtonbrett');
              settextstyle(1,0,1);
              outtextxy(155,10,'Anzahl der Versuche:');
              gotoxy(45,2);
              readln(n);
              for k:=1 to n do
              begin
               pos_x:=320;pos_y:=234;
               for i:=1 to 4 do
               begin
                zufall:=random(2);
                if zufall=0 then richtung:=1
                            else richtung:=-1;
                kugelfall(pos_x,pos_y,richtung);
                pos_x:=pos_x+richtung*50;
                pos_y:=pos_y+50;
               end;
              end;
              readln;
    end.



    Re: PROGRAMMSAMMLUNG

    Dragorad - 19.12.2006, 14:05


    Ich hab' mal ein bisschen mit der Soundausgabe herumgespielt und rausgekommen ist das hier.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 27.12.2006, 14:05


    Hi!

    Also eigentlich ist das gar kein Programm sondern eher eine headerdatei.
    Es sollte das arbeiten mit Dateien vereinfachen, sodass man schon eine vorgefertigte lösung parat hat, wenn man mal schnell was machen braucht.
    Die anleitung, wie es funktioniert steht oben als kommentar.
    Ich hab noch ne .cpp datei draufgepackt, damit man das ganze auch testen kann.

    Die programme wurden nur in Unix getestet, aber ich denke sie sollten problemlos unter DOS/Win32 funktionieren.

    Für anregungen, Kritik, hinweise auf Bugs oder vorschläge zur erweiterung wäre ich sehr dankbar.

    Hier die dateien:

    Code: // CLoadFile_AK.h

    /*
     * This header file is free for private use
     * and was completely written by Alexander Korsunsky.
    */

    // CLoadFile(const char* FileName, char* BigArray, int MaxChars)
    // CLoadFile::load()

    //CLoadFile loads a file with a certain maximum filesize into an array

    /* USAGE:
     *
     * 1. Instance
     *
     * Declare an Instance of this class with the parameters
     * FileName, which has to contain the name of the file
     * BigArray and MaxChars
     * BigArray must be an Array that is big enough to
     * contain the whole Text File, and have MaxChars elements
     *
     * 2. Initialize by calling the function CLoadFile::load()
     *
     * 3. Exception handling
     *
     * CLoadFile::load() returns 0 if the operation worked,
     * CLoadFile::FILE_ERR if the file could not be loaded and
     * CLoadFile::SIZE_ERR if the file was bigger than MaxChars bytes
     *
     * A possible way of catching exceptions would be:

    int nErrorMessage;

    nErrorMessage = textfile.load();         
    if (nErrorMessage == CLoadFile::FILE_ERR )
       {
       printf ("The file could not be loaded.\n");
       }
    else if (nErrorMessage == CLoadFile::SIZE_ERR)
       {
       printf ("The file is too big\n");
       }
    */

    // DEPENDENCIES ///////////////////////////////////////////////////////////////
    /*
     * This file depends on the header file
     * filesize.h
    */


    #ifndef CLOADFILE_AK_H

    #define CLOADFILE_AK_H


    // INCLUDES ///////////////////////////////////////////////////////////////////
    #include <stdio.h>
    #include <stdlib.h>
    #include "filesize.h"

    // DEFINES ////////////////////////////////////////////////////////////////////
       /* Nothing, the constants are declared as public in the class*/


    class CLoadFile
    {

    // Variables //////////////////////////////////////////////////////////////////
          
    public:
       static const int FILE_ERR;
       static const int SIZE_ERR;
       static const int BLOCKSIZE;

    protected:

       //sz String, where the name of the file is stored
       char szFileName[256];

       //Defines the maximum amount of characters to be loaded from file
       int nMaxChars;

       //Pointer to the Array where the text is to be stored
       char* szTargetBuffer;
       
       //Pointer to the File
       FILE* flInFile;
       
       // Flag wich defines wether loading the file was succesfull
       bool fFileLoaded;



    // FUNCTION HEADERS, FUNCTIONS ////////////////////////////////////////////////
       
    public:


       // CONSTRUCTOR
       CLoadFile (const char* fileName, char* targetBuffer,int maxChar)
          {

             strncpy (szFileName, fileName, 255);
             szTargetBuffer = targetBuffer;
             nMaxChars = maxChar;      

          }


       // Function to initialize the class,
       // this function is to be called by user manually
       int load();


       //DESTRUCTOR
       ~CLoadFile()
          {
             if (fFileLoaded)
                {
                rewind(flInFile);
                fclose(flInFile);
                }
          }

    };//CLoadFile



    const int CLoadFile::FILE_ERR = 1;

    const int CLoadFile::SIZE_ERR = 2;

    const int CLoadFile::BLOCKSIZE = 32;








    int CLoadFile::load()
    {
    //How many characters were stored unnecessarily
    int nTooMuch;

    //How big is the file (bytes)
    int nFileSize;

    // Determine the Filesize and check how many chars were loaded unnecessarily
    nFileSize = FileSize(szFileName);
    nTooMuch = nFileSize % BLOCKSIZE;


       //Load the file
       if (nFileSize < nMaxChars) {
          
          if (( flInFile = fopen (szFileName, "r") ) == NULL)
             {
             fFileLoaded = 0;
             return FILE_ERR;
             }

          fFileLoaded = 1;

       } //if (iFileSize < maxChar)


       else
       {
          fFileLoaded = 0;
          return SIZE_ERR;
       } // else (iFileSize < maxChar)


       //Read the file into a string blockwise
       do {

       fread (szTargetBuffer, BLOCKSIZE, 1, flInFile);
       szTargetBuffer = szTargetBuffer + BLOCKSIZE;

       } while ( feof(flInFile) == 0 );


       /*
        * Quick and dirty way to correct the last characters of
        * the text stored in szTargetBuffer
       */
       memset (&szTargetBuffer[nFileSize-1], '\0', nTooMuch);

       return 0;
    }

    #endif //#ifdef CLOADFILE_AK_H




    Code: //filesize.h

    /*
     * Taken from http://www.codeproject.com/
     *
     * PLEASE NOTE that this is not my own work.
     * This function was written by Christopher Diggins, http://www.cdiggins.com/
     * and published on http://www.codeproject.com/file/filesize.asp
    */

    #ifndef FILESIZE_H

    #define FILESIZE_H

    #include <fstream>
    unsigned int FileSize(const char* sFileName)
    {
      std::ifstream f;
      unsigned int filesize=0;
      f.open(sFileName, std::ios_base::binary | std::ios_base::in);
      if (!f.good() || f.eof() || !f.is_open()) { return 0; }
      f.seekg(0, std::ios_base::beg);
      std::ifstream::pos_type begin_pos = f.tellg();
      f.seekg(0, std::ios_base::end);
      filesize = static_cast<unsigned int>(f.tellg() - begin_pos);
      f.close();
      return filesize;
    }

    #endif //FILESIZE_H



    So, und hier noch die .cpp zum testen:

    Code: // show_text.cpp

    /*
     * Dependencies:
     * CLoadFile_AK
    */


    // #INCLUDES //////////////////////////////////////////////////////////////////

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include "CLoadFile_AK.h"

    int main(int argc, char* argv[])
    {

    // VARIABLES //////////////////////////////////////////////////////////////////

    //Array where the loaded file is stored
    char pcTextBuffer[10240];
    int iErrorMessage;

       if (argc < 2)
          {
          printf ("This Program has to be called with one parameter\n");
          return 0;
          }
       else if(argc == 2)
          {
             CLoadFile textfile(argv[1], pcTextBuffer, 10240);
             iErrorMessage = textfile.load();
             
             if (iErrorMessage == CLoadFile::FILE_ERR )
                {
                printf ("The file could not be loaded.\n");
                }
             else if (iErrorMessage == CLoadFile::SIZE_ERR)
                {
                printf ("The file is too big\n");
                }
             else if (iErrorMessage == 0)
                {
                printf ("\n%s\n", pcTextBuffer);
                }

          return 0;
          } //else if (argc == 2)
       else
          {
          printf("The number of arguments is not correct.");
          return 0;
          }
    } //main()

       



    Re: PROGRAMMSAMMLUNG

    Dragorad - 27.12.2006, 18:42


    ... und wozu genau soll das Programm dienen? Ich hab's immer noch nicht ganz gerafft. :?:



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 28.12.2006, 13:58


    Das ist kein Programm, sondern eine Klasse.
    Sie soll dazu dienen den Umgang mit Textdateien zu vereinfachen. Anstatt dass du jedes mal neu Die Datei öffnen, den text in ein Array kopierst und dann alles wieder schließen musst, und das alles mit Fehlerbehandlung, kannst du alles von dieser Klasse erledigen lassen.
    Modulare Programmierung, soll heißen ein Programmierer muss nicht alles selbst schreiben, sondern kann sich zur Vereinfachung seiner Aufgabe schon vorprogrammierte Lösungen holen. Jetzt kapiert?
    Und das beiliegende programm dient eigentlich zu gar nichts, nur zum testen der Klasse.



    Re: PROGRAMMSAMMLUNG

    Dragorad - 29.12.2006, 01:09


    Aha, hab's verstanden (jedenfalls das meiste :D ) ... für modulare Programmierung reichen meine Kenntnisse (noch) nicht aus. Mehr als eigene Units erstellen kann ich net.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 29.12.2006, 13:48


    Naja, modulare programmierung ist eigentlich nichts anderes, als dass man seine Programme so aufteilt, dass daraus teilaufgaben entstehen, die möglichst allgemein sind, sodass man sie wiederverwenden kann.
    Also solche dateien schreiben, die nicht nur für ein einziges Programm nützlich sein könnten, sondern auch für andere.



    Re: PROGRAMMSAMMLUNG

    Dragorad - 30.12.2006, 00:33


    Ach so. Jetzt hab ich's richtig verstanden. Das ist ja doch nicht so schwer, wie ich dachte. :D



    Re: PROGRAMMSAMMLUNG

    exbs - 30.12.2006, 03:00


    Dragorad hat folgendes geschrieben: für modulare Programmierung reichen meine Kenntnisse (noch) nicht aus. Mehr als eigene Units erstellen kann ich net.

    nja Units sind jaa eigl auch Header (ok nein würde mein infoleherer jetzt wieda sagn :twisted: ) ... aba du schreibst sie und kannst sie überall wiederverwenden wo du die funkrionen braauchst ... so wie ein header.

    nur, dass ein header nicht compiliert wird wohingegen eine unit schon (hoffe ich irre mich jetzt net was die units angeht :roll: )



    Re: PROGRAMMSAMMLUNG

    Dragorad - 31.12.2006, 00:12


    Normalerweise Kompiliere ich meine Units, bevor ich sie verwende :mrgreen: !

    Aber was ist ein Header?



    Re: PROGRAMMSAMMLUNG

    exbs - 31.12.2006, 02:37


    nja eigl ist ein header nur ne text datei die die endung ".h" hat :roll: (richtig dumm gesagt) ... er wird nicht compiliert sondern nur gespeicher und dann durch den präprozessorbefehl "#include <mein_header.h>" eingebunden.

    und dort können dann funktionen des headers im prog genutzt werden.

    zum bsp:

    [header.h]
    Code: #include <stdio.h> <--- muss mit dabei sein weil der header ja printf benutzt.

    void show_hallo (void)
    {
          printf("Hallo");
    }

    [prog.c]

    Code: #include <header.h>

    int main()
    {
          show_hallo();
    }

    [prog.exe.]
    asugabe: Hallo


    so geht das also eigl wie ne unit oda ... nur wird nix compiliert.

    und wenn das noch net reicht:
    http://de.wikipedia.org/wiki/Header-Datei



    Re: PROGRAMMSAMMLUNG

    CRASH - 28.01.2007, 15:26


    es ist zwar kein besonderes programm aba mein erstes^^.
    also man gibt ne zahl von 1-6 an und es zeigt dir dan halt die entsprechende schulnote.gibt man einen wert ungleich 1-6 an, komm ne meldung .
    ps:ich weiss nicht wie man daraus ne .exe datei macht. :oops:

    Code:
    #include <stdio.h>
    #include <stdlib.h>
    #include  <conio.h>

    int main ()
    {
    int schulnote;
    printf ("Geben Sie eine gueltige Zahl von 1-6 ein: ");
    scanf ("%d",&schulnote);
    if ( (schulnote != 1) && (schulnote != 2) && (schulnote != 3) && (schulnote != 4) && (schulnote != 5) && (schulnote != 6) ) {
         printf ("Bitte geben Sie eine gueltige Zahl von 1-6 ein!");
         }
    else {
    if (schulnote == 1) printf ("sehr gut");
    if (schulnote == 2) printf ("gut");
    if (schulnote == 3) printf ("befriedigend");            #
    if (schulnote == 4) printf ("ausreichend");
    if (schulnote == 5) printf ("mangelhaft");
    if (schulnote == 6) printf ("ungenügend");

    }
    fflush (stdin);
    getchar();
    }


    ihr könnt mir auch gerne tipss geben was ich noch so proggen kann.als nächstes wollt ich n programm schreiben das fahrenheit in celsius umrechnet :P man muss halt klein anfangen^^



    Re: PROGRAMMSAMMLUNG

    exbs - 28.01.2007, 16:39


    das einzige was mir jetzt spontan auffällt ist, dass man kein Code: fflush(stdin); verwendet, besser ist: Code: setvbuf(stdin,NULL,_IONBF,0);
    setvbuf(stdin,NULL,_IOFBF,BUFSIZ);



    Re: PROGRAMMSAMMLUNG

    CRASH - 28.01.2007, 20:25


    also einfach anstelle von fflush reinpasten?hat die selbe wirkung?oO



    Re: PROGRAMMSAMMLUNG

    exbs - 28.01.2007, 20:34


    CRASH hat folgendes geschrieben: also einfach anstelle von fflush reinpasten?hat die selbe wirkung?oO genau ... fflush weg und die andere paste rin ;) ...!

    ja das hat die selbe wirkung ist aba sicherer.



    Re: PROGRAMMSAMMLUNG

    Dragorad - 28.01.2007, 23:35


    Inwiefern ist das "sicherer"? Sorgt das dafür, dass das Programm nicht abstürtzt?



    Re: PROGRAMMSAMMLUNG

    exbs - 28.01.2007, 23:45


    Zitat: 7.19.5.2 The fflush function
    Synopsis

    #include <stdio.h>
    int fflush(FILE *stream);
    Description

    If stream points to an output stream or an update stream in which the most recent
    operation was not input, the fflush function causes any unwritten data for that stream
    to be delivered to the host environment to be written to the file; otherwise, the behavior is
    undefined.

    If stream is a null pointer, the fflush function performs this flushing action on all
    streams for which the behavior is defined above.
    Returns

    The fflush function sets the error indicator for the stream and returns EOF if a write
    error occurs, otherwise it returns zero.



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 28.01.2007, 23:58


    kannst du das mal komplett übersetzen?

    versteh zwar das meiste, aber...naja



    Re: PROGRAMMSAMMLUNG

    Dragorad - 29.01.2007, 00:36


    'ne Übersetzung wäre wirklich hilfreich, da man es dann inhaltlich viel besser versteht.



    Re: PROGRAMMSAMMLUNG

    rattenfan - 29.01.2007, 22:04


    So jetzt will ich hier auch mal mein erstes Programm posten:
    Code:
    program rechner;
    uses crt;
    Var strecke,zeit: extended;
    var ergebnis : extended;
    a: string;
    geschwindigkeit: extended;
    begin
    repeat
    write ('was möchten sie berrechnen? ');
    textcolor(lightgreen);write ('G');textcolor (white); write ('eschwindigkeit, ');
    textcolor (lightgreen);write('S');textcolor (white);write ('trecke, ');
    textcolor (lightgreen);write('Z');textcolor (white);writeln('eit, ');
    write ('Wenn sie beenden möchten geben sie '); textcolor (lightgreen);write ('beenden ');
    textcolor (white);writeln ('ein');
    readln (a) ;
    {----------------------Geschwindigkeitsberechnung--------------------------------}
    If (a='G') then
    begin
            Repeat
            Repeat
            textcolor (lightblue);
            writeLn ('Geschwindigkeiterrechnung');
            textcolor (white);
            Write ('Geben sie die strecke in km an!');
            ReadLN (strecke);
            IF (strecke<0) then writeln ('Sie haben eine falsche Eingabe gemacht!');
            Until  (strecke>0);
            Write ('geben sie die benötigte zeit in h ein:');
            readln (zeit);
            IF (zeit<0)Then writeln ('Sie haben eine falsche eingabe gemacht!');
            UNTIL (zeit>0);
            Ergebnis := (strecke / Zeit);
            Write ('Die geschwindigkeit beträgt:');
            textcolor (lightred);
            write (ergebnis:5:2);
            writeln ('km/h');

    end;
    {---------------------------------Strecke-----------------------------------}
    if
    (a='S') then
    begin
            Repeat
            Repeat
            textcolor (lightblue);
            writeln ('Streckenberechnung');
            textcolor (white);
            writeln ('Geben sie die Geschwindigkeit an!');
            read (geschwindigkeit);
            IF (geschwindigkeit<0)then  writeln ('Sie haben eine falsche Eingabe gemacht');
            UNTIL (geschwindigkeit>0);
            writeln ('Geben sie die benötigte Zeit an!');
            read (zeit);
            IF (zeit<0)Then writeln ('Sie haben eine falsche Eingabe gemacht!');
            UNTIL (zeit>0);
            write ('Die Strecke beträgt');textcolor (lightred);write (geschwindigkeit * Zeit:5:1);textcolor(lightgray);writeln ('km');
    end;
    {-------------------------------Weg-----------------------------------------}
    if (a='Z') then
    begin
            Repeat
            Repeat
            textcolor (lightblue);writeln ('Zeitberechnung');
            textcolor (white); write ('Geben sie die Geschwindigkeit an!');
            read (geschwindigkeit);
            IF (geschwindigkeit<0) then writeln ('sie haben eine falsche Eingabe gemacht!');
            UNTIL (geschwindigkeit>0);
            write ('Geben sie die Strecke an!');
            read (strecke);
            IF (strecke<0) then writeln ('Sie haben eine falsche eingabe gemacht!');
            UNTIL (strecke>0);
            writeln ('Die zeit beträgt');textcolor (lightred);write (geschwindigkeit/strecke:5:2);textcolor(white);writeln('km');
    end;
    {--------------------------------falsche Eingabe----------------------------}
    if
    (a<> 'G') AND (a<>'S')AND(a<>'Z') AND (a<>'beenden') then
    begin
            Writeln ('Sie haben eine falsche Eingabe gemacht ');
    END;
    textcolor (white);
    Until a = 'beenden';
    end.


    HOffe auf Kritik, Verbesserungsvorschläge (,lob?).

    Und wenn ihr etwas ändern wollt, dann bitte schreiben, was das jetzt macht, denn ich will es ja zumindest einigermaßen verstehen! :wink:

    CU Rattenfan



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 30.01.2007, 12:57


    Dragorad hat folgendes geschrieben: 'ne Übersetzung wäre wirklich hilfreich, da man es dann inhaltlich viel besser versteht.

    Naja, also ich weiß, manchmal ist englisch etwas schwerer. Aber du solltest dich schnell daran gewöhnen, denn fast alle wichtigen Dokumentationen sind auf englisch. Ist zwar anstrengend zu lesen, aber das ist nunmal leider so.

    Hier mal das wichtigste:
    Wenn stream auf einen Ausgabestream zeigt, oder auf einen update stream (?), dessen letzte operation keine Eingabe war, dann werden alle ungeschriebenen Daten an die Zielumgebung (?, ws. ist damit das Ziel des ausgabestreams gemeint) geschickt um in die Datei geschrieben zu werden. Ansonsten ist das Verhalten NICHT DEFINIERT.

    Kurz: wenns ein ausgabestream war, dann werden ungeschriebene Daten geschrieben, ansonsten ist nicht genau festgelegt was passiert. Allerdings ist diese Funktion meines Wissens für DOS/Windows so implementiert, dass der Eingabebuffer gelöscht wird. ACHTUNG! Ich habe gelesen, dass das für UNIX- ähnliche Systeme NICHT der fall ist. Das bedeutet, dass das Programm nicht Portabel ist, und zwar an einer Stelle, wo das gar nicht notwendig wäre. Also bitte vermeiden.

    Alles klar soweit?

    ps.: Wo hast du das eigentlich her exbs? Klingt nach ner halbwegs seriösen doku...



    Re: PROGRAMMSAMMLUNG

    Dragorad - 30.01.2007, 14:56


    @ratenfan: ich hab' den Code etwas überarbeitet, sodass er jetzt auch für TurboPascal erkannbar ist (dh: aus extended wurde real). Außerdem hab' ich einige clrscrs reingebracht, damit der Bildschirm nicht überfrachtet wird. Zusätzlich hat jetzt jede Berechnung eine extra seite, dh dass jedes mal der Bildschirm gelöscht wird (wegen übersicht).

    Code: program   rechner;
    uses      crt;
    Var       strecke,zeit,ergebnis,geschwindigkeit:real;
              a:string;

    {----------------------------------------------------------------------------}

    begin     repeat
               clrscr;
               write('was m”chten Sie berrechnen? ');
               textcolor(lightgreen);
               write('G');
               textcolor(white);
               write('eschwindigkeit, ');
               textcolor (lightgreen);
               write('S');
               textcolor (white);
               write ('trecke, ');
               textcolor (lightgreen);
               write('Z');
               textcolor (white);
               writeln('eit, ');
               write('Wenn sie beenden möchten geben sie ');
               textcolor (lightgreen);
               write ('beenden ');
               textcolor (white);
               writeln ('ein');
               readln (a) ;
    {----------------------Geschwindigkeitsberechnung--------------------------------}
               If (a='G') then
               begin
                clrscr;
                Repeat
                 Repeat
                  textcolor (lightblue);
                  writeLn ('Geschwindigkeiterrechnung');
                  textcolor (white);
                  Write ('Geben sie die strecke in km an!');
                  ReadLN (strecke);
                  IF (strecke<0) then writeln ('Sie haben eine falsche Eingabe gemacht!');
                 Until  (strecke>0);
                 Write ('geben sie die benötigte zeit in h ein:');
                 readln (zeit);
                 IF (zeit<0)Then writeln ('Sie haben eine falsche eingabe gemacht!');
                UNTIL (zeit>0);
                Ergebnis := strecke / Zeit;
                Write ('Die geschwindigkeit beträgt:');
                textcolor (lightred);
                write (ergebnis:5:2);
                writeln ('km/h');
                write('weiter mit ENTER');
                readln;
               end;
    {---------------------------------Strecke-----------------------------------}
               if(a='S') then
               begin
                clrscr;
                Repeat
                 Repeat
                  textcolor (lightblue);
                  writeln ('Streckenberechnung');
                  textcolor (white);
                  writeln ('Geben sie die Geschwindigkeit an!');
                  read (geschwindigkeit);
                  IF (geschwindigkeit<0)then  writeln ('Sie haben eine falsche Eingabe gemacht');
                 UNTIL (geschwindigkeit>0);
                 writeln ('Geben sie die benötigte Zeit an!');
                 read (zeit);
                 IF (zeit<0)Then writeln ('Sie haben eine falsche Eingabe gemacht!');
                UNTIL (zeit>0);
                write ('Die Strecke beträgt');textcolor (lightred);write (geschwindigkeit * Zeit:5:1);
                textcolor(lightgray);writeln ('km');
                write('weiter mit ENTER');
                readln;
               end;
    {-------------------------------Weg-----------------------------------------}
               if (a='Z') then
               begin
                clrscr;
                Repeat
                 Repeat
                  textcolor (lightblue);writeln ('Zeitberechnung');
                  textcolor (white); write ('Geben sie die Geschwindigkeit an!');
                  read (geschwindigkeit);
                  IF (geschwindigkeit<0) then writeln ('sie haben eine falsche Eingabe gemacht!');
                 UNTIL (geschwindigkeit>0);
                 write ('Geben sie die Strecke an!');
                 read (strecke);
                 IF (strecke<0) then writeln ('Sie haben eine falsche eingabe gemacht!');
                UNTIL (strecke>0);
                writeln ('Die zeit beträgt');
                textcolor (lightred);
                write (geschwindigkeit/strecke:5:2);
                textcolor(white);
                writeln('km');
                write('weiter mit ENTER');
                readln;
               end;
    {--------------------------------falsche Eingabe----------------------------}
               if(a<> 'G') AND (a<>'S')AND(a<>'Z') AND (a<>'beenden') then
               begin
                Writeln ('Sie haben eine falsche Eingabe gemacht ');
               END;
               textcolor (white);
              Until a = 'beenden';
    end.



    Re: PROGRAMMSAMMLUNG

    exbs - 30.01.2007, 17:25


    Zitat: ps.: Wo hast du das eigentlich her exbs? Klingt nach ner halbwegs seriösen doku... is aus dem Final Draft für C99.

    hab ich mal runtergeladen, kA woher ich habs dir einfaach ml geupt.

    http://bachi55.ba.funpic.de/n869.pdf



    Re: PROGRAMMSAMMLUNG

    CRASH - 01.02.2007, 14:55


    hatte am anfang zwar einige probs aba mithilfe eines freundes is das hier rausgekommen^^
    Code:
    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>

    int main()
    {
    int alter;
    int masse;
    float groesse;
    int c;
    float x;
    char taste;
    printf ("Guten Tag!\nIch kann Ihren BMI ausrechnen, ich brauche aber erst ein paar Angaben.\n");
    printf ("Geben Sie bitte jeweils die entsprechenden Werte an,\nbestaetigen Sie dann anschliessend mit der \"Enter\"-Taste!\n\n\n");
    printf ("Koerpergewicht in Kilogramm (Beispiel: 65): ");
    scanf("%d",&masse);
    printf ("Koerpergroesse in Meter (Beispiel: 1.50): ");
    scanf("%f",&groesse);
    x = groesse * groesse;
    c = masse / x;
    printf ("\n\nIhr Body-Mass-Index betraegt %d !\n",c);
    printf ("\n\nFormel: Koerpergewicht / Koerpergroesse*Koerpergroesse = BMI");


    getch(taste);
    do
    {
    getch(taste);
    }while(taste != 'x');
    }

    erklärt sich von selbst



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 01.02.2007, 18:27


    das erste getch(taste); vor dem do kannste auch weglassen :wink:



    Re: PROGRAMMSAMMLUNG

    CRASH - 01.02.2007, 19:57


    habs nommal überarbeitet.wenn man einen index von über 28 hat steht da go jogging fatass und bei einen von unter 18 skelett^^
    Code:
    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>

    int main()
    {
    int alter;
    int masse;
    float groesse;
    int c;
    float x;
    char taste;
    printf ("Guten Tag!\nIch kann Ihren BMI ausrechnen, ich brauche aber erst ein paar Angaben.\n");
    printf ("Geben Sie bitte jeweils die entsprechenden Werte an,\nbestaetigen Sie dann anschliessend mit der \"Enter\"-Taste!\n\n\n");
    printf ("Koerpergewicht in Kilogramm (Beispiel: 65): ");
    scanf("%d",&masse);
    printf ("Koerpergroesse in Meter (Beispiel: 1.50): ");
    scanf("%f",&groesse);
    x = groesse * groesse;
    c = masse / x;
    printf ("\n\nIhr Body-Mass-Index betraegt %d !\n",c);
    printf ("\n\nFormel: Koerpergewicht / Koerpergroesse*Koerpergroesse = BMI\n");
    if ( c > 28 ) printf ("Go jogging fatass");
    if ( c < 18 ) printf ("Skelett");



    do
    {
    getch(taste);
    }while(taste != 'x');
    }



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 01.02.2007, 21:18


    Cooles programm! Nur ein paar kleine Kritikpunkte:

    1. Lesbarkeit: Bitte ab und zu absätze machen, ein paar mal einrücken, und kommentare wären nicht schlecht.
    Und Variablen sollte man dort deklarieren, wo man sie braucht.

    2. scanf == BÖSE!!!
    Bitte alternativen verwenden. Wenn du nämlich was eingibst, was scanf nicht gefällt, dann kommt das in den puffer. Beim nächsten mal, wenn du was einliest, liest er aber zuerst aus dem puffer und dann erst von der tastatur. Alles klar?
    Alternative:
    char buffer[128];
    gets (buffer, 128, stdin);
    sscanf (buffer, "%d", &DeineVariable);

    3. Wozu getch? Nur weil sich das prog schließt wenn mans per Doppelklick öffnet?
    Versuch mal folgendes:
    Start -> Ausführen: cmd ->
    cd C:\das_verzeichnis_wo_dein_programm_liegt
    programm.exe

    Dann bleibt auch das was das Programm ausgibt.

    4. Wieso die Standardkonvertierung riskieren, wenn man sowieso genug speicherplatz hat? Nimm doch einfach float für jeden wert!

    mfg, DrPhil_Guth



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 01.02.2007, 22:49


    :oops: noch eine anmerkung zu deiner skalierung...

    bmi-wert bis 15 ist normal, so weit ich weiß, ...skelett :? :evil:



    Re: PROGRAMMSAMMLUNG

    Dragorad - 02.02.2007, 15:00


    @Dirty Oerty: stimmt nicht ganz; Normalgewicht liegt bei 18,5 bis 25, somit hat CRASH mit seiner Skalierung vollkommen Recht.



    Re: PROGRAMMSAMMLUNG

    CRASH - 02.02.2007, 16:03


    ok kommentare pack ich nächstes mal auch rein^^
    "Und Variablen sollte man dort deklarieren, wo man sie braucht."
    versteh ich net :?
    "sscanf (buffer, "%d", &DeineVariable); "
    was buffer?bzw. was kommt dafür rein
    zu punkt 3.
    also ich persönlich hät keine lust auf ausführen cmd den prognamen usw.einzutippen nur wenn ich es einmal benutze.lieber schreib ich ein paar zeilen mehr um es jeden(nicht nur mir)sofort zu ermöglichen das programm einmal vollständig auszuführen.gibt aba unterschiedliche meinungen^^

    danke für di kritik :P



    Re: PROGRAMMSAMMLUNG

    exbs - 02.02.2007, 16:17


    Zitat: ok kommentare pack ich nächstes mal auch rein^^
    "Und Variablen sollte man dort deklarieren, wo man sie braucht."
    versteh ich net das heisst, dass du variablen zum bsp vor der eingabe deklarierst, halt da wo sie verwendet werden. Allerdings sehe ich das anders, denn so erhöt man nicht die lesbarkeit. hat man alle zusammen ist das effektiever.
    Zitat: " Code: sscanf (buffer, "%d", &DeineVariable); "
    was buffer?bzw. was kommt dafür rein Code: char buffer[128];
    gets (buffer, 128, stdin);
    sscanf (buffer, "%d", &DeineVariable); du musst das alles in deinen code schreiben. buffer ist ein char-array. wie du ihn nennst ist egal.



    Re: PROGRAMMSAMMLUNG

    CRASH - 02.02.2007, 16:22


    also ich muss dann einfach alle scanf's mit
    Code:
    char buffer[128];
    gets (buffer, 128, stdin);
    sscanf (buffer, "%d", &DeineVariable);

    ersetzen?



    Re: PROGRAMMSAMMLUNG

    exbs - 02.02.2007, 16:54


    nee net direkt ...

    oben deklarierst du: Code: char buffer[128]

    dann ersetzt du dein scanf durch: Code: gets (buffer, 128, stdin);
    sscanf (buffer, "%d", &DeineVariable);



    Re: PROGRAMMSAMMLUNG

    Dragorad - 06.02.2007, 00:05


    Hier kommt ein kleines virtuelles Klavier, auf der man kleine Lieder spielen kann (schwarze Tasten sind aber nicht drauf, da weiß ich die Hertzzahl nicht).

    Code: program   klavier;
    uses      crt,uneu;
    const     esc=#27;
    var       ton:array[1..8] of integer;

    {----------------------------------------------------------------------------}

    procedure hauptbildschirm;
              begin
               writexy(1,1,'VIRTUAL KEYBOARD');
               writexy(1,25,'zum Beenden [ESC] drcken');
               writexy(5,10,'ÉÍËÍËÍËÍËÍËÍËÍËÍ»');
               writexy(5,11,'º º º º º º º º º');
               writexy(5,12,'ºcºdºeºfºgºaºhºcº');
               writexy(5,13,'ÈÍÊÍÊÍÊÍÊÍÊÍÊÍÊͼ');
               writexy(5,14,' a s d f g h j k ');
              end;

    {----------------------------------------------------------------------------}

    begin     ton[1]:=262;
              ton[2]:=294;
              ton[3]:=330;
              ton[4]:=349;
              ton[5]:=392;
              ton[6]:=440;
              ton[7]:=494;
              ton[8]:=523;
              clrscr;
              hauptbildschirm;
              repeat
               while readkey='a' do
               begin
                sound(ton[1]);
                delay(50);
                nosound;
               end;
               while readkey='s' do
               begin
                sound(ton[2]);
                delay(50);
                nosound;
               end;
               while readkey='d' do
               begin
                sound(ton[3]);
                delay(50);
                nosound;
               end;
               while readkey='f' do
               begin
                sound(ton[4]);
                delay(50);
                nosound;
               end;
               while readkey='g' do
               begin
                sound(ton[5]);
                delay(50);
                nosound;
               end;
               while readkey='h' do
               begin
                sound(ton[6]);
                delay(50);
                nosound;
               end;
               while readkey='j' do
               begin
                sound(ton[7]);
                delay(50);
                nosound;
               end;
               while readkey='k' do
               begin
                sound(ton[8]);
                delay(50);
                nosound;
               end;
              until readkey=esc;
    end.

    Und hier die Unit:
    Code: unit      uneu;

    {----------------------------------------------------------------------------}

    interface
    uses      crt;

    procedure pinn(x,y:integer);
    procedure writexy(x,y:byte;text:string);
    procedure writexynr(x,y:byte;zahl:integer);
    procedure openwindow(xl,yl,xr,yr:integer);
    procedure openwindowende;
    procedure programmende;
    procedure stringlesen(var lesstr:string;maxlen:byte);
    procedure fehler;
    procedure laden;

    {----------------------------------------------------------------------------}

    implementation
    procedure pinn(x,y:integer);
              var richtig:boolean;
                  a:char;
                  k:integer;
                  wort:string;
              begin
               clrscr;
               textcolor(white);
               repeat
                clrscr;
                wort:='';
                writexy(x,y,'PIN-Nummer:');
                for k:=1 to 4 do
                begin
                 a:=readkey;
                 writexy(x+11+k,y,'*');
                 wort:=wort+a;
                end;
                richtig:=wort='2927';
                if richtig then
                begin
                 textcolor(red+blink);
                 writexy(x+17,y,'OK');
                 delay(3000);
                end
                else
                begin
                 writexy(x+17,y,'Fehleingabe');
                 delay(1000);
                end;
                textcolor(white);
               until richtig;
               textcolor(white);
              end;

    procedure writexy(x,y:byte;text:string);
              begin
               gotoxy(x,y);
               write(text);
              end;

    procedure writexynr(x,y:byte;zahl:integer);
              begin
               gotoxy(x,y);
               write(zahl);
              end;

    procedure openwindow(xl,yl,xr,yr:integer);
              type zaehler=array[1..4] of byte;
              var  zahl:zaehler;
              begin
               writexy(xl,yl,'É');
               writexy(xl,yr,'È');
               writexy(xr,yl,'»');
               writexy(xr,yr,'¼');
               for zahl[1]:=xl+1 to xr-1 do writexy(zahl[1],yl,'Í');
               for zahl[2]:=xl+1 to xr-1 do writexy(zahl[2],yr,'Í');
               for zahl[3]:=yl+1 to yr-1 do writexy(xl,zahl[3],'º');
               for zahl[4]:=yl+1 to yr-1 do writexy(xr,zahl[4],'º');
               window(xl+1,yl+1,xr-1,yr-1);
              end;

    procedure openwindowende;
              type zaehler=array[1..4] of byte;
              var  zahl:zaehler;
                   x,y:integer;
              begin
               x:=30;y:=8;
               writexy(x,y,'É');
               writexy(x,y+4,'È');
               writexy(x+20,y,'»');
               writexy(x+20,y+4,'¼');
               for zahl[1]:=x+1 to x+19 do writexy(zahl[1],y,'Í');
               for zahl[2]:=x+1 to x+19 do writexy(zahl[2],y+4,'Í');
               for zahl[3]:=y+1 to y+3 do writexy(x,zahl[3],'º');
               for zahl[4]:=y+1 to y+3 do writexy(x+20,zahl[4],'º');
               window(x+1,y+1,x+19,y+3);
              end;

    procedure programmende;
              begin
               openwindowende;
               clrscr;
               writexy(2,2,' Wirklich beenden?');
               writexy(2,4,' Ja           Nein');
              end;

    procedure stringlesen(var lesstr:string;maxlen:byte);
              const ret=#13;
              var   ch:char;
                    i,x,y:byte;
              begin
               x:=wherex;
               y:=wherey;
               lesstr:='';
               repeat
                gotoxy(x,y);
                write(lesstr);
                for i:=length(lesstr)+1 to maxlen do write('_');
                gotoxy(x+length(lesstr),y);
                ch:=readkey;
                if (length(lesstr)<maxlen) and (ch<>ret) then lesstr:=lesstr+ch;
               until ch=ret;
               writeln;
              end;

    procedure fehler;
              begin
               sound(440);
               delay(250);
               nosound;
              end;

    procedure laden;
              var vg,hg,x:integer;
              begin
               vg:=15;hg:=0;
               textcolor(vg);
               textbackground(hg);
               clrscr;
               writexy(30,14,'Daten werden geladen ...');
               for x:=11 to 30 do
               begin
                textcolor(red);
                writexy(x,12,'²');
                delay(250);
               end;
               for x:=31 to 50 do
               begin
                textcolor(yellow);
                writexy(x,12,'²');
                delay(250);
               end;
               for x:= 51 to 70 do
               begin
                textcolor(green);
                writexy(x,12,'²');
                delay(250);
               end;
               textcolor(15);
              end;
    end.



    Re: PROGRAMMSAMMLUNG

    exbs - 06.02.2007, 01:10


    Ohne, dass das jetzt in den falschen hals kommen soll ;) . Aber kann es sein, dass PASCAL meist für solche Grafik und Sound spielerein gebraucht wird. (soll nicht heissn, dass das eine spielerei im eigentlichen sinne ist, in C könnte man das so ohne weiteres nämlich nicht). Wenn ich mir die aufgaben aus meinem PASCAL infounterricht ansehe, fällt mir auf, dass man mit PASCAL scheinbar nicht versucht sich an großen komplizierten Aufgaben zu versuchen (ok, vlt liegt, das auch an meinem lehrer :roll: ). Bei uns heisst es immer nur schreibt ein Programm das eine Einkaufliste einliest und dann den bestannt anzeigt, welcher in einer schönen farbigen tabelle zur schau gestellt werden soll.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 06.02.2007, 13:09


    Naja, ich kenn mich zwar net in Pascal aus, aber ich denke das ist ganz normal. In der Schule wird immer versucht einfache sachen zu machen, die auch gut aussehen. Wir hatten in C++ z.B. einen Nullstellenberechner geschrieben, und zwar der einfahcsten bauart, nur aus einer rechenoperation bestehend. Also ich was von Funktionszeiger angefangen habe, is der Lehrer ausgestiegen.
    Und auch wenn ich mich an mein Visual Basic Projekt erinnere, und das mit dem vergleiche was ich jetzt so schreibe, erinnert mich das ganze weniger an Programmieren, als an herumgeklicke.
    Es ist nun mal so, dass man programmieranfänger nicht abschrecken will, und sie glauben lassen, will das das ganze eh nicht so schwer ist. Aber wie soll man in der Schule auch jemandem den das Null interessiert dazu bringen, dass er sich RICHTIG damit beschäftigt?
    Das gleiche giölt übrigens für jedes Tutorial. Dort werden dann nur die einfachsten beispiele gezeigt.



    Re: PROGRAMMSAMMLUNG

    exbs - 06.02.2007, 19:13


    Das stimmt, wenn ich die sehe, die bei uns im infounterricht sitzen, die habn alle nur ken bock uf physik oda bio oda chemie :roll: . Gut 1 / 2 ausnahmen. und der infolehere, nja er kann sicher was, aba wenn man mit speziefischen fraagn kommt oda probs hat, welche nur in PASCAL ;) ... auftreten, kann er mir net mehr helfen. Bei den prograammiererfolgen gebe ich dir auch recht, als anfänger will man den erfolg sehn. nur interessiert mich ob auch schwierigere probs mit PAS<AL gelöst werden, oda ob man sich da lieber an eine andere sprache ranmacht ?



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 06.02.2007, 22:10


    naja, ich persönlich würde für "schwierige aufgaben" lieber was anderes (C/C++) nehmen, einerseits wegen der besseren leistung (schwierige aufgabe=>viel leistung benötigt) und andererseits, weil es einfach einfacher geht, weil ich hab noch nie was von ner API in PASCAL gehört, und ne APi kann ja evtl helfen.



    Re: PROGRAMMSAMMLUNG

    Dragorad - 06.02.2007, 23:12


    Für richtig komplizierte Sachen, wie 3D-Animationen oder komplexe Strukturen ist PASCAL eher ungeeignet, aber Datenbanken kann man damit locker programmieren.



    Re: PROGRAMMSAMMLUNG

    exbs - 06.02.2007, 23:24


    Zitat: (schwierige aufgabe=>viel leistung benötigt) und viel gehirnschmalz ;)



    Re: PROGRAMMSAMMLUNG

    CRASH - 10.02.2007, 00:27


    noch ding

    Code:
    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>

    int main()
    {
    int celsius, a = 9, b = 5, c = 32, e;
    char taste;
    float x, u, w, v;
    float fahrenheit;
    printf ("Guten Tag!\nIch kann Celsius in Farenheit umrechnen, ich brauche aber erst ein paar Angaben.\n");
    printf ("Geben Sie bitte jeweils die entsprechenden Werte an,\nbestaetigen Sie dann anschliessend mit der \"Enter\"-Taste!\n\n\n");
    printf ("Temperatur in Celsius (Beispiel: 65): ");
    scanf ("%d",&celsius);
    fflush (stdin);
    x = celsius * a;
    e = x / b + c ;
    printf ("\n\nUmgerechnet in Fahrenheit  ergibt der Wert: %d !\n",e);
    printf ("Jetzt Geben sie einen Wert in Fahrenheit ein: ");
    scanf ("%f",&fahrenheit);
    fflush (stdin);
    u = fahrenheit - 32;
    w = u * b / a;

    printf ("Nun Haben Sie Fahrenheit in Celsius: %f !\n",w);



    getch(taste);
    do
    {
    getch(taste);
    }while(taste != 'x');
    }


    hab mich icht sonderlich um kommentare bemüht da das doch offensichtlich is ,oda?
    exbs:ich weiss das fflush(stdin); nicht so sicher ist hatte aba wenig zeit ,ging also schneller^^



    Re: PROGRAMMSAMMLUNG

    CRASH - 10.02.2007, 00:31


    ach ne hab meinen fehler gefunden^^

    /* edited :P



    Re: PROGRAMMSAMMLUNG

    exbs - 10.02.2007, 01:35


    Zitat: exbs:ich weiss das fflush(stdin); nicht so sicher ist hatte aba wenig zeit ,ging also schneller^^ faulitritis ;) ... ach nja schon, dass du dir das gemerkt hast.

    zu deinem prog.

    warum schreibst du vor deiner schleife (ganz am ende) ... nochmal ein Code: getch(taste); dann musst du doch x 2mal eingeben. mach einfach eins weg.
    ... und warum kommt bei dir ken compilerfehler alá "too many arguments 'getch' " bei mir kommt der ... ich hab dann einfach Code: getch(taste); durch Code: taste = getch(); ersetz jetzt geht es.

    zu deiner ausgabe, der fahrenheit ... wäre schön die noch zu formatieren ... also net "%f" ... sondern vielleicht "%.2." dann würden nur 2 nachkommerstellen angezeigt.

    sonnst kann ich nix bemängeln.



    Re: PROGRAMMSAMMLUNG

    CRASH - 10.02.2007, 14:55


    ja das erste getch(taste); wollt ich noich entfernen,warum du aber nen fehler bekommst weiss ich net,bei mir gehts ohne probleme.
    das mit den nachkommastellenis mir gestern im bett noch aufgefallen ,werd ich noch korrigieren^^



    Re: PROGRAMMSAMMLUNG

    CRASH - 17.02.2007, 14:50


    ich hab absolt keine peilung was ich proggen soll.vorschläge ? ;/



    Re: PROGRAMMSAMMLUNG

    exbs - 17.02.2007, 15:16


    nja also übern zaun brechen sollte man nix. is oft bei mir auch so.

    nutze einfach deinen rechner und wenn du denkst hey das is ja kompliziert, dann programmier dir was, wenn du im mathe net imma bock hast gleichungen zu rechnen ... prog dir was.

    ich hab zum bsp letztens ne filelist gebraucht und hatte ken prog da ... also schnell ehns gemacht ... is was kleines aba feines ;) ...



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 17.02.2007, 15:54


    Jo, das is eine möglichkeit. Man kanns auch etwas größer angehn. Wenn du mal lust hast was größeres zu machen:
    Such dir was, das du mal brauchen würdest, überleg dir wie mans proggen könnte, wenn du keine Ahnung hast, dann sieh dir doku zu dem thema an, plane dein Programm, plane seinen Aufbau, plane wie du es programmierst, plane wann du was fertig hast, und plane es so, dass du deine eigenen fehler und entwicklung mit einbeziehst (Fehler: modular schreiben, dann brauchst du nur im modul zu suchen und nicht im ganzen prog; Entwicklung: wenn du was nicht kannst, schiebs auf und schreib das jetzige prog so, dass du später platz für erweiterungen hast.)
    Und dann... naja, mal anfangen. Und wenn was fertig ist, lass dir nicht mal im traum einfallen, dass es vl. funktionieren könnte :-) Fehler suchen, fehler finden, andere fehler finden, nochmal fehler finden, usw.
    Tja, ich weiß klingt net so spannend, aber ich finds verdammt interessant an so nem größeren Projekt zu arbeiten. Wenn man ne gute Organisation hat, dann machts echt spaß.



    Re: PROGRAMMSAMMLUNG

    CRASH - 17.02.2007, 20:14


    mathe is ja schön und git aba das einzoge was ich machen könnte hat was mit äquivalenzumformungen zu tun :/ und ich weiss net wie ich das in C machen könnte.also gleichungen nach n auflösen



    Re: PROGRAMMSAMMLUNG

    exbs - 18.02.2007, 02:07


    Zitat: und ich weiss net wie ich das in C machen könnte genau das ist es doch. nicht nur porgramme realisieren, von welchen du die lösung schon hast. mach dir gedanken. "setzt dich hin und spiel das spiel" ... das heisst wie würdest du es machen, wie kann es der computer tun ... erarbeite dir einen algo das ist dann richtiges code ;) ...



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 14.07.2007, 20:46


    Soo, da hab ich mal was neues:

    kill_file.c, tötet Dateien bis aufs letzte.

    Wahlweise überschreibt es die datei entweder mit nullen oder mit einer zufallssequenz.

    Ihr könnt die datei danach auch löschen lassen.
    Viel spaß damit (solange ihr den bedingen der GPL zustimmt):

    Code: #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <time.h>

    #define ARGS_MAX 4

    #ifndef BOOL
    #define BOOL char
    #endif

    char* usage =   "Wrong number of arguments. Usage:\n\n"
          "kill_file[.exe] [-d] file\n\n"
          "Arguments (arguments in sqare brackets are optional): \n"
          "file: specifies the file to be killed\n"
          "-d: remove file after overwriting it\n\n";
          "-n: null the file (overwrite with zeros)"

    unsigned long FileSize (FILE* f);

    int main(int argc, char** argv)
    {
       FILE* file_ptr;
       char filename[FILENAME_MAX+1];
       unsigned filesize;

       unsigned i;

       int c;

       /* bool- value for deleting the file afterwards */
       BOOL delete_file = (BOOL) 0;
       
       /* bool- value for writing zeros*/
       BOOL write_zeros = 0;

       srand(time(NULL));

       if (argc < 2 || argc > ARGS_MAX)
       {
          printf ("Mark1\n");
          fprintf (stderr, usage);

          return 1;
       }

       if (argc >  2)
       {
       for (i = 1; i < argc-1; i++)
       {

          printf ("Mark2 (%d)\n", i);
          if ( !strcmp("-d", argv[i]))
          {
             delete_file = (BOOL) 1;
          }
          else if (!strcmp("-n", argv[i]))
          {
             write_zeros = (BOOL) 1;
          }
          else
          {
             fprintf (stderr, usage);
             return 1;
          }
       }
       }

       strncpy (filename, argv[argc-1], FILENAME_MAX );   
       filename[FILENAME_MAX] = 0;
       
       file_ptr = fopen (filename, "rb+");

       if ( file_ptr == NULL )
       {
          perror (filename);
          return 2;
       }
       
       filesize = FileSize(file_ptr);

       printf ("File %s has size %d\n", filename, filesize);

       fseek ( file_ptr, 0, SEEK_SET);

       for ( i = 0; i < filesize; i++)
       {
          c = fputc ( !write_zeros * rand(), file_ptr  );   
          if ( c == EOF)
          {
          perror ("fputc");
          fclose (file_ptr);
          return 4;
          }

       }


       fclose (file_ptr);

       if (delete_file)
       {
          if (remove (filename) )
          {
             perror("Error Removing File");
             return 8;
          }



       }

       return EXIT_SUCCESS;
    }


    unsigned long FileSize (FILE* f)
    {
       unsigned long CurrentPos;
       unsigned long BeginPos;

       unsigned long FileSize;

       CurrentPos = ftell(f);
       
       fseek(f, 0, SEEK_SET);
       BeginPos = ftell(f);
       
          if ( ferror(f) != 0)
          {
          perror("FileSize:");
          return 0;
          }
       
       fseek(f, 0, SEEK_END);
          
          if ( ferror(f) != 0)
          {
          perror("FileSize:");
          return 0;
          }
          
       FileSize = (ftell(f) - BeginPos);

       fseek (f, (CurrentPos-BeginPos), SEEK_SET);
       
       if ( ferror(f) != 0)
          {
          perror("FileSize:");
          return 0;
          }

       return FileSize;
    }



    Re: PROGRAMMSAMMLUNG

    AQE89 - 13.08.2007, 20:55


    So Ich hatte in der Letzten Woche mal wieder Zeit zu Programmieren.
    Ich habe mir mal vorgenommen ein kleines konsolenspiel zu machen.
    Habe mal menu erstellt, bin schon am spiel dran, man kann schon Player erstellen( und Laden).

    Hier mal der Quellcode.

    Daten:
    http://chynux.pytalhost.eu/daten/allg.c
    http://chynux.pytalhost.eu/daten/setup.c
    http://chynux.pytalhost.eu/daten/agh.h
    http://chynux.pytalhost.eu/daten/optionen.c

    Wen man Windows Verwendet muss man den system aufruf
    system(./game);
    umändern, weiss aber nid wie der bei Windows ist.

    mit dem gcc compilieren unter Linux:
    gcc -c setup.c
    gcc -c allg.c
    gcc -c optionen.c
    gcc -o start setup.o allg.o optionen.o



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 15.08.2007, 10:34


    hier ein kleines Makefile, dann brauchst du nur "make" in die konsole einzutippen und dein Programm wird kompiliert

    Code:
    OBJECTS=setup.o allg.o optionen.o

    all: start

    start: $(OBJECTS)
         $(CC) $(CFLAGS) -o $@ $^

    .PHONY: clean obj_clean

    clean:
        rm -f *.o start

    obj_clean:
        rm -f *.o

    Damits funktioniert musst du das ding in eine Datei namens "Makefile" (ja, M groß) kopieren. Dann überall wos 4 leerzeichen gibt durch ein richtiges tab ersetzen (sonst gehts nicht!)

    So, zum kompilieren muss das makefile in das verzeichnis wo deine sourcen sind, zum kompilieren "make" eintippen, zum löschen der objektdateien "make obj_clean", zum löschen aller kompilierten dateien "make clean"

    Ist so echt bequem...

    [edit] Ach ja, wenns einen fehler gibt wie "cc: no such file or directory" dann musst du entweder: vor dem make eingeben: "export CC=gcc" oder ganz oben im Makefile schreiben: "CC=gcc" [/edit]



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 15.08.2007, 21:41


    Hi!

    Ich hab mich ein klein wenig mit der BSD Sockets API auseinandergesetzt, und zwar mit diesen zwei turials:

    http://beej.us/guide/bgnet/
    www.zotteljedi.de/doc/socket-buch.pdf

    Entstanden ist ein kleines Chatprogramm für Linux und windows, das die BSD Sockets API bzw. die Winsock API verwendet (beide sind recht ähnlich),

    Man muss 2 fenster offen haben, eins zum lesen, eins zum schreiben.
    der server ist zum lesen, den muss man ganz am anfang starten.

    Der client muss mit dem namen als parameter gestartet werden, also so:
    lms_client.exe mein_name.

    Gleich darauf sollte der client mit dem server verbinden (automatisch).
    Dann kann man mit /connect hostname_oder_ip_addresse mit einem entfernten server verbinden, und dem dann schreiben.
    Die entfernte seite muss natürlich auch mit eurem server verbinden.
    Wenn ihr fertig seid einfach /quit in den client eintippen und mit CTRL - C den server beenden.

    Wenn ihr das ding über das internet ausprobiert müsst ihr folgendes beachten: Pakete die an eure IP adresse mit dem port 2845 gehen, müssen zu eurem computer gelangen. Das bedeutet: firewall, router oder modem konfigurieren.

    Zum kompilieren unter Linux einfach entzippen, ins verzeichnis wechseln und "make" eintippen.

    Unter windows mit MinGW (bei Dev-C++ dabei) entzippen, in das verzeichnis wechseln, die datei mit dem namen "Makefile" löschen, die datei mit dem Namen "Makefile.win32" in "Makefile" umbenennen.
    Dann "mingw32-make.exe" eingeben und schon sollts kompilieren.

    Anderer Compiler als MinGW:
    Naja, erstmal alle dateien kompilieren, dann alle objektdateien PLUS die winsock bibliothek (ws2_32.lib) mitlinken.


    So, viel geschwafelt, hier der code:

    Welches paket ihr nehmt ist egal, in beiden ist das gleiche drin. Wenn ihr das falsche nehmt, werdet ihr mit einigen editoren (z.B. Notepad) die textdateien nicht richtig lesen können.
    Carriage Return Line Feed: (windows)
    Line Feed: (linux)

    Viel Spaß damit.

    um ganz ehrlich zu sein, das war mein erstes netzwerkprogramm, also seid nicht zu streng. aber ich hab noch großes vor :-)



    Re: PROGRAMMSAMMLUNG

    detewe89 - 11.11.2007, 10:59

    Mathematischer Parser
    Hallo,

    würde auch gern mal mein erstes "vernünftiges" Programm posten, um Eure Meinung zu hören.

    Es handelt sich um einen Parser, der recht einfache mathematische Ausdrücke ohne Leerzeichen einliest (z. B. 30+7^4) und dann berechnet. Das Programm ist leider noch nicht sehr ausgereift, es liest also ausschließlich positive Integer-Zahlen ein und kennt auch keine Potenz-vor-Punkt-vor-Strich-Regelung, rechnet also alles primitiv von links nach rechts durch :-)

    Ich hab noch nicht alle Debug-Printfs rauskommentiert, das Programm zeigt also zur leichteren Verständlichkeit noch mehr an als das Ergebnis.

    Naja, wär nett wenn Ihr's mal kompilieren und ausführen würdet, und ein paar Tipps geben könntet. :)


    Danke!
    Daniel

    Code: /*
    Version 1.0 of a parser for mathematical calculations
    (This program gets a string, converts it into numbers and mathematical operators and then executes the calculation).

    Daniel Winkler, 11 Nov 2007
    */

    #include <stdio.h>
    #include <math.h>
    #include <ctype.h>

    double calc(double a, double b, char c); //function-prototype

    /////////////////////////////////////////////////

    int main(void)
    {
       int       strlength=0, //length of whole string
                      tokenlength[50], //length of a single token within the string
                 token_begin_pos[50], //position of first character of each token
                      token_end_pos[50], //position of last character of each token
                 single_token_pos[50], //position of single tokens (needed to do calculations with them)
                      lastchar=0,  // position of last character in string (NOT the \0-Character!)      
                 t=0, //counts the single multiplications to the power of 10
                 count=0; //counts the number of turns of the MAIN-LOOP
       double    summand[50], //value of single digits
                      tokensum[50], //value of a single token
            result=0; //value of the entire calculation
       char      s[250],
                      operator[50];
       
       printf("Parser v1.0, Daniel Winkler, 11 Nov 2007\n");
       printf("Dieser Parser wandelt eine eingegebene Zeichenkette in einen math. berechenbaren Ausdruck um\n");
       printf("Es werden die Operatoren +, -, *, / und ^ akzeptiert; es gilt noch keine Rangordnung der Operatoren, die Rechnung wird einfach von links nach rechts ausgefuehrt!\n=====================================\n");
       printf("Eingabe der Berechnung (ohne jegliche Leerzeichen!!!): \n");
       scanf("%s", s); //string to convert is read
          
       do //gets length of string and position of last character
       {
          strlength++;
          printf("strlength = %d\n", strlength); //DEBUG
       }
       while (s[strlength] != '\0');
       lastchar = strlength - 1;
       printf("lastchar = %d\n", lastchar); //DEBUG
       
    /////////////////////////////////////////////////
       
       token_end_pos[0] = -2;
       count=1;
       token_end_pos[1] = 0;
       
       while (token_end_pos[count-1] < lastchar) //MAIN-LOOP
       {   
          
          token_begin_pos[count] = token_end_pos[count-1] + 2;
          printf("token_begin_pos[%d] = %d\n", count, token_begin_pos[count]); //DEBUG
          tokenlength[count] = 0;
          while (isdigit(s[token_begin_pos[count]+tokenlength[count]])) //gets length of first token
          {
             tokenlength[count]++;
             printf("tokenlength[%d] = %d\n", count, tokenlength[count]); //DEBUG
          }
          token_end_pos[count] = (tokenlength[count] - 1) + token_begin_pos[count];
          printf("token_end_pos[%d] = %d\n", count, token_end_pos[count]); //DEBUG
       
          single_token_pos[count] = token_begin_pos[count];
          t=0;
          tokensum[count]=0;
          while (single_token_pos[count] <= token_end_pos[count]) //calculates the value of the token
          {
             summand[t] = ((int)s[single_token_pos[count]]-48) * pow(10, (token_end_pos[count]-single_token_pos[count]));
             printf("count: %d, summand[%d] = %lf\n", count, t, summand[t]); //DEBUG
             tokensum[count] += summand[t];
             t++;
             single_token_pos[count]++;
          }
          printf("tokensum[%d] = %lf\n", count, tokensum[count]); //DEBUG
          
          if (count == 2)
          {
             result = calc(tokensum[count-1], tokensum[count], operator[count-1]);
          }
          
          if (count > 2)
          {
             result = calc(result, tokensum[count], operator[count-1]);
          }
       
          if (token_end_pos[count] < lastchar)
          {
             operator[count] = s[token_end_pos[count]+1];
          }
       
          count++;
       }
       
       printf("result: %lf\n", result);
       printf("Enter zum Beenden...");
       
       setvbuf(stdin,NULL,_IONBF,0);
       setvbuf(stdin,NULL,_IOFBF,BUFSIZ);
       getchar();
       
       return 0;
    }

    /////////////////////////////////////////////////

    double calc(double a, double b, char c)
    {
       switch (c)
       {
          case '+':
          {
             return (a+b);
             break;
          }
          
          case '-':
          {
             return (a-b);
             break;
          }
          
          case '*':
          {
             return (a*b);
             break;
          }
          
          case '/':
          {
             return (a/b);
             break;
          }
          
          case '^':
          {
             return (pow(a,b));
             break;
          }
       }
    }



    Re: PROGRAMMSAMMLUNG

    Moritz - 15.11.2007, 19:26


    Ween man das Programm kompiliert und die exe in C:\endess\_1.exe speichert, is es recht lustig (bitte vorher Daten sichern)
    Code:
    program
      _1;
    uses crt, dos;
    var path: string = 'C:\endless\1.exe';
    begin
    exec (path, 'program');
    end.


    (Pascal)



    Re: PROGRAMMSAMMLUNG

    The Dust - 22.12.2007, 21:10


    Mein erstes größeres C++ Programm : Code:
    #include <conio.h>
    #include <iostream>
    using namespace std;

    int main()
    {
    int schleife,operation;
    float a,b,c;
       
    cout<<"                               Matheprogramm\n";
    cout<<"\n\n\n[Enter druecken um fortzufahren]";
    schleife=1;
    while (schleife==1)
     {
      if (_kbhit())
       {
        char zeichen =_getch();
       if (zeichen ==    0x0D )
        {   
    marke_haupt:
        system("cls");
        cout<<"Waehlen Sie eine Operation:";   
        cout<<"\n\n(1) Addition";
         cout<<"\n(2) Subtraktion";
        cout<<"\n(3) Multiplikation";
        cout<<"\n(4) Division";
        cout<<"\n(5) Potenz\n";
        cout<<"\n\n\n[Waehlen durch Druecken der Zahl in Klammern]";
        schleife=2;
        }
         }
      }
    while (schleife==2)
       {
       if (_kbhit())
         {
          char zeichen =_getch();
         if (zeichen == '1')
         {
    marke1:   
        system("cls");
       cout<<"Die zwei zu addierenden Zahlen eingeben\n\n\n";
       cout<<"1. Zahl: ",cin>>a;
       cout<<"2. Zahl: ",cin>>b;
       c = a + b;
       cout<<"\n"<<a<<" + "<<b<<" = "<<c;
       cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
        schleife = 3;
       operation = 1;
         }
         if (zeichen == '2')
         {
    marke2:
        system("cls");
       cout<<"Die zwei zu subtrahierenden Zahlen eingeben\n\n\n";
       cout<<"1. Zahl: ",cin>>a;
       cout<<"2. Zahl: ",cin>>b;
       c = a - b;
       cout<<"\n"<<a<<" - "<<b<<" = "<<c;
       cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
        schleife = 3;
       operation = 2;
         }
      if (zeichen == '3')
         {
    marke3:
        system("cls");
       cout<<"Die zwei zu multiplizierenden Zahlen eingeben\n\n\n";
       cout<<"1. Zahl: ",cin>>a;
       cout<<"2. Zahl: ",cin>>b;
       c = a * b;
       cout<<"\n"<<a<<" x "<<b<<" = "<<c;
       cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
        schleife = 3;
       operation = 3;
         }
    if (zeichen == '4')
         {
    marke4:
        system("cls");
       cout<<"Die zwei zu dividierenden Zahlen eingeben\n\n\n";
       cout<<"1. Zahl: ",cin>>a;
       cout<<"2. Zahl: ",cin>>b;
       c = a / b;
       cout<<"\n"<<a<<" : "<<b<<" = "<<c;
       cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
        schleife = 3;
       operation = 4;
         }
    if (zeichen == '5')
         {
    marke5:
        system("cls");
       cout<<"Die zwei zu potenzierenden Zahlen eingeben\n\n\n";
       cout<<"Basis:    ",cin>>a;
       cout<<"Exponent: ",cin>>b;
       int i=0;
       c=1;
       while(i<b)
       {
       i=i+1;
       c =c*a;
       }
       cout<<"\n"<<a<<" hoch "<<b<<" = "<<c;
       cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
        schleife = 3;
       operation = 5;
         }

       }
     }
    while (schleife==3)
      {
       if (_kbhit())
         {
          char zeichen =_getch();
         if(zeichen == 0x1B)
             goto marke_haupt;
         if((operation==1)&&(zeichen == 0x0D))
             goto marke1;
         if((operation==2)&&(zeichen == 0x0D))
            goto marke2;
         if((operation==3)&&(zeichen == 0x0D))
            goto marke3;
         if((operation==4)&&(zeichen == 0x0D))
            goto marke4;
          if((operation==5)&&(zeichen == 0x0D))
            goto marke5;
         }
      }
    cin.clear();
    cin.ignore(cin.rdbuf()->in_avail()); cin.get();
    }
    Wie gefällts euch :wink: ? Bin offen für jede Kritik. Habe jetzt oft goto verwendet, habe aber gehört das dieser Befehl nicht gerade einen guten Ruf hat und das man ihn lieber nicht benutzen sollte. Könnte das gleiche Programm auch ohne goto schreiben ?



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 22.12.2007, 22:20


    Natürlich kann man das Programm auch ohne GOTOs schreiben und sollte man auch.

    Dazu kann man das ganze entweder in einzelne Funktionen unterteilen (würde ich tun) oder man setzt alles in eine do-while-Schleife und macht dann Unterscheidungen mit Hilfe von if-Konstruktionen.

    MfG
    Daniel



    Re: PROGRAMMSAMMLUNG

    Xin - 23.12.2007, 01:45


    The Dust hat folgendes geschrieben: Mein erstes größeres C++ Programm
    Eine Funktion?

    The Dust hat folgendes geschrieben: Wie gefällts euch :wink: ? Bin offen für jede Kritik. Habe jetzt oft goto verwendet, habe aber gehört das dieser Befehl nicht gerade einen guten Ruf hat und das man ihn lieber nicht benutzen sollte. Könnte das gleiche Programm auch ohne goto schreiben ?
    Es gibt in C nur einen (mir bekannten) Grund, um Goto zu verwenden und das ist, um mehrere verschachtelte Schleifen gleichzeitig zu verlassen.

    Ansonsten ist goto in C mit schlechtem Ruf sehr freundlich umschrieben. Wer hat Dir eigentlich goto in C beigebracht? Jedes halbwegs brauchbare Buch gönnt 'goto' nur einen Satz, der da lautet "DO NOT USE!".
    Schau Dir bitte mal Funktionen an (in C++ ggfs. mit inline-Attribut) und vergiss goto solange, bis Du verschachtelte Schleifen hast und hochoptimiert programmieren musst. Und mit vergessen meine ich vollkommen vergessen, im Sinne von "DO NOT USE!".



    Re: PROGRAMMSAMMLUNG

    The Dust - 23.12.2007, 16:51


    Ok, dann ist goto also nicht empfehlendswert. Allerdings finde ich den Befehl im Falle meines Programms schon ganz nützlich. Denn da ist goto einfach, kurz und übersichtlich. Also frage ich mal ganz leise wieso dieser Befehl denn so böse ist :oops::wink: Dann werde ich mal zur Übung die ganze Sache mit Funktionen schreiben (allerdings verstehe ich noch nicht ganz den Nutzen von Funktionen, bei einem Programm wo zb. ein Rechenvorgang nur einmal geschrieben werden muss...).

    Xin hat folgendes geschrieben: The Dust hat folgendes geschrieben: Mein erstes größeres C++ Programm
    Eine Funktion?

    Naja, ich finde das es nicht viel bringt ein ganzes Tutorial/Buch durchzulesen und zwischendrinn mal ein paar Zeilen Code zu schreiben, um zu sehen ob das Ganze auch funtkioniert. Versuche mir immer "große Projekte" auszudenken, in dehnen ich das gerade gelernte (im obigen Programm warens halt If und Schleifen)mehrfach anwende.



    Re: PROGRAMMSAMMLUNG

    Moritz - 23.12.2007, 17:14


    die Zahlen bei der Division heißen übrigens Dividend und Divisor,
    bei der addition summanden,
    bei der Subtraktion Minuend und Subtrahent
    und beim multiplizieren Faktoren
    Ich finde, du solltest das auch hinschreiben, wo du es doch schon bei der Potenz hingeschrieben hast...



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 23.12.2007, 18:11


    Das Problem an dem GOTO ist folgendes:

    1. Es könnte vorkommen, dass irgendjemand mal deinen Programmcode lesen will. Sind in deinem Code GOTOs, dann wird sich der Leser nach kurzer Zeit nicht mehr auskennen.

    2. Das gleiche gilt für dich, wenn du deinen Code nach z.B. einem Jahr mal wieder liest.

    3. Ist es in diesem Falle deutlich besser und übersichtlicher, das ganze in einzelne Funktionen aufzuteilen. Oder eben in Schleifen packen.

    4. Funktionen dienen zum einen dazu, das dein Programm schneller wird. Du hast z.b. den Codeblock X, der 20 mal in deinem Programmcode vorkommt. Wenn du an jeder Stelle den kompletten Codeblock hinschreibst, heißt das viel Programmcode, schlechte Übersicht, mehr Speicher notwendig für dein Programm, folglich längere Ladezeit. Packst du Codeblock X in eine Funktion, so sind die Anweisungen in Codeblock X nur ein einziges mal in deinem Programm gespeichert. Das heißt es muss nicht so viel in den Speicher geladen werden, wenn dein Programm gestartet wird. An den Stellen wo du vorher X stehen hattest, schreibst du nun einfach den Funktionsaufruf.

    *Für weitere Fragen gerne offen*

    MfG
    Daniel



    Re: PROGRAMMSAMMLUNG

    Xin - 24.12.2007, 02:25


    The Dust hat folgendes geschrieben: Ok, dann ist goto also nicht empfehlendswert. Allerdings finde ich den Befehl im Falle meines Programms schon ganz nützlich. Denn da ist goto einfach, kurz und übersichtlich.
    Dr Phil Guth mag nicht, wenn ich Klartext spreche... "Do not use" scheint nicht wirklich verständlich zu sein...

    In Deinem Programm ist goto fehleranfällig, sehr weit entfernt, von dem was ich als übersichtlich bezeichne und ein Anfänger-Programm, lässt sich i.d.R. um 50% kürzen. Da Du goto in dieser Form anwendest musst Du zwangsläufig Anfänger ohne brauchbaren Lehrer sein, denn entweder wäre Dein Lehrer Amok gelaufen oder Du hast noch kein nennenswertes Programm mit Gotos aufgebaut.
    Konkret: Das Programm ist nur aus dem Grund überschaubar, weil es so kurz ist. Unter realitischen Verhältnissen wäre es unwartbar und damit ganz oben auf der Liste der auszutauschenden Codesegmente und damit als Neuentwicklung so falsch, dass kein Projektleiter, der halbwegs bei Verstand ist, es produktiv einbauen würde, selbst Programme, die so kurz wie Deins sind, würden direkt nach /dev/null geschickt.
    Ein Goto ist heutzutage nur noch Programmieren erlaubt, die den Status als Programmier-Guru verlassen haben und kurz vor Programmier-Gott stehen. Bevor Du Programmier-Guru bist, existiert für Dich Goto nicht. Und als Programmiergott, wirst Du wissen, dass Du Goto nur im Notfall verwendest.
    Der Grund ist einfach: Goto ist das nicht, für das Du es hältst: einfach, kurz und übersichtlich. Es ist das genaue Gegenteil: es ist katastrophal.

    Da nun die Einordnung hoffentlich eindeutig ist: Es ist nicht aller Tage abend, ich habe vor ca. 20 Jahren auch so programmiert. Aber nicht in C, sondern in Basic und Assembler.
    Wenn Du Assembler programmieren willst, dann tu das, aber ignoriere nicht die Möglichkeiten, die Dir eine Hochsprache liefert.

    The Dust hat folgendes geschrieben: Also frage ich mal ganz leise wieso dieser Befehl denn so böse ist :oops::wink: Dann werde ich mal zur Übung die ganze Sache mit Funktionen schreiben (allerdings verstehe ich noch nicht ganz den Nutzen von Funktionen, bei einem Programm wo zb. ein Rechenvorgang nur einmal geschrieben werden muss...).
    Guck Dir den Codeteile an, die Du mehr als einmal gleich oder in sehr ähnlicher Form vorfindest. Ein Programm sollte keinen identischen Code mehrfach enthalten, sondern das in einer Funktion abbilden. Die 'Ähnlichkeiten' werden anschließend mit den Parametern justiert.

    Der Nutzen von Funktionen liegt zum einen in der Wiederverwendbarkeit.
    Es erhöht die Lesbarkeit, in dem es Dein Vokabular vergrößert.
    Die deutsche Sprache besteht aus mehreren hunderttausend Vokabeln. C aus 32.
    Wenn Du also nicht immer nur Romane schreiben möchtest, die aus der Kombination von 32 Worten etwas erklären, dann beschreibst Du neue Vokabeln, wie "Datei öffnen" usw. Du schreibst Funktionen.

    Schau Dir den Thread mal an: Dort findest Du einen Hinweis, wie Du Dein goto-Zeugs angehen könntest in meinem Programmvorschlag. Allerdings ist der eben nicht mehr ganz unterstes Anfängerlevel: http://www.iphpbb.com/board/ftopic-53411326nx34195-415-0-asc-0.html

    Xin hat folgendes geschrieben: The Dust hat folgendes geschrieben: Mein erstes größeres C++ Programm
    Eine Funktion?

    Naja, ich finde das es nicht viel bringt ein ganzes Tutorial/Buch durchzulesen und zwischendrinn mal ein paar Zeilen Code zu schreiben, um zu sehen ob das Ganze auch funtkioniert. Versuche mir immer "große Projekte" auszudenken, in dehnen ich das gerade gelernte (im obigen Programm warens halt If und Schleifen)mehrfach anwende.[/quote]
    Erstens: Wirf alle Tutorials weg, die ein Goto enthalten. Bis Du soweit bist, Gotos zu verwenden, brauchst du schon lange keine Tutorials mehr.

    Solange Du if und Schleifen machst, probiere if und Schleifen in den kleinsten Dir möglichen Einheiten aus. Lern C. Verstehe C und damit wie Computer denken.
    Es hat keinen Sinn, wenn Du Dir "große Projekte" ausdenkst basierend auf Vermutungen, wie das ganze Funktionieren kann. Beweise erstmal, dass Deine Vermutungen stimmen und zwar so klein und verständlich wie möglich.




    Dirty Oerty hat folgendes geschrieben:
    4. Funktionen dienen zum einen dazu, das dein Programm schneller wird. Du hast z.b. den Codeblock X, der 20 mal in deinem Programmcode vorkommt. Wenn du an jeder Stelle den kompletten Codeblock hinschreibst, heißt das viel Programmcode, schlechte Übersicht, mehr Speicher notwendig für dein Programm, folglich längere Ladezeit. Packst du Codeblock X in eine Funktion, so sind die Anweisungen in Codeblock X nur ein einziges mal in deinem Programm gespeichert. Das heißt es muss nicht so viel in den Speicher geladen werden, wenn dein Programm gestartet wird.
    Früher, auf meinem 7 MHz Amiga habe ich Programme gepackt, weil das Laden von Diskette länger dauerte als das Entpacken im Arbeitsspeicher - und da das ganze Betriebsystem + Programme auf 880KB Diskettenspeicher passen musste, sparte es da natürlich auch Platz.
    Eine moderne Festplatte schaufelt etwa 30 MB/s - pro Stück. RAID Systeme kommen ja langsam in Mode...
    Das Laden von 15 Byte mehr Code dauert in der Regel nicht bermerkbar länger.
    C++ kennt das Attribut inline, was den Compiler dazu anregt, die beschriebene Funktion nicht zu rufen sondern die komplette Funktion "in die Line" zu packen, wo der Funktionsaufruf hätte sein sollen. Die Funktion taucht dann also an jeder Stelle komplett auf, wo sie eigentlich nur gerufen werden sollen. Es spart den Funktionsruf - das beschleunigt das Programm in der Ausführung.

    Funktionsaufrufe sind nämlich sogar sehr teuer, was die Rechenzeit angeht, wohingegen ein Goto fast kostenlos ist. Hätte "The Dust" das als Vorteil für Gotos angebracht, hätte ich das gelten lassen müssen, aber nicht für sein Programm.
    Man kann darüber überlegen, statt Funktionsaufrufe Gotos zu benutzen, wenn das Programm mehrere Sekunden/Minuten/Stunden/Tage den Computer zu 100% in Beschlag nimmt und man das Problem mit Goto deutlich beschleunigen kann. Überlegen - das heißt nicht unbedingt auch wirklich gotos zu benutzen. Zumal ein Goto etwas anderes ist, als ein Funktionsaufruf und ein Funktionsaufruf nicht zwangsläufig mit einem Goto ersetzt werden kann.
    "The Dusts" Programm benötigt Rechenzeit im Bereich von Nanosekunden, 99,99999% wartet es darauf, dass der User mal eine Taste drückt, hier kommt goto für eine Beschleunigung des Programms überhaupt nicht in Frage.



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 24.12.2007, 12:20


    Eine Funktion als Inline zu definieren ist aber bei größeren Funktionen gerade unnütze, oder etwa nicht?
    Angenommen wir haben eine Funktion, die 300 mal in unserem Code vorkommt. Angenommen, diese Funktion braucht für sich selber nochmal 3 Funktionen. Werden die alle als Inlinefunktionen geschrieben, dann wird sich das wohl schon auf die Größe und Leistung das Programms auswirken. Das Funktionsaufrüfe "teuer" sind ist schon klar, und kleine Funktionen sollten wohl auch Inline sein. Aber größere eher meiner Ansicht nach eher nicht.


    Nachtrag zu Funktionen:
    (Weiß nicht ob das iwo schon so steht)
    Vorteil: Du kannst deinen Programmcode einfacher verbessern. Angenommen du hast einen Algorithmus, der dir Zeichen auf den Bildschirm bringt. Zeichen auf den Bildschirm bringen musst du 20 mal in deinem Programm machen. Nun stell dir vor, was passiert, wenn du eines Tages feststellst, dass dir ein besserer Algorithmus eingefallen ist. Was nun? Jetzt den Programmcode an 20 Stellen umschreiben?!? Einfach geht das wenn dieser Algorithmus in einer Funktion liegt. Dann musst du nur einmal eine Änderung vornehmen, und merkst es überall im Programm.

    Weiterer Vorteil:
    Iwann arbeitest du vllcht nicht mehr alleine an einem Programm. Wenn mehrere an einem Programm arbeiten lässt sich mit Hilfe von Funktionen die Arbeitsteilung einfach regeln.

    MfG
    Daniel



    Re: PROGRAMMSAMMLUNG

    The Dust - 24.12.2007, 14:46


    Ok, ok, goto ist böse :wink:. Dann liegt es also hauptsächlich an der Größe des Programms ob goto katastrophal oder nur eine schlechte Alternative darstellt. Und deßhalb ist es für mich noch schwierig zu erkennen wieso goto nicht ratsam ist, da ich ja noch kein großes Programm geschrieben habe.
    Xin hat folgendes geschrieben:
    In Deinem Programm ist goto fehleranfällig, sehr weit entfernt, von dem was ich als übersichtlich bezeichne und ein Anfänger-Programm, lässt sich i.d.R. um 50% kürzen. Da Du goto in dieser Form anwendest musst Du zwangsläufig Anfänger ohne brauchbaren Lehrer sein, denn entweder wäre Dein Lehrer Amok gelaufen oder Du hast noch kein nennenswertes Programm mit Gotos aufgebaut.

    Also das mit den 50% kürzen will ich sehen :D. Würde mich sehr interessieren, da ich noch eher dazu tendiere lieber mehrere simple Sachen zu schreiben als weniger Code der dafür komplexer ist. Habe keinen Lehrer, alles ein Hobby ohne (Schul)Zwang. Allerdings könnte ich nächstes Jahr in einen Informatikzug gehen, da ich aber in Mathe nicht so eine Leuchte bin, wird das eine haarige Geschichte...

    Danke für eure Erklärung der Funktionen :). So wie ich das verstanden habe sind Funtkionen so nützlich, dass man sie am besten bei jedem Programm benutzen sollte oder ?
    @Moritz
    Gut erkannt, werde diese Schönheitsoperation demnächst durchführen.

    Achja, fröhliche Weihnachten :wink:



    Re: PROGRAMMSAMMLUNG

    Xin - 24.12.2007, 15:27


    The Dust hat folgendes geschrieben: Xin hat folgendes geschrieben:
    In Deinem Programm ist goto fehleranfällig, sehr weit entfernt, von dem was ich als übersichtlich bezeichne und ein Anfänger-Programm, lässt sich i.d.R. um 50% kürzen. Da Du goto in dieser Form anwendest musst Du zwangsläufig Anfänger ohne brauchbaren Lehrer sein, denn entweder wäre Dein Lehrer Amok gelaufen oder Du hast noch kein nennenswertes Programm mit Gotos aufgebaut.

    Also das mit den 50% kürzen will ich sehen :D.

    Okay... Du hast 134 Zeilen, das heißt, ich darf auf weniger als 68 Zeilen kommen.
    Dein Programm wäre verständlicher, wenn Du geschickt Leerzeilen einfügen würdest.

    Ich kann das Programm nicht kompilieren, ich habe keine conio.h, also werde ich mal so ändern ohne zu garantieren, adss es danach noch läuft.

    Schritt 1: Lesbarer machen:
    Code:
    #include <conio.h>
    #include <iostream>

    using namespace std;

    int main()
    {
      int schleife,operation;
      float a,b,c;

      cout << "Matheprogramm\n";
      cout << "\n\n\n[Enter druecken um fortzufahren]";

      schleife=1;
      while (schleife==1)
      {
        if (_kbhit())
        {
          char zeichen =_getch();
          if (zeichen ==    0x0D )
          {
     marke_haupt:
            system("cls");
            cout<<"Waehlen Sie eine Operation:";   
            cout<<"\n\n(1) Addition";
            cout<<"\n(2) Subtraktion";
            cout<<"\n(3) Multiplikation";
            cout<<"\n(4) Division";
            cout<<"\n(5) Potenz\n";
            cout<<"\n\n\n[Waehlen durch Druecken der Zahl in Klammern]";
            schleife=2;
          }
        }
      }

      while (schleife==2)
      {
        if (_kbhit())
        {
          char zeichen =_getch();

          if (zeichen == '1')
          {
     marke1:
            system("cls");
            cout<<"Die zwei zu addierenden Zahlen eingeben\n\n\n";
            cout<<"1. Zahl: ",cin>>a;
            cout<<"2. Zahl: ",cin>>b;
            c = a + b;
            cout<<"\n"<<a<<" + "<<b<<" = "<<c;
            cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
            schleife = 3;
            operation = 1;
          }

          if (zeichen == '2')
          {
    marke2:
            system("cls");
            cout<<"Die zwei zu subtrahierenden Zahlen eingeben\n\n\n";
            cout<<"1. Zahl: ",cin>>a;
            cout<<"2. Zahl: ",cin>>b;
            c = a - b;
            cout<<"\n"<<a<<" - "<<b<<" = "<<c;
            cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
            schleife = 3;
            operation = 2;
          }


          if (zeichen == '3')
          {
    marke3:
            system("cls");
            cout<<"Die zwei zu multiplizierenden Zahlen eingeben\n\n\n";
            cout<<"1. Zahl: ",cin>>a;
            cout<<"2. Zahl: ",cin>>b;
            c = a * b;
            cout<<"\n"<<a<<" x "<<b<<" = "<<c;
            cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
            schleife = 3;
            operation = 3;
          }

          if (zeichen == '4')
          {
    marke4:
            system("cls");
            cout<<"Die zwei zu dividierenden Zahlen eingeben\n\n\n";
            cout<<"1. Zahl: ",cin>>a;
            cout<<"2. Zahl: ",cin>>b;
            c = a / b;
            cout<<"\n"<<a<<" : "<<b<<" = "<<c;
            cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
            schleife = 3;
            operation = 4;
          }

          if (zeichen == '5')
          {
    marke5:
            system("cls");
            cout<<"Die zwei zu potenzierenden Zahlen eingeben\n\n\n";
            cout<<"Basis:    ",cin>>a;
            cout<<"Exponent: ",cin>>b;
            int i=0;
            c=1;
            while(i<b)
            {
              i=i+1;
              c =c*a;
            }
            cout<<"\n"<<a<<" hoch "<<b<<" = "<<c;
            cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
            schleife = 3;
            operation = 5;
          }
        }
      }

      while (schleife==3)
      {
        if (_kbhit())
        {
          char zeichen =_getch();
          if(zeichen == 0x1B)
              goto marke_haupt;
          if((operation==1)&&(zeichen == 0x0D))
              goto marke1;
          if((operation==2)&&(zeichen == 0x0D))
             goto marke2;
          if((operation==3)&&(zeichen == 0x0D))
             goto marke3;
          if((operation==4)&&(zeichen == 0x0D))
             goto marke4;
          if((operation==5)&&(zeichen == 0x0D))
             goto marke5;
        }
      }
    cin.clear();
    cin.ignore(cin.rdbuf()->in_avail()); cin.get();
    }

    (142 Zeilen)

    Schritt 2: Redundanzen ausfiltern:
    Code:
    #include <conio.h>
    #include <iostream>

    using namespace std;

    float add( float a, float b ) { return a + b; }
    float sub( float a, float b ) { return a - b; }
    float mul( float a, float b ) { return a * b; }
    float div( float a, float b ) { return a / b; }
    float pot( float a, float b )
    {
      int i=0;
      float result =1;

      while( i++ < b )
        result *= a;

      return result;
    }

    void calc( char const * headline, char const * first, char const * second, char operation, (float) calc( float, float ) )
    {
      system("cls");

      cout << headline << "\n\n\n";
      cout << first; cin>>a;
      cout << second; cin>>b;
      c = calc( a, b );
      cout<<"\n"<<a<<" + "<<b<<" = "<<c;
      cout<<"\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
    }

    struct

    int main()
    {
      int schleife,operation;
      float a,b,c;

      cout << "Matheprogramm\n";
      cout << "\n\n\n[Enter druecken um fortzufahren]";

      /* Menü anzeigen:

      schleife=1;
      while (schleife==1)
      {
        if (_kbhit())
        {
          char zeichen =_getch();
          if (zeichen ==    0x0D )
          {
     marke_haupt:
            system("cls");
            cout<<"Waehlen Sie eine Operation:";   
            cout<<"\n\n(1) Addition";
            cout<<"\n(2) Subtraktion";
            cout<<"\n(3) Multiplikation";
            cout<<"\n(4) Division";
            cout<<"\n(5) Potenz\n";
            cout<<"\n\n\n[Waehlen durch Druecken der Zahl in Klammern]";
            schleife=2;
          }
        }
      }

      while (schleife==2)
      {
        if (_kbhit())
        {
          char zeichen =_getch();

          if (zeichen == '1') calc( "Die zwei zu addierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '+', add );
          if (zeichen == '2') calc( "Die zwei zu subtrahierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '-', sub );
          if (zeichen == '3') calc( "Die zwei zu multiplizierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '*', mul );
          if (zeichen == '4') calc( "Die zwei zu dividierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '//', div );
          if (zeichen == '5') calc( "Die zwei zu potenzierenden Zahlen eingeben", "Basis:    ", "Exponent: ", "^", pot );
        }
      }

      while (schleife==3)
      {
        if (_kbhit())
        {
          char zeichen =_getch();
          if(zeichen == 0x1B) goto marke_haupt;
          if((operation==1)&&(zeichen == 0x0D)) calc( "Die zwei zu addierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '+', add );
          if((operation==2)&&(zeichen == 0x0D)) calc( "Die zwei zu subtrahierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '-', sub );
          if((operation==3)&&(zeichen == 0x0D)) calc( "Die zwei zu multiplizierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '*', mul );
          if((operation==4)&&(zeichen == 0x0D)) calc( "Die zwei zu dividierenden Zahlen eingeben", "1. Zahl", 2. Zahl", '//', div );
          if((operation==5)&&(zeichen == 0x0D)) calc( "Die zwei zu potenzierenden Zahlen eingeben", "Basis:    ", "Exponent: ", "^", pot );
        }
      }

      cin.clear();
      cin.ignore(cin.rdbuf()->in_avail()); cin.get();
    }

    (98 Zeilen)

    Schritt drei: Aufbau verbessern & neue Redundanz rausnehmen:
    Code:
    #include <conio.h>
    #include <iostream>

    using namespace std;

    float add( float a, float b ) { return a + b; }
    float sub( float a, float b ) { return a - b; }
    float mul( float a, float b ) { return a * b; }
    float div( float a, float b ) { return a / b; }
    float pot( float a, float b )
    {
      int i=0;
      float result =1;

      while( i++ < b )
        result *= a;

      return result;
    }

    void calc( char const * headline, char const * first, char const * second, char const * operation, float (*func)( float, float ) )
    {
      float a, b, c;
      system("cls");

      cout << headline << "\n\n\n";
      cout << first;  cin >> a;
      cout << second; cin >> b;
      c = func( a, b );
      cout << "\n" << a << " " << operation << " " << b << " = " << c;
      cout << "\n\n\n[Druecke Enter um eine weitere Rechnung durchzufuehren\nund Esc um zum Menue gelangen]";
    }

    void showMenu()
    {
      system("cls");
      cout<<"Waehlen Sie eine Operation:";   
      cout<<"\n\n(1) Addition";
      cout<<"\n(2) Subtraktion";
      cout<<"\n(3) Multiplikation";
      cout<<"\n(4) Division";
      cout<<"\n(5) Potenz\n";
      cout<<"\n\n\n[Waehlen durch Druecken der Zahl in Klammern]";
    }

    int main()
    {
      cout << "Matheprogramm\n";
      cout << "\n\n\n[Enter druecken um fortzufahren]";

      if( _kbhit() )
      {
        char zeichen = _getc();
        int operation;
        if (zeichen == 0x0D)
        {
          showMenu();

          while ( true )
          {
            if (_kbhit())
            {
              zeichen = _getc();

              if( zeichen == 0x1B )
              {
                showMenu();
                continue;
              }

              if( zeichen != 0x0D )
                operation = zeichen - '0';

              switch( operation )
              {
                case 1: calc( "Die zwei zu addierenden Zahlen eingeben",       "1. Zahl",    "2. Zahl",    "+", add ); break;
                case 2: calc( "Die zwei zu subtrahierenden Zahlen eingeben",   "1. Zahl",    "2. Zahl",    "-", sub ); break;
                case 3: calc( "Die zwei zu multiplizierenden Zahlen eingeben", "1. Zahl",    "2. Zahl",    "*", mul ); break;
                case 4: calc( "Die zwei zu dividierenden Zahlen eingeben",     "1. Zahl",    "2. Zahl",    "/", div ); break;
                case 5: calc( "Die zwei zu potenzierenden Zahlen eingeben",    "Basis:    ", "Exponent: ", "^", pot ); break;
              }
            }
          }
        }
      }

      cin.clear();
      cin.ignore(cin.rdbuf()"Die zwei zu addierenden Zahlen eingeben", "1. Zahl", "2. Zahl", "+", add->in_avail()); cin.get();
    }

    (90 Zeilen)

    Ich weiß nicht, ob's funktioniert, die Mittelversion funktioniert höchstwahrscheinlich nicht.
    Würde ich die Zwischenzeilen jetzt rauswerfen, wären wir bei etwa 80 Zeilen. Das Auflösen der wiederholten calc aufrufe könnte noch was bringen, aber vorrangig dann, wenn weitere Operationen unterstützt würden, kamen wir an die 50% wohl gut ran.

    Das Programm ist auch noch was arg kurz, es muss ja auch was drinstehen, damit ich kürzen kann, das Programm besteht ja fast nur aus Ausgaben, die natürlich weiterhin getätigt werden müssen.

    Zitat: Achja, fröhliche Weihnachten :wink:
    Ebenso.



    Re: PROGRAMMSAMMLUNG

    The Dust - 25.12.2007, 22:36


    Oh mann, danke Xin :D. Werde Zeile für Zeile durchstudieren und versuchen alles zu verstehen :wink:. Schön das ich jetzt eine von einem Profi verbesserte Version meines Codes habe.



    Re: PROGRAMMSAMMLUNG

    Xin - 25.12.2007, 23:33


    The Dust hat folgendes geschrieben: Oh mann, danke Xin :D. Werde Zeile für Zeile durchstudieren und versuchen alles zu verstehen :wink:. Schön das ich jetzt eine von einem Profi verbesserte Version meines Codes habe.

    Bei main hatte ich etwas Probleme Deinen Code nachzuvollziehen und da Du unbedingt ein 'Enter' vor der Ausführung Deines Programms haben wolltest, ist der Code länger. Nimmt man das Enter raus, könnte man main() vermutlich auch halbieren.

    Ich hoffe, es läßt sich überhaupt kompilieren und läuft, sonst hilft "Profi" nicht wirklich ;-)

    Mangels conio.h habe ich weder die Funktion _kbhit() noch _getc() unter Linux, also kann ich es nicht so einfach komplilieren und testen. Und umschreiben ging an hl. Abend auch nicht mehr, ich war dank des Programms grade eben noch auf die Minute pünktlich. ;-)

    Wenn was nicht stimmt, mach 'nen anderen Thread auf und mich ggfs. drauf aufmerksam.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 05.01.2008, 20:43

    opstreader
    So, nach allzulanger Zeit kann ich endlich mein erstes ungefähr "fertiges" Projekt vorstellen:

    Die optsreader Bibliothek
    Konfigurationsdateien Lesen und auswerten

    Das Problem:
    Größere Programme bedürfen Einstellungen, noch größere bedürfen so viele, dass es nicht bequem wäre diese auf der Kommandozeile anzugeben. Das einzige was man tun kann ist, dass man Einstellungen aus einer Konfigurationsdatei ausliest. Dies ist allerdings mit großem Aufwand verbunden.

    Die Lösung:
    Mithilfe von modernen C++ features wie z.B. Streams, Templates und Exceptions habe ich eine recht einfach zu benutzende Bibliothek geschaffen, die es erlaubt eine Datei einzulesen und daraus die nötigen Werte zu extrahieren.


    Verwendung:
    Am besten erstmal die Readme- Datei lesen...
    Die kurzform:

    Alle dateien zum Projekt hinzufügen, die beiden .cpp's müssen kompiliert werden. optsreader.hpp muss inkludiert werden, und los gehts.
    Ein beispiel:

    Ihr wollt ne konfigurationsdatei auslesen die so aussieht:

    config.txt hat folgendes geschrieben:
    #das hier ist der Wert
    max_clients 7


    Das hier ist der Code dazu:
    Code:
    ...
    #include "optsreader.hpp"
    ...

    // Hier kommt die variable rein
    int max_clients;

    // Das hier ist das objekt, das das ganze macht
    optsreader::COpts_Plain optsfile;

    // Datei laden
    optsfile.load("config.txt");

    // Wert auslesen
    max_clients = optsfile.get_value<int>("max_clients");


    Und schon fertig. Die Fehlerabfrage habe ich hier ausgelassen.


    Falls jemand diese Bibliothek verwendet, ich habe sie auch (einigermaßen) gut dokumentiert, sowohl im Quelltext als auch als eigene Dateien.
    Es gibt ein kleines Tutorial in der Readme datei und eine Referenz- Datei.
    Bis jetzt ist die doku noch in einfachen Textdateien, bei entsprechendem Zeit- Lust verhältnis werde ich das ganze in eine HTML Datei umschreiben.

    Diese Dateien sind enthalten:

    Quelltext:
    - optsreader_base.h
    - optsreader_base.cpp
    - optsreader.hpp
    - optsreader.cpp

    Dokumentation:
    - LICENSE.txt: Die Lizenz
    - README.txt: Ein readme das die wichtigsten Punkte enthält
    - reference.txt: Eine referenz über alle Klassen und Funktionen
    - syntax.txt: Die Syntax- Regeln, wie Dateien aufgebaut sein dürfen.

    Hier sind die Links:

    Windows:
    http://fat-lobyte9.pytalhost.com/downloads/optsreader.zip

    Unix:
    http://fat-lobyte9.pytalhost.com/downloads/optsreader.tar.gz

    Die beiden Archive sind identisch, der Unterschied besteht nur im Archivformat und in den Line- Endings.

    Tja, das ding steht sogar unter einer Lizenz, aber keine Sorge.
    Sie heißt "Modified BSD License" und verspricht nur Freiheiten.
    Sie besgagt, dass man diese Datei weitergeben und Verändern kann wie man will, allerdings wird unter keinen Umständen Haftung für evtl. schäden übernommen.

    So, ich hoffe das sieht sich wenigstens mal wer an...

    mfg, DrPhil_Guth



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 06.01.2008, 23:16


    Gut gemacht!

    Hört sich spitze an, was du da programmiert hast.

    :D

    MfG
    Daniel



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 07.01.2008, 18:42


    Danke :)
    Hast dus denn schon mal ausprobiert?



    Re: PROGRAMMSAMMLUNG

    Dirty Oerty - 07.01.2008, 18:58


    Noch nicht, aber ich kann mir sehr gut vorstellen, das bei meinem nächsten Programm zu verwenden.

    Nur kann dran zur Zeit leider nicht arbeiten...die Schule ruft :(



    Re: PROGRAMMSAMMLUNG

    Xin - 08.01.2008, 00:00

    Re: opstreader
    DrPhil_Guth hat folgendes geschrieben: So, nach allzulanger Zeit kann ich endlich mein erstes ungefähr "fertiges" Projekt vorstellen:
    Deinen Code anzusehen ist merkwürdig.
    Templates, Namespaces, volles Programm. Das ist nichts, was man als "erstes" schreibt.

    Was mich - der Tatsache zum Trotz, dass Du quasi das C++-Reportoire reichhaltig nutzt - wundert ist, dass Du dennoch so nachlässig bist, was Codeformatierung angeht.
    Die Verwendung von Leerzeilen geschieht nach dem Zufallsprinzip, ich kann an Ihnen keine Strukturierung des Codes erkennen.
    Schade, denn Code, der mit Namespaces hantiert, ist schon schwer genug zu lesen.
    Ein using namespace std; in den CPP-Dateien würde vielleicht schon etwas vereinfachen.

    Oder die einen Header .hpp nennst und den anderen .h.

    Die Verwendung von Tabs ist eigentlich inzwischen ziemlich aus der Mode gekommen, aber das ist eine Geschmacksfrage.

    DrPhil_Guth hat folgendes geschrieben: Die optsreader Bibliothek
    Das Problem:
    Die Lösung:
    Verwendung:
    Das hier ist der Code dazu:
    ...
    Und schon fertig. Die Fehlerabfrage habe ich hier ausgelassen.
    Und genau das ist das Problem von Exceptions. Nicht nur Du lässt sie weg. Eigentlich lässt sie jeder weg. Java zwingt Dich, dann steht da catch( Exception e ) {} und fertig.
    Wenn sie Dir - wo Du die Lib in und auswendig kennst - schon für ein kleines Beispiel zu aufwendig ist, wie soll das laufen, wenn irgendwer sich da erst noch einlesen muss?

    DrPhil_Guth hat folgendes geschrieben: Falls jemand diese Bibliothek verwendet, ich habe sie auch (einigermaßen) gut dokumentiert, sowohl im Quelltext als auch als eigene Dateien.
    Ziemlich viel dokumentiert sogar. *thumbs up*
    Schau Dir mal Doxygen an. Wenn Du Deine Kommentare etwas veränderst, generiert Dir Doxygen gleich HTML oder PDF oder was auch immer Du haben willst.
    Ich dokumentiere auch damit, ein Beispiel findest Du u.a. in der gtk-API-Dokumentation.

    DrPhil_Guth hat folgendes geschrieben: So, ich hoffe das sieht sich wenigstens mal wer an...
    Ich hoffe, Du verzeihst, dass ich mir keine Programme damit schreibe, obwohl ich sogar Interesse dran habe, es zu verwenden.
    Hättest Du ein Beispielprogramm und ein Makefile dazugelegt, hätte ich mehr damit gespielt und mich vielleicht sogar überzeugen lassen. (Du kannst den Satz auch so lesen, dass die Bereitschaft steigt, sich das ganze anzugucken, wenn man erstmal nur "make" tippen muss und sieht schon was).

    Was für mich vorrangig von der Verwendung abhält ist die Tatsache, dass Dein Codestil doch etwas von meinem abweicht. Das wäre für mich der Hauptgrund es nicht zu verwenden.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 09.01.2008, 20:08

    Re: opstreader
    Xin hat folgendes geschrieben: DrPhil_Guth hat folgendes geschrieben: So, nach allzulanger Zeit kann ich endlich mein erstes ungefähr "fertiges" Projekt vorstellen:
    Deinen Code anzusehen ist merkwürdig.
    Templates, Namespaces, volles Programm. Das ist nichts, was man als "erstes" schreibt.


    Mit erstes meinte ich eigentlich nicht "erstes" sondern "erstes fertiges", "erstes einigermaßen releasefähiges".
    Für das ganze andere Zeug hab ich mich gechämt, weil das nicht nur unvollkommen, sondern schlicht und einfach unfertig ist. Keine doku, keine Lizenz, kein gar nichts.


    Xin hat folgendes geschrieben: Was mich - der Tatsache zum Trotz, dass Du quasi das C++-Reportoire reichhaltig nutzt - wundert ist, dass Du dennoch so nachlässig bist, was Codeformatierung angeht.
    Die Verwendung von Leerzeilen geschieht nach dem Zufallsprinzip, ich kann an Ihnen keine Strukturierung des Codes erkennen.
    Das ist mir bewusst. Das liegt ganz einfach daran dass das Projekt extrem (furchtbar furchtbar furchtbar) lange gedauert hat. Während dieser Zeit hat es viele Stile miterlebt, ich hab viel verschieden Formatierten Code gelesen, also meinen auch so geschrieben.
    Ich bin mir bewusst dass das ein Missstand ist, und es wird im nächsten Projekt eine einheitliche Formatierungsrichtlinie geben. In diesem Projekt nicht mehr: Die Formatierung ist gut genug, dass es einigermaßen lesbar ist. Deswegen werde ich mich nicht vor den editor setzen und Tabulatoren suchen gehen.

    Xin hat folgendes geschrieben: Oder die einen Header .hpp nennst und den anderen .h.
    Das war beabsichtigt. Es sollte daran erinnern dass die .h Datei nur Deklarationen enthält, die .hpp allerdings Deklarationen UND Implementierungen enthält. Ist vielleicht ein wenig ungeschickt, aber hier gilt das gleiche wie für die Formatierung.

    Xin hat folgendes geschrieben: Und genau das ist das Problem von Exceptions. Nicht nur Du lässt sie weg. Eigentlich lässt sie jeder weg. Java zwingt Dich, dann steht da catch( Exception e ) {} und fertig.
    Wenn sie Dir - wo Du die Lib in und auswendig kennst - schon für ein kleines Beispiel zu aufwendig ist, wie soll das laufen, wenn irgendwer sich da erst noch einlesen muss?
    Eigentlich lässt sie jeder weg? Ich habe sie hier weggelassen, weil das eben ein kleines Beispiel sein sollte, das nicht gleich den vollen umfang der Fehlerbehandlung inkludiert. Hier die unveränderte version:
    Code:    
    if ( optsfile.load("config.txt") == 0 )
    {
        std::cout<<"The file could not be loaded.\n";
    }

    try
    {
        max_clients = optsfile.get_value<int>(keyword);
    }
    catch(optsreader::opts_exc err)
    {
           std::cout<<"Could not read value: "<<err.what()<<std::endl;
          
            if (err.value() == COPTS_PLAIN_KW_NOTFOUND)
            {
                  // Do whatever is appropriate in this situation
            }   
          
    }

    Xin hat folgendes geschrieben: DrPhil_Guth hat folgendes geschrieben: So, ich hoffe das sieht sich wenigstens mal wer an...
    Ich hoffe, Du verzeihst, dass ich mir keine Programme damit schreibe, obwohl ich sogar Interesse dran habe, es zu verwenden.
    Hättest Du ein Beispielprogramm und ein Makefile dazugelegt, hätte ich mehr damit gespielt und mich vielleicht sogar überzeugen lassen. (Du kannst den Satz auch so lesen, dass die Bereitschaft steigt, sich das ganze anzugucken, wenn man erstmal nur "make" tippen muss und sieht schon was).
    Hehe, hab sogar sowas. Ich hab mir sogar überlegt es zum tarball hinzuzufügen, hab mich aber dagegen entschieden. Wie auch immer, hier was zum testen:

    http://fat-lobyte9.pytalhost.com/downloads/optsreader_test.tar.gz

    Xin hat folgendes geschrieben: Was für mich vorrangig von der Verwendung abhält ist die Tatsache, dass Dein Codestil doch etwas von meinem abweicht. Das wäre für mich der Hauptgrund es nicht zu verwenden.
    Tut mir echt leid, aber wenn dich das davon abhält Bibliotheken zu benutzen, dann weiß ich echt nicht wie du mit Programmieren Geld verdienst. Es ist nun mal so, dass C++ extrem verbreitet ist, und da gibt es nun mal sehr viele verschiedene Stile. Wenn ich ein Programm schreibe das Boost mit dem ANSI
    Stil (bool some_func(struct foobar f) verwendet, und gleichzeitig DirectX mit dem furchtbaren Microsoft Stil, (BOOL someFunc(struct FOOBAR f) dann musst du dich darauf einstellen. Wichtig ist nur dass die Bibliothek selbst einen einheitlichen Stil aufweist, was meine zugegebenermaßen nicht erfüllt.



    Re: PROGRAMMSAMMLUNG

    Xin - 09.01.2008, 21:24

    Re: opstreader
    DrPhil_Guth hat folgendes geschrieben: Für das ganze andere Zeug hab ich mich gechämt, weil das nicht nur unvollkommen, sondern schlicht und einfach unfertig ist. Keine doku, keine Lizenz, kein gar nichts.
    Das ist kein Grund sich zu schämen, wenn man etwas kompilieren kann, was brauchbar ist und funktioniert.
    Die wenigsten interessieren sich für die Sourcecodes.

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Was mich - der Tatsache zum Trotz, dass Du quasi das C++-Reportoire reichhaltig nutzt - wundert ist, dass Du dennoch so nachlässig bist, was Codeformatierung angeht.
    Die Verwendung von Leerzeilen geschieht nach dem Zufallsprinzip, ich kann an Ihnen keine Strukturierung des Codes erkennen.
    Das ist mir bewusst. Das liegt ganz einfach daran dass das Projekt extrem (furchtbar furchtbar furchtbar) lange gedauert hat. Während dieser Zeit hat es viele Stile miterlebt, ich hab viel verschieden Formatierten Code gelesen, also meinen auch so geschrieben.
    Ich bin mir bewusst dass das ein Missstand ist, und es wird im nächsten Projekt eine einheitliche Formatierungsrichtlinie geben.
    Wie kommst Du auf die Idee, dass dieses Projekt fertig ist?

    DrPhil_Guth hat folgendes geschrieben: In diesem Projekt nicht mehr: Die Formatierung ist gut genug, dass es einigermaßen lesbar ist. Deswegen werde ich mich nicht vor den editor setzen und Tabulatoren suchen gehen.
    Dein Editor baut die Tabs ein. Schalt es doch einfach ab. ^^

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Oder die einen Header .hpp nennst und den anderen .h.
    Das war beabsichtigt. Es sollte daran erinnern dass die .h Datei nur Deklarationen enthält, die .hpp allerdings Deklarationen UND Implementierungen enthält. Ist vielleicht ein wenig ungeschickt, aber hier gilt das gleiche wie für die Formatierung.
    Nein, klingt im ersten Moment sogar sinnvoll.
    Allerdings wird's schwierig, wenn ein Header Implementierung hinzugewinnt oder vollständig verliert. Dann musst Du entweder viel ändern oder die Namensgebung ist einfach nur inkonsistent.
    Weiterhin interessiert mich beim Einbinden gar nicht, ob da irgendwo eine Funktion inline implementiert ist oder nicht... oder wie siehst Du das?

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Und genau das ist das Problem von Exceptions. Nicht nur Du lässt sie weg. Eigentlich lässt sie jeder weg. Java zwingt Dich, dann steht da catch( Exception e ) {} und fertig.
    Wenn sie Dir - wo Du die Lib in und auswendig kennst - schon für ein kleines Beispiel zu aufwendig ist, wie soll das laufen, wenn irgendwer sich da erst noch einlesen muss?
    Eigentlich lässt sie jeder weg? Ich habe sie hier weggelassen, weil das eben ein kleines Beispiel sein sollte, das nicht gleich den vollen umfang der Fehlerbehandlung inkludiert. Hier die unveränderte version:
    Code:    
    if ( optsfile.load("config.txt") == 0 )
    {
        std::cout<<"The file could not be loaded.\n";
    }

    try
    {
        max_clients = optsfile.get_value<int>(keyword);
    }
    catch(optsreader::opts_exc err)
    {
           std::cout<<"Could not read value: "<<err.what()<<std::endl;
          
            if (err.value() == COPTS_PLAIN_KW_NOTFOUND)
            {
                  // Do whatever is appropriate in this situation
            }   
          
    }

    Okay... zurück zu Realität. Welche Value Du nicht lesen konntst, steht in Keyword ^^
    Warum Du es nicht lesen konntest - ob's nicht da war, oder falsch geschrieben, interessiert mich doch gar nicht. Wen sollte es interessieren?
    Mich interessiert nur, ob ich einen Wert habe, mit dem ich was anfangen kann.

    Code:
        if( !optsfile.get_value<int>(keyword, max_clients ) )
           max_clients = max_clients_default_value;

    oder für mich noch besser:
    Code:
        config_ok &= optsfile.get_value<int>(keyword, max_clients, max_clients_default_value);


    Dafür will ich mir doch nicht 'nen Wolf schreiben.

    DrPhil_Guth hat folgendes geschrieben: Hehe, hab sogar sowas. Ich hab mir sogar überlegt es zum tarball hinzuzufügen, hab mich aber dagegen entschieden. Wie auch immer, hier was zum testen:
    Ich gucke es mir die Tage mal an, könnte aber was dauern und mit etwas Glück verplane ich es zum WE nicht.

    DrPhil_Guth hat folgendes geschrieben: Tut mir echt leid, aber wenn dich das davon abhält Bibliotheken zu benutzen, dann weiß ich echt nicht wie du mit Programmieren Geld verdienst. Es ist nun mal so, dass C++ extrem verbreitet ist, und da gibt es nun mal sehr viele verschiedene Stile. Wenn ich ein Programm schreibe das Boost mit dem ANSI
    Stil (bool some_func(struct foobar f) verwendet, und gleichzeitig DirectX mit dem furchtbaren Microsoft Stil, (BOOL someFunc(struct FOOBAR f) dann musst du dich darauf einstellen. Wichtig ist nur dass die Bibliothek selbst einen einheitlichen Stil aufweist, was meine zugegebenermaßen nicht erfüllt.

    Natürlich.
    Doch auf eine Lib muss ich mich einlassen, wenn sie ausreichend Vorteile mit sich bringt.
    Wenn ich in GTK programmiere, dann ist das einfacher als die Funktionen unter Windows und Linux neu zu schreiben.
    Das Problem, dass Du gelöst hast, kann ich notfalls selbst lösen.
    Habe es sogar schon gelöst, in dem ich einer Klasse mitteile, wo die interessanten Variablen sind, und welchen Typ sie haben. Das Speichern liest die Variablen automatisch aus und beim Laden werden sie automatisch beschrieben. Halbiert den Aufwand, weil ich die interessanten Variablen nur einmalig bekannt geben muss.
    Der Nachteil an meiner Lösung ist, dass sie XML speichert, was für das zu lösende Problem eigentlich übertrieben ist. Ich müsste meine Lösung also anpassen oder mich in Deine einarbeiten.
    Ansonsten verdiene ich mein Geld derzeit vorrangig mit Java. Nicht freiwillig, aber die Bestechung fällt ausreichend hoch aus. C++ wird in der Firma verwandt, aber in dem Bereich arbeite ich zurzeit nicht.
    Den Unterstrich in Funktionen einzubauen halte ich für ziemlich daneben und vermeide ihn daher. Aber das ist eine Frage des Stils.


    Vielleicht schreibst Du den ganzen Kram einfach mal von Grundauf neu.
    Das ist nicht nötig, es funktioniert ja auch so, aber darum geht es ja nicht.
    Du wirst einiges gelernt haben, vergleiche doch mal, wie lange Du nun dafür brauchst und wie die neue Klasse im Vergleich zur alten aussieht. Das gibt Dir vielleicht eine Richtung für die nächsten Klassen, die Du schreibst.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 10.01.2008, 20:57

    Re: opstreader
    Xin hat folgendes geschrieben:
    Wie kommst Du auf die Idee, dass dieses Projekt fertig ist?

    Sagt ja niemand. Allerdings kann man bei Softwareprojekten generell nie sagen dass sie "fertig" sind. (Außer Natürlich Die Götter aus Redmond und deresgleichen) Aber es ist verwendbar, releasefertig und ich werds wahrscheinlich nicht mehr weiterentwickeln. Im ursprünglichen Sinne des Wortes (nicht in der Softwaresprache) würde ich das als fertig bezeichnen.

    Xin hat folgendes geschrieben: DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Oder die einen Header .hpp nennst und den anderen .h.
    Das war beabsichtigt. Es sollte daran erinnern dass die .h Datei nur Deklarationen enthält, die .hpp allerdings Deklarationen UND Implementierungen enthält. Ist vielleicht ein wenig ungeschickt, aber hier gilt das gleiche wie für die Formatierung.
    Nein, klingt im ersten Moment sogar sinnvoll.
    Allerdings wird's schwierig, wenn ein Header Implementierung hinzugewinnt oder vollständig verliert. Dann musst Du entweder viel ändern oder die Namensgebung ist einfach nur inkonsistent.
    Weiterhin interessiert mich beim Einbinden gar nicht, ob da irgendwo eine Funktion inline implementiert ist oder nicht... oder wie siehst Du das?
    Naja so unglaublich viel Arbeit ist das auch wieder nicht den Dateinamen zu ändern, wenn ein header Implentierungen dazugewinnt und verliert. ( "mv optsreader.hpp optsreader.h" um genau zu sein). Ich denke ich schaffe es, dass ich wenn ich an einer Datei lange Arbeite, dass ich zu irgendeinem Zeitpunkt dran Denke den Namen zu ändern.
    Und es kann sein dass ich den unterschied beim Einbinden nicht brauche. Aber hier eine gegenfrage: wieso gibt es Dateiendungen überhaupt? Für mich ist die Antwort dass ich damit erkenne was für einen "Typ" eine Datei hat. Das ist für die Organisation und fürs Debuggen ziemlich wichtig, dass ich das sofort auf den ersten Blick sehe.

    Xin hat folgendes geschrieben: DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Und genau das ist das Problem von Exceptions. Nicht nur Du lässt sie weg. Eigentlich lässt sie jeder weg. Java zwingt Dich, dann steht da catch( Exception e ) {} und fertig.
    Wenn sie Dir - wo Du die Lib in und auswendig kennst - schon für ein kleines Beispiel zu aufwendig ist, wie soll das laufen, wenn irgendwer sich da erst noch einlesen muss?
    Eigentlich lässt sie jeder weg? Ich habe sie hier weggelassen, weil das eben ein kleines Beispiel sein sollte, das nicht gleich den vollen umfang der Fehlerbehandlung inkludiert. Hier die unveränderte version:
    Code:
    ...

    Warum Du es nicht lesen konntest - ob's nicht da war, oder falsch geschrieben, interessiert mich doch gar nicht. Wen sollte es interessieren?
    Ich denke das würde dich schon interessieren, wenn du dein Programm debuggst und 20 mal deine Konfiguration ändern musst, bis du draufkommst was falsch ist.
    Und überhaupt: dass du die Information bekommen KANNST, bedeutet nicht dass du sie bekommen MUSST. Wenns dich wirklich nicht interessiert, kannst du sie ja abfangen und mit dem gleichen Codeblock wie deine if ( ... == ...) variante bearbeiten. Das einzige was länger wäre ist try {}. Und naja, so böse ist der Wolf auch wieder nicht.
    Außerdem gehts bei den Exceptions auch vor allem um eines: Die funktion gibt nicht irgendeinen dämlichen "Erfolgscode" zurück, oder sie braucht auch keinen zusätzlichen Parameter für einen Zeiger oder Referenz auf den Statuswert. Hier gehts hauptsächlich um einfachheit: gib ihm nen String als Parameter, nen Typ als Templateparameter und bekomme deine Variable zurück.
    Ich finde die Methode Fehler als Rückgabewerte zurückzugeben generell ziemlich unschön.

    Xin hat folgendes geschrieben: Natürlich.
    Doch auf eine Lib muss ich mich einlassen, wenn sie ausreichend Vorteile mit sich bringt.
    Wenn ich in GTK programmiere, dann ist das einfacher als die Funktionen unter Windows und Linux neu zu schreiben.
    Das Problem, dass Du gelöst hast, kann ich notfalls selbst lösen.
    Habe es sogar schon gelöst, in dem ich einer Klasse mitteile, wo die interessanten Variablen sind, und welchen Typ sie haben. Das Speichern liest die Variablen automatisch aus und beim Laden werden sie automatisch beschrieben. Halbiert den Aufwand, weil ich die interessanten Variablen nur einmalig bekannt geben muss.
    Der Nachteil an meiner Lösung ist, dass sie XML speichert, was für das zu lösende Problem eigentlich übertrieben ist. Ich müsste meine Lösung also anpassen oder mich in Deine einarbeiten.
    Hm, ist das nicht immer so bei bibliotheken? :) Kann mir schon denken dass meine "mal-sehen-was-ich-eigentlich-so-draufhab-bibliothek" dich nicht so reizt.

    Xin hat folgendes geschrieben:
    Den Unterstrich in Funktionen einzubauen halte ich für ziemlich daneben und vermeide ihn daher. Aber das ist eine Frage des Stils.
    Genau das ist es. Ich finde umgekehrt diese gemischten gruß- und kleinbuchstaben ziemlich daneben. Und wenn ich mich schon an wem Orientiere, dann wohl an den großen oder?

    Xin hat folgendes geschrieben:
    Vielleicht schreibst Du den ganzen Kram einfach mal von Grundauf neu.
    Das ist nicht nötig, es funktioniert ja auch so, aber darum geht es ja nicht.
    Du wirst einiges gelernt haben, vergleiche doch mal, wie lange Du nun dafür brauchst und wie die neue Klasse im Vergleich zur alten aussieht. Das gibt Dir vielleicht eine Richtung für die nächsten Klassen, die Du schreibst.
    Gute Idee eigentlich, ich denk mal drüber nach. Hab schon sogar ein paar Ideen.



    Re: PROGRAMMSAMMLUNG

    Xin - 11.01.2008, 02:37

    Re: opstreader
    DrPhil_Guth hat folgendes geschrieben: ... es ist verwendbar, releasefertig und ich werds wahrscheinlich nicht mehr weiterentwickeln. Im ursprünglichen Sinne des Wortes (nicht in der Softwaresprache) würde ich das als fertig bezeichnen.
    Wenn Du die Software nicht weiterentwickeln möchtest, dann frage ich mich, warum Du sie geschrieben hast. Anscheinend nicht für etwas, was Du selbst benötigtest - denn sonst wüßtest Du, wie Du diese Klassen erweitern möchtest.

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Allerdings wird's schwierig, wenn ein Header Implementierung hinzugewinnt oder vollständig verliert. Dann musst Du entweder viel ändern oder die Namensgebung ist einfach nur inkonsistent.
    Weiterhin interessiert mich beim Einbinden gar nicht, ob da irgendwo eine Funktion inline implementiert ist oder nicht... oder wie siehst Du das?
    Naja so unglaublich viel Arbeit ist das auch wieder nicht den Dateinamen zu ändern, wenn ein header Implentierungen dazugewinnt und verliert. ( "mv optsreader.hpp optsreader.h" um genau zu sein).
    Die Änderung auf dem Dateisystem ist vernachlässigbar, jedoch wie sieht das in den ganzen Dateien aus, die Deine Dateien einbinden möchten?


    DrPhil_Guth hat folgendes geschrieben: Ich denke ich schaffe es, dass ich wenn ich an einer Datei lange Arbeite, dass ich zu irgendeinem Zeitpunkt dran Denke den Namen zu ändern.
    Ich habe aber keine Lust mehr Arbeit irgendwo reinzustecken, als unbedingt notwendig. Ich arbeite ja schon lange genug mit den Quellcodes, da will ich nicht auch noch auf Kleinigkeien achten müssen.

    DrPhil_Guth hat folgendes geschrieben: Aber hier eine gegenfrage: wieso gibt es Dateiendungen überhaupt? Für mich ist die Antwort dass ich damit erkenne was für einen "Typ" eine Datei hat. Das ist für die Organisation und fürs Debuggen ziemlich wichtig, dass ich das sofort auf den ersten Blick sehe.
    Ob in der Headerdatei Implementierung steckt oder nicht, ist mir beim Debuggen genauso schnuppe, wie bei der Organisation.
    Was interessiert Dich daran?

    DrPhil_Guth hat folgendes geschrieben: Ich denke das würde dich schon interessieren, wenn du dein Programm debuggst und 20 mal deine Konfiguration ändern musst, bis du draufkommst was falsch ist.
    Und überhaupt: dass du die Information bekommen KANNST, bedeutet nicht dass du sie bekommen MUSST.
    Das ist ja grade der Unterschied bei Exceptions, ich kann nicht entscheiden, ob ich die Information haben kann, sondern ich bekomme sie um die Ohren geschlagen.
    Zumal man wirklich fragen muss, ob ein nicht definierter Parameter Regelfall oder Ausnahme (Exception) ist.


    DrPhil_Guth hat folgendes geschrieben: Wenns dich wirklich nicht interessiert, kannst du sie ja abfangen und mit dem gleichen Codeblock wie deine if ( ... == ...) variante bearbeiten. Das einzige was länger wäre ist try {}.
    Ich interessiere mich nicht für das Warum, also gibt es auch kein überflüssige Frage. Es gibt also kein "Dein if".

    DrPhil_Guth hat folgendes geschrieben: Außerdem gehts bei den Exceptions auch vor allem um eines: Die funktion gibt nicht irgendeinen dämlichen "Erfolgscode" zurück, oder sie braucht auch keinen zusätzlichen Parameter für einen Zeiger oder Referenz auf den Statuswert.
    Richtig. Stattdessen verbrät sie Rechenzeit auf Dinge, die niemanden interessieren.
    Das Try kostet bereits. Richtig teuer wird's bei den Catch. Mein If kostet genausoviel, wie die Unterscheidung, ob ich eine Exception werfe oder nicht.
    Und wenn mich der Grund nicht interessiert, warum ein Parameter nicht lesbar ist, dann gibt's bei mir auch kein if mehr.

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben: Ich müsste meine Lösung also anpassen oder mich in Deine einarbeiten.
    Hm, ist das nicht immer so bei bibliotheken? :) Kann mir schon denken dass meine "mal-sehen-was-ich-eigentlich-so-draufhab-bibliothek" dich nicht so reizt.
    Der Funktionsumfang ist zu klein, als dass das Einarbeiten lohnt.

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben:
    Den Unterstrich in Funktionen einzubauen halte ich für ziemlich daneben und vermeide ihn daher. Aber das ist eine Frage des Stils.
    Genau das ist es. Ich finde umgekehrt diese gemischten gruß- und kleinbuchstaben ziemlich daneben. Und wenn ich mich schon an wem Orientiere, dann wohl an den großen oder?
    Und was ist groß?
    Der Stil mit den Unterstrichen erscheint mir vollkommen überholt zu sein.

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben:
    Vielleicht schreibst Du den ganzen Kram einfach mal von Grundauf neu.
    Das ist nicht nötig, es funktioniert ja auch so, aber darum geht es ja nicht.
    Du wirst einiges gelernt haben, vergleiche doch mal, wie lange Du nun dafür brauchst und wie die neue Klasse im Vergleich zur alten aussieht. Das gibt Dir vielleicht eine Richtung für die nächsten Klassen, die Du schreibst.
    Gute Idee eigentlich, ich denk mal drüber nach. Hab schon sogar ein paar Ideen.
    Darum geht's beim Programmieren doch... Ideen auszuprobieren und auszuleben.



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 11.01.2008, 17:58

    Re: opstreader
    Xin hat folgendes geschrieben:
    Wenn Du die Software nicht weiterentwickeln möchtest, dann frage ich mich, warum Du sie geschrieben hast. Anscheinend nicht für etwas, was Du selbst benötigtest - denn sonst wüßtest Du, wie Du diese Klassen erweitern möchtest.
    Natürlich benötige ich es für mich selbst. Und ich weiß genau wie ich es erweitern kann. Glaube es oder nicht, ich hab mir doch ein wenig gedanken darüber gemacht. Bis jetzt reicht für mich der Funktionsumfang allerdings. Wenn ich später welchen benötige, dann wird noch welcher hinzugefügt.

    Xin hat folgendes geschrieben:
    Ob in der Headerdatei Implementierung steckt oder nicht, ist mir beim Debuggen genauso schnuppe, wie bei der Organisation.
    Was interessiert Dich daran?
    Das möglichst schnelle finden von Fehlern ermöglicht möglichst viel relevante Informationen. Wenn diese Information nicht relevant ist wird mich eine Dateiendung nicht überfordern. Wenn sie relevant ist, dann hilft sie mir auf den ersten Blick zu sehen dass es sich um eine Headerdatei mit Implementierungen handelt. Dieses kleine Detail kann mir eventuell helfen einen Fehler zu finden. Wenn ich beispielsweise versuche ein Datei zu kompilieren, die 12 Header inkludiert, von denen 5 Implementierungen enthalten, und dann Compilerfehler bekomme, dann hilft es hier wenn ich nicht einfach nur 12 ".h" dateien habe.
    Du musst akzeptieren dass das hier eine Entscheidung ist, die nicht auf puren Fakten beruht sondern auf Einschätzung von Arbeitsaufwand und Nutzen. In dieser Einschätzung differenzieren wir anscheinend von einander.

    Xin hat folgendes geschrieben:
    Das ist ja grade der Unterschied bei Exceptions, ich kann nicht entscheiden, ob ich die Information haben kann, sondern ich bekomme sie um die Ohren geschlagen.
    Zumal man wirklich fragen muss, ob ein nicht definierter Parameter Regelfall oder Ausnahme (Exception) ist.
    Xin hat folgendes geschrieben:
    Ich interessiere mich nicht für das Warum, also gibt es auch kein überflüssige Frage. Es gibt also kein "Dein if".
    Xin hat folgendes geschrieben:
    Richtig. Stattdessen verbrät sie Rechenzeit auf Dinge, die niemanden interessieren.
    Das Try kostet bereits. Richtig teuer wird's bei den Catch. Mein If kostet genausoviel, wie die Unterscheidung, ob ich eine Exception werfe oder nicht.
    Und wenn mich der Grund nicht interessiert, warum ein Parameter nicht lesbar ist, dann gibt's bei mir auch kein if mehr.
    Hier gilt das gleiche wie vorhin. Das ist eine Frage der einschätzung, eine Kosten- Nutzen Rechnung. Ich habe auf andere Dinge Wert gelegt als du. Für mich war wichtig: Einfachheit bei der Programmierung (Exceptions abfangen, abfragen und weiterwerfen, statt herumhantieren mit Rückgabewerten und Fehlercodes.), einfachheit bei der Benutzung (x = funktion<typ>(schlüsselwort)). Wenn ich Rückgabewerte für die erkennung von Fehlern benutzen würde, dann müsste ich mit Zeigern oder Referenzen hantieren, was die benutzung umständlich machen würde.
    Zum Thema Leistung: Leistung spielt nur bei 2 anwendungsgebieten eine Rolle: Bei Leistungskritischen Anwendungen (z.B. bei Spielen) oder auf sehr sehr sehr sehr langsamen Computern aus der Steinzeit.
    Ich nehme nicht an, dass ein Spiel, das auf einem Uralten Computer in jedem Frame versucht eine Option aus einer Datei zu laden. Ich nehme an, dass diese Datei nur ein einziges mal am Anfang des Programms geladen wird. Wieso ich mir anmaße diese Annahme zu treffen? Diese Bibliothek hat einen Zweck, nämlich in erster Linie eine Hilfe bei meinen Programmen zu sein. Das bedeutet allerdings nicht, dass es nicht auch andere Menschen gibt, die Programme mit ähnlichen Eigenschaften schreiben wie ich, und für die diese Bibliothek auch passend wäre.


    Xin hat folgendes geschrieben: Der Funktionsumfang ist zu klein, als dass das Einarbeiten lohnt.
    Darauf wollte ich hinaus.

    Xin hat folgendes geschrieben:
    Und was ist groß?
    Der Stil mit den Unterstrichen erscheint mir vollkommen überholt zu sein.

    Das ist schön. Mir erscheint er aber nicht so. In meinem Programm schreibe ich wie ich will, und richte mich nicht nach Trends. Zumindest nicht bei Variablennamen.
    Und mal ganz ehrlich: Es interessiert mich nicht ob ich "class CKillerApp" schreibe oder "class suPER_tollEss_prog_ddas_ALLES_kann". Der effekt ist derselbe.

    Aber ich muss dir danken. Ich habe bis jetzt nie Verstanden wozu die "Rationale"- Section in manchen Dokumentationen gut ist. Jetzt weiß ich es. Es geht darum, Menschen wie dir, die es ziemlich gut verstehen eigene Meinungen und Einschätzungen als Unwiderlegbare Fakten darzulegen davon abzuhalten Flamewars mit den Programmierern zu führen. Mag sein, dass du diese Lib anders geschrieben hättest. Das bedeutet allerdings nicht, dass sie keine Daseinsberechtigung hat, denn ich habe mir bei jeder Entscheidung etwas überlegt und dementsprechend diese Entscheidung getroffen. Code: cat facts | /usr/bin/brain > optsreader.hpp sozusagen...



    Re: PROGRAMMSAMMLUNG

    Xin - 11.01.2008, 18:40

    Re: opstreader
    DrPhil_Guth hat folgendes geschrieben: Bis jetzt reicht für mich der Funktionsumfang allerdings. Wenn ich später welchen benötige, dann wird noch welcher hinzugefügt.
    Das klingt doch ganz anders als 'wird nicht mehr weiterentwickelt'.

    DrPhil_Guth hat folgendes geschrieben: Xin hat folgendes geschrieben:
    Ob in der Headerdatei Implementierung steckt oder nicht, ist mir beim Debuggen genauso schnuppe, wie bei der Organisation.
    Was interessiert Dich daran?
    Das möglichst schnelle finden von Fehlern ermöglicht möglichst viel relevante Informationen. Wenn diese Information nicht relevant ist wird mich eine Dateiendung nicht überfordern. Wenn sie relevant ist, dann hilft sie mir auf den ersten Blick zu sehen dass es sich um eine Headerdatei mit Implementierungen handelt. Dieses kleine Detail kann mir eventuell helfen einen Fehler zu finden. Wenn ich beispielsweise versuche ein Datei zu kompilieren, die 12 Header inkludiert, von denen 5 Implementierungen enthalten, und dann Compilerfehler bekomme, dann hilft es hier wenn ich nicht einfach nur 12 ".h" dateien habe.
    Du musst akzeptieren dass das hier eine Entscheidung ist, die nicht auf puren Fakten beruht sondern auf Einschätzung von Arbeitsaufwand und Nutzen. In dieser Einschätzung differenzieren wir anscheinend von einander.
    Akzeptieren muss ich nichts, ich werde Dein Verhalten nämlich nicht übernehmen. Ich kann's tolerieren - um nicht zu sagen 'Ich kann warten'.

    Mir scheint nur, dass Du Dich aufgrund meine Ablehnung einige Dinge auf den Schlips getreten fühlst. Das ist nicht meine Absicht.
    Ich sehe halt nur, dass ich Headerdateien von Dir mal mit .h und mal mit .hpp einbinden muss. Also entweder klappts, oder ich muss nochmal ran.
    Wenn Implementation in der Headerdatei crasht, sagt mir der Debugger, in welcher Datei. Ob die nun mit .cpp, .hpp oder .h endet, spielt für den Debugger - und damit für mich - keine Rolle.

    Ich sehe keinen Vorteil, aber einen Nachteil.
    Daher mein Hinweis. Was Du machst, kannst Du selbst entscheiden.

    DrPhil_Guth hat folgendes geschrieben: Hier gilt das gleiche wie vorhin. Das ist eine Frage der einschätzung, eine Kosten- Nutzen Rechnung. Ich habe auf andere Dinge Wert gelegt als du. Für mich war wichtig: Einfachheit bei der Programmierung (Exceptions abfangen, abfragen und weiterwerfen, statt herumhantieren mit Rückgabewerten und Fehlercodes.), einfachheit bei der Benutzung (x = funktion<typ>(schlüsselwort)). Wenn ich Rückgabewerte für die erkennung von Fehlern benutzen würde, dann müsste ich mit Zeigern oder Referenzen hantieren, was die benutzung umständlich machen würde.
    An dem Wort 'hantieren' erkenne ich schon Deine Begeisterung von Exceptions. Exceptions sind modern, also warum nicht.
    Ich arbeite hier jeden Tag mit Exceptions, weil Java ist modern.
    Obwohl Exceptions in C++ schon länger existieren als Java selbst, benutzt sie da kaum einer. Ist vermutlich zu trivial für C++ Programmierer, die wollen es nicht zu einfach.

    DrPhil_Guth hat folgendes geschrieben: Zum Thema Leistung: Leistung spielt nur bei 2 anwendungsgebieten eine Rolle: Bei Leistungskritischen Anwendungen (z.B. bei Spielen) oder auf sehr sehr sehr sehr langsamen Computern aus der Steinzeit.
    Hmm... da sehe ich noch eine dritte Größe: Habe ich das Recht Rechenleistung zu verbraten, die der Computeruser auch für andere Dinge verwenden könnte?

    Das Argument 'Ich kann es mir leisten Rechenzeit zu verbraten, weil der Anwender hat ja genug' kommt bei mir nicht an. Das Argument 'Mein Programm wird so selten gerufen, da stört das nicht' auch nicht.
    Exceptions verbrauchen nicht so viel Rechenzeit, dass es (hier) wirklich ins Gewicht fällt, aber etwas Falsches zählt als Argument nie.
    Man kann Abwägen ob man ein Übel oder ein anderes wählt. Aber ein Übel als Pro-Argument zu wählen ist für mich ein Zeichen, dass auf der Basis eine Diskussion keinen Wert hat. It's not a bug - it's feature!

    DrPhil_Guth hat folgendes geschrieben: Aber ich muss dir danken. Ich habe bis jetzt nie Verstanden wozu die "Rationale"- Section in manchen Dokumentationen gut ist. Jetzt weiß ich es. Es geht darum, Menschen wie dir, die es ziemlich gut verstehen eigene Meinungen und Einschätzungen als Unwiderlegbare Fakten darzulegen davon abzuhalten Flamewars mit den Programmierern zu führen. Mag sein, dass du diese Lib anders geschrieben hättest. Das bedeutet allerdings nicht, dass sie keine Daseinsberechtigung hat, denn ich habe mir bei jeder Entscheidung etwas überlegt und dementsprechend diese Entscheidung getroffen.
    Du wolltest Meinungen hören. Du wolltest, dass man es sich ansieht.
    Was ich dazu sagte, gefällt Dir nicht, daher will ich mit meiner Meinung und meiner Einschätzung einen Flamewar mit Dir anzetteln, insbesondere mit Sprüchen wie "Menschen, wie Dir, die <negative Eigenschaften>...". Eine interessante Schlussfolgerung. Ich habe auch nie ein Wort über eine Daseinsberechtigung oder das Fehlen ebendieser geäußert.

    Du kannst Deine Libs schreiben, wie Du magst, genauso wie ich entscheiden kann, ob ich das so verwenden mag.

    Also komm mal wieder runter. Wenn Du nur hören wolltest, dass Du ein toller Hecht bist, dann kannst Du das aus meinem vorherigen Posting auch lesen. Ich dachte, Du suchst Anregungen zur Weiterentwicklung, aber da Du Deine Entscheidungen ja nicht in Frage stellen möchtest, habe ich mich da wohl vertan.



    Re: PROGRAMMSAMMLUNG

    dani93 - 11.01.2008, 20:17


    Macht es einen Unterschied ob man den Header als .h oder .hpp einbindet?



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 11.01.2008, 21:11


    nein. Der Name einer datei ist egal. du könntest deine Header auch mit .dani93_format - benennen.



    Re: PROGRAMMSAMMLUNG

    Moritz - 30.01.2008, 18:03


    Hier ein Programm, welches wer-wird-millionär simuliert:

    http://rapidshare.com/files/87839859/wwm-Setup.exe.html



    Re: PROGRAMMSAMMLUNG

    Moritz - 30.01.2008, 22:08


    Und Hier der (Delphi-)Quellcode downloadbar: (eine dll, 2 units und die zugehörigen 2 Hauptprogramme)


    http://rapidshare.com/files/87898287/wwm-sources.exe.html



    Re: PROGRAMMSAMMLUNG

    DrPhil_Guth - 08.03.2008, 20:48

    calc_md5 - MD5 Prüfsummen berechnen
    Hi! So, ich hab ein paar Funktionen und eine kleine Klasse geschrieben, mit der es ganz einfach ist MD5 Prüfsummen zu berechnen.
    Den Algorithmus hab ich nicht selbst implementiert, sondern ich hab die Beispielimplementierung aus dem RFC 1321 (Definition des MD5 Algorithmus) genommen.
    Was ich geschrieben habe ist nur ein kleiner C++ wrapper, mit dem das ganze um einiges bequemer zu handhaben ist.

    Also die benutzung läuft wie folgt:

    Einfach "md5.hpp" inkludieren, md5.cpp mitkompilieren und los gehts.

    Korrekte ausdrücke wären:

    Code:
    // hash- variable deklarieren
    md5hash hash;


    // MD5 Pruefsumme aus einer datei berechnen
    FILE* infile;
    // oder
    std::fstream infile;
    // fopen(), infile.open(), blah bla...

    hash = md5(infile); // achtung! wirft exception, wenn mit der datei etwas nicht stimmt.

    // MD5 Pruefsumme aus einem String berechnen.
    std::string hs_string("Dies ist ein string.\n");
    hash = md5(hs_string);

    // MD5 Pruefsumme aus einem beliebigen Array berechnen
    int array[4] = { 1, 4, 2, 6 };
    hash = md5(array);

    // Pruefsumme in einen String speichern
    std::string result;
    result = hash.to_string();
    result = (std::string) hash; // oder so!

    // Pruefsummen vergleichen
    if ( result == hash)
        // bla();

    // Pruefsumme ausgeben
    std::cout<<hash;

    // pruefsumme einlesen
    std::cin>>hash; // bitte 32 hexadezimalzeichen eingeben
    // achtung, wirft exception, wenn das format nicht stimmt!

    // md5hash objekt aus einem string erstellen
    md5hash hash_aus_string(result); // wirft ebenfalls exception. In dem string könnte ja irgendwas stehen.

    Alle details könnt ihr in der headerdatei md5.hpp nachlesen.
    Achtung: folgende funktionen werfen exceptions:

    std::istream& operator>> (std::istream& in, md5hash& hs);
    md5hash::md5hash (const std::string& hs); // (konstruktor)

    md5hash md5 (FILE* infile);
    md5hash md5 (std::ifstream& infile);

    Wenn ihr das ganze ohne exceptions haben wollt, müsst ihr nur das Makro _MD5_NOTHROW definieren. Dann werden alle exceptions abgeschaltet, allerdings gibt es bei den jeweiligen funktionen kaum möglichkeiten zur Fehlerüberprüfung.


    Zum testen der Funktionen und der Klasse habe ich ein kleines Programm geschrieben, dass eigentlich ein Klon des Programms "md5sum" ist, das es auf Linux Systemen gibt. (Mit einigen einschränkungen)
    Die datei heißt calc_md5.cpp, und ein kleines Makefile zum kompilieren liegt natürlich auch noch bei. Die ausgabe ist kompatibel zu md5sum, und auch die Argumente sind recht ähnlich.
    Für weitere details müsst ihr das Programm mit dem argument -h oder --help aufrufen.
    Noch ein kleines Wort zum Thema von der Standardeingabe lesen:
    ihr könnt das program ohne argumente mit einer pipe '|' aufrufen, zum beispiel so: "cat bla.txt | calc_md5". Wenn ihr das Programm unabsichtlich (oder auch nicht) einfach so ohne argumente gestartet habt, liest es von der Standardeingabe, also von der Tastatur. Beenden könnt ihr die eingabe durch senden eines EOF- Zeichens, dass unter Linux durch (manchmal mehrmaliges!) drücken von CTRL - D erreicht wird. Wie man das unter windows erreicht, habe ich noch nicht herausgefunden.

    So, genug der worte, jetzt lasse ich Code sprechen:

    http://fat-lobyte9.pytalhost.com/downloads/calc_md5.zip
    http://fat-lobyte9.pytalhost.com/downloads/calc_md5.tar.gz

    So, bitte runterladen, ganz viel verwenden und sagen was ihr davon haltet!

    mfg, DrPhil_Guth



    Mit folgendem Code, können Sie den Beitrag ganz bequem auf ihrer Homepage verlinken



    Weitere Beiträge aus dem Forum Tutorials.at

    PC-Spiele programmieren - gepostet von Dominik92 am Mittwoch 13.09.2006
    Problem mit Klassen - gepostet von absoluter noob tith am Donnerstag 15.03.2007
    Neuer Webspace - gepostet von administrator am Freitag 15.06.2007
    Shutdown - gepostet von DarkJiN am Samstag 11.08.2007
    problem mit einer Angabe! - gepostet von niki1 am Montag 14.05.2007
    ersatz für getch() - gepostet von DrPhil_Guth am Freitag 28.07.2006
    Variablen tauschen - gepostet von Joe am Samstag 03.11.2007
    Datei öffnen - gepostet von ringo am Donnerstag 23.08.2007
    C++ Lernen - gepostet von Nightm4r3 am Mittwoch 20.09.2006



    Ähnliche Beiträge wie "PROGRAMMSAMMLUNG"