Verfügbare Informationen zu "PROGRAMMSAMMLUNG"
Qualität des Beitrags: 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:12PROGRAMMSAMMLUNG
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:59Mathematischer 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:43opstreader
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:00Re: 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:08Re: 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:24Re: 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:57Re: 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:37Re: 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:58Re: 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:40Re: 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:48calc_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"
