PS-Trainer C - Entwicklung
Lehreinheit Nr. 1
Homepage von PS-Trainer - C-Entwicklung - Bibliotheken - an PS-Trainer
PS-Trainer PS-Trainer

Start mit C-Programmierung:

Diese Programme setzen keine C-Kenntnisse voraus und führen schrittweise zu den elementaren Techniken der Programmierung.

Dabei werden zunächst nur wenige Themen oberflächlich berührt.

Ziel dieser Unterrichtseinheit ist es, einige grundlegende "Werkzeug"-Kenntnisse zu vermitteln.

Alle Themen werden zu späteren Zeitpunkten nochmals genauer behandelt.
Die einzelnen Programme werden besprochen und je nach Geschwindigkeit des Arbeits-Fortschritts in Arbeit genommen. Damit den unterschiedlichen praktischen Kenntnissen der StudentInnen entsprochen werden kann, sind zu jedem Programm einige Varianten vorgesehen - programmieren sie diese, solange und sobald Zeit dazu ist.

Ein wichtiger Neben-Effekt ist es, daß sie lernen, sich Hilfe zu organisieren: Versuchen sie zuerst, geeignete Stichworte zum gesuchten Thema zu definieren, verwenden sie dann integrierte Hilfe und Internet, um rasch und zielgerichtet Informationen zu finden.

Tip 1: Verwenden sie neben dem PC auch Papier und Bleistift !
Tip 2: Sie haben RW-Zugriff auf C:\Temp und auf ihren Server-Bereich.
Tip 3: Beginnen sie mit minimaler Dokumentation (Kommentare !) und benennen sie aufeinanderfolgende Varianten ihrer Programme sinnvoll.
Tip 4: Sie können sich mit Hilfe von WebMail selbst die Source-Codes senden und zu Hause bearbeiten. Umgekehrt stellt das WebMail eine Möglichkeit dar, Dateien von zu Hause in den Unterricht mitzunehmen.

Viel Erfolg & viel Spaß !

001 Hallo
002 ZeichenEcho
003 ATSEUR
004 Textanalyse
005 Zeichencode
006 Umbruch
007 Textkontrolle
008 Zufallszahl
009 Zufallstext
010 Zahlenkategorie

001
Programm "Hallo"

Das Programm gibt einen kurzen Text aus (z.B. "Hallo Welt!")
Ziel: Nachweis eines funktionierenden Programms.
Sie erstellen ein Programm, das sein Funktionieren überhaupt bekanntgeben kann.
Hilfe: StreamIO (formatiert).

Library #include "stdio.h"
Funktion printf("Ausgabetext\n");

002
Programm "ZeichenEcho"

Das Programm verlangt die Eingabe von Zeichenketten und gibt diese anschließend wieder aus.
Ziel: Einfache Eingabe und Ausgabe; EOF.

Das benötigen sie als minimale Voraussetzung, um die "eigentlichen" Programme zwischen Eingabe und Ausgabe auszubauen.
Hilfe: StreamIO
Funktionen

getchar();
putchar();
scanf();
printf();


003
Programm "ATSEUR"
Das Programm verlangt die Eingabe eines Betrages in ATS und gibt den Betrag in EUR aus.
Ziel: Einfacher Umgang mit Zahlen, Makro-Konstante.

Definition #define ATSEUR 13.7603
#define PI 3.14159265358979323846
#define E 2.718281828459045

Varianten
:
Diskutieren sie Möglichkeiten zur Prüfung der Eingabe.
Überlegen sie die Erweiterung, zusätzlich die umgekehrte Berechnung (EUR->ATS) auszuführen, oder gemischte Eingabe sowohl von ATS als auch EUR zuzulassen.

004
Programm "Textanalyse"
Das Programm verlangt die Eingabe von Texten und gibt die Anzahl der Zeichen als einfache Analyse der Texte aus.
Ziel: Einfacher Umgang mit Zeichen und Texten, einfache logische Verzweigungen.

Varianten:
Das Programm analysiert zusätzlich die Anzahl der Worte
(woran erkennen sie ein "Wort" ?)
Das Programm isoliert Worte, die mit "#" beginnen und gibt diese aus (parse).
Das Programm isoliert das längste Wort und gibt dieses aus.

005
Programm "Zeichencode"

Das Programm erzeugt eine 2-spaltige Tabelle (Zahl, Zeichen) aller Zeichen des verwendeten Zeichencodes.
Ziel: Einfache Schleifen, Umwandlung Zeichen <-> Ganzzahl
> Überlegen sie, welche Werte ein Zeichencode überhaupt annehmen kann, welche davon sinnvoll für dieses Programm sind.
> Vergleichen sie die Ergebnisse mit jenen, die sie in typischen Win-Programmen (z.B. Excel) erhalten.

Hilfe: Flusskontrolle (Schleifen),
Anmerkung: Führen sie Typ-Umwandlungen durch, z.B. c=char(i); oder i=int(c);

Varianten:
Erzeugung von 4 Spalten: Dezimal, Oktal, Hex, Zeichen. (Formatierung)
Ausgabe eines Eingabetextes als Liste oder Tabelle mit den oben erwähnten 4 Spalten
Zusätzliche Spalte für Binär-Anzeige.


006
Programm "Umbruch"
Das Programm verlangt die Eingabe eines (langen) Textes und gibt diesen wieder aus, umgebrochen auf 5 Zeichen breite Spalten.
Ziel: Schleife, Verzweigung.

007
Programm "Textkontrolle"

Das Programm simuliert die Überwachung und Verbesserung eines Datenbank-Textfeldes.
Eingabe: Text, normalerweise 1 Wort, gelegentlich auch 2...3 Worte (z.B. Vornamen)
Ausgabe: Das geprüfte und bei Bedarf verbesserte Wort, Anzahl der Worte

Prüfungen:
Sonderzeichen außer "-" werden durch Leerzeichen ersetzt.
Folgen von Leerzeichen werden durch einzelne Leerzeichen ersetzt.
Führende und nachfolgende Leerzeichen werden eliminiert.
Anfangsbuchstaben werden groß geschrieben, alle anderen klein.
Anzahl der Worte wird auf 5 begrenzt.
> Überlegen sie, ob die Reihenfolge der Prüfungen gleichgültig oder sinnvoll ist, bzw. ob in manchen Fällen weitere Prüfungen sinnvoll wären.
   

008
Programm "Zufallszahl"

Das Programm erzeugt eine gleichmäßig verteilte Zufallszahl in einem Intervall.
Ziel: Funktionen (Unterprogramme), Geltungsbereich von Variablen. Programmierung eines vorgegebenen Algorithmus.
Eingabe: Minimalwert (grenze_von), Maximalwert (grenze_bis).
> Stellen sie fest, in welchem Bereich ihr System Zufallszahlen ausgibt und normieren sie diesen Bereich unabhängig vom Betriebssystem auf Reale Zahlen 0...1
> Diskutieren sie Möglichkeit und Sinn wiederholbarer "Pseudo-Zufallsreihen" und "wirklicher" Zufallsreihen.

Algorithmus:

zufall_intervall_float = zufallszahl(0...1) * (grenze_bis - grenze_von) + grenze_von
Hilfe: Mathematik-Funktionen "Zufall".

Varianten:
Ändern sie den Code so, daß das Hauptprogramm nur Eingabe und Ausgabe organisiert, die Zufallszahl in einer Funktion berechnet wird.
Geben sie zusätzlich eine ganze Zahl für die Menge der Zufallszahlen ein und erzeugen sie mit jedem Eingabe-Schritt eine ganze Tabelle von Zufallszahlen, je nach gewünschter Menge.
Erzeugen sie wahlweise ganze Zahlen (integer) oder reelle Zahlen (float) im gewünschten Bereich:

Algorithmus:
zufall_intervall_int = ganzzahl (zufallszahl(0...1) * (grenze_bis - grenze_von + 1) + grenze_von)

Erzeugen sie in einer weiteren Funktion "spitzen-verteilte" Zufallszahlen durch Multiplikation jeweils zweier Zufalls-Zahlenpaare.
Legen sie die "Spitze" zunächst genau in die Mitte des Intervalls.

Algorithmus:

spitze = (grenze_von + grenze_bis) / 2
x = zufallszahl(0...1) * zufallszahl(0...1)
wenn zufallszahl(0...1) < 0.5
x = x * (grenze_von - spitze)
sonst
x = x * (grenze_bis - spitze)
zufall_spitze = spitze + x


Erweitern sie diese Funktion auf asymmetrische Verteilung durch Eingabe eines "Spitzen"-Werts, der innerhalb des Intervalls (Minimalwert...Maximalwert) liegen muß.
Erzeugen sie eine weitere Funktion, die nach obigen Mustern spitzen-verteilte ganze Zahlen (Integer) erzeugt.
Erzeugen sie mit Hilfe ihrer Funktionen das praktische Programm "LehrerInnen-Hilfe", das Schulnoten gleichmäßig bzw. spitzen-verteilt erzeugt.

Diese Funktionen können sie später zum Test ihrer eigenen Programme verwenden.
Testen sie damit nicht nur zulässige Zahlenwerte !
Beispiel Zufallszahl: Beispiel: Das Hauptprogramm liefert das bescheidene "user unterface", der Rest wird in (wiederverwendbaren) Unterprogrammen bearbeitet.:

/*
Random number generator example program
This generator delivers qually distributed
real pseudo-random numbers in user-defined range
Version 1.0: range 0...1
Version 1.1: user-defined range
Version 1.2: function myrnd
It is initializes with seconds of real time
- switch off initialization to reproduce same random sequence
Version 1.2 / 2001.09.01
Autor: Peter Schindler, pstrainer@gmx.net
*/

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <conio.h>
#include <math.h>

/* ***************************************************
Declarations
*/
int myrnd_init(int myrnd_control);
float myrnd0(void);
float myrnd1(void);
float myrnd2(void);
float select_choice(void);

int user_choice;
float myrnd_max,myrnd_lo,myrnd_med,myrnd_hi;

/* ***************************************************
Main program
*/
void main (void) {

int i,j;
float r;

/* Init variables */
user_choice=9;
myrnd_lo=0.0;
myrnd_hi=0.0;

/* user info */
printf("Random number generator V1.0\n");
printf("(1) Initialize rand function with seconds(time).\n");
printf("(2) Generate & display 50 random numbers in a user-defined range.\n");
printf("(3) Display console until key pressed.\n\n");

/* Get user choice */
while (user_choice>2) {
printf("Demonstrate random function:\n");
printf(" 0-> interval 0...1\n");
printf(" 1-> user-defined interval\n");
printf(" 2-> triangle-distribution\n");
printf("Enter your choice: ");
scanf("%d",&user_choice);
if (user_choice>2) {
printf("\nError: enter 0...2 !\n\n");
}
}

/* Get limit values from user */
if ((user_choice==1)||(user_choice==2)) {
printf("\nEnter lower limit ");
scanf("%f",&myrnd_lo);
printf("Enter upper limit ");
scanf("%f",&myrnd_hi);
}

if (user_choice==2) {
myrnd_med=myrnd_hi*2.0;
while ((myrnd_med<myrnd_lo)||(myrnd_med>myrnd_hi)) {
printf("Enter peak value ");
scanf("%f",&myrnd_med);
if () {printf("Error, enter %f < peak value < %f\n",myrnd_lo,myrnd_hi);}
}
}
myrnd_init(1);

/* print 5 columns @ 10 lines of random numbers */
printf("\n");
for( i = 0; i < 10;i++ ) {
for (j=0;j<4;j++){
r = select_choice();
printf("%12f ",r);
}
r=select_choice();
printf( " %12f\n", r );
}

/* show console window until key pressed */
printf("\nType any key to continue.\n");
_getch();

}

/* ***************************************************
Function select_choice
select user choice
from avaliable functions myrnd0...myrnd2
according to int user_choice
*/
float select_choice(void)
{
float x;
x=0;
if (user_choice==0) {x=myrnd0();}
else if (user_choice==1) {x=myrnd1();}
else if (user_choice==2) {x=myrnd2();}
return(x);
}

/* ***************************************************
Function myrnd_init
int myrnd_control:
1->normalize (interval lo...hi)
2->initialize (time)
3->normalize and initialize (interval lo...hi)
*/
int myrnd_init(int myrnd_control)
{

/* normalize myrnd */
if ((myrnd_control==1)||(myrnd_control==3)) {
myrnd_max=float(RAND_MAX);
if (myrnd_max==0) {myrnd_max=1.0;}
myrnd_med=(myrnd_lo+myrnd_hi)/2.0;
}

/* initialize rand function */
if ((myrnd_control==2)||(myrnd_control==3)) {
srand (time(NULL));
}

return(myrnd_control);
}

/* ***************************************************
Function myrnd0
returns random value in interval 0...1
*/

float myrnd0(void)
{
float c;
c=float(rand())/myrnd_max;
return(c);
}

/* ***************************************************
Function myrnd1
returns random value in interval initialized by myrnd_init
*/

float myrnd1(void)
{
float c;
c=myrnd0()*(myrnd_hi-myrnd_lo)+myrnd_lo;
return(c);
}

/* ***************************************************
Function myrnd2
returns triangle-distributed random value
in interval initialized by myrnd_init
*/

float myrnd2(void)
{
float x;
x=myrnd0()*myrnd0();
if (myrnd0()<0.5) {x = x * (myrnd_lo-myrnd_med);}
else {x = x*(myrnd_hi-myrnd_med);}
x=myrnd_med+x;
return(x);
}


009
Programm "Zufallstext"

Das Programm erzeugt in einer Funktion Zufallstexte.
Ziel: Testprogramm für den eigenen Bedarf.
> Überlegen sie sinnvolle Eingabe-Parameter.
Das Programm soll - je nach Eingabe - Zufallstexte zum Test entsprechender Programme erzeugen.
> Überlegen sie z.B.: Anzahl und Länge der Worte, Sonderzeichen, leere Texte...
Verwenden sie das Unterprogramm dazu, alle oben angeführten Text-orientierten Programme automatisch zu testen.

010
Programm "Zahlen-Kategorie"

Das Programm analysiert Zahlen und ordnet sie einer von mehreren vorgegebenen Kategorien zu.
Ziel: Test-Strategie
Das Programm erwartet die Eingabe beliebig vieler Zahlen, analysiert diese nach Kategorie und gibt eine Statistik aus.
Kategorie: Schulnoten (1...5).

Variante:
Testen sie das Programm mit der Funktion "Zufallszahl", z.B. mit 10.000 Eingabezahlen
> Überlegen sie die Erweiterung auf exotische Eingabewerte.


Einige hilfreiche Beispiele (nach Brian Kernighan und Dennis Ritchie)
Funktion strlen(s)

int strlen (char s[]) /* berechnet Laenge von s */
{
int i;
i = 0;
while (s[i] != '\0')
++i;
return(i);
}

Funktion getline(s,lim)

int getline (char s[],int lim)
/* Zeile in s ablegen, Länge liefern */
{
int c, i;
i = 0;
for (i=0; i<lim-1 && (c=getchar()) != EOF && c != '\n'; ++i)
s[i] = c;
if (c == '\n') {
s[j] = c;
++i;
}
s[i] = '\0';
return(i);
}

Funktion index(s.t)

int index (char s[], char t[])
/* Position von t in s liefern, -1 falls nicht gefunden */
{
int i, j, k;
for (i = 0; s[i] != '\0'; i++) {
for (j=i, k=0; t[k]!='\0' && s[j]==t[k]; j++, k++)
;
if (t[k]=='\0')
return(i);
}
return(-1);
}

Funktion atof(s)

main() {
double atof();
...
}

double atof (char s[]) /* String in double umwandeln */
{
double val, power;
int i, sign;
for (i=0; s[i]==' ' || s[i]=='\n' || s[i]=='\t';i++)
; /* Zwischenraum uebergehen */
sign = 1;
if (s[i] == '+' || s[i] =='-') /* Vorzeichen */
sign = s[i++] == '+') ? 1 : -1;
for (val = 0; s[i] >= '0' && s[i] <= '9'; i++)
val = 10 * val + s[i] - '0';
if (s[j] == '.')
i++;

for (power = l; s[i] >= '0' && s[i] <= 9'; i++) {
val = 10 * val + s[i] - '0';
power *=10;
}
return(sign * val / power);
}

Funktion atoi(s) int atoi (char s[]) /* Zeichenkette s in int umwandeln */
{
int i, n, sign;
for (i=0; s[i]==' ' || s[i]=='\n' || s[i]=='\t';i++)
; /* Blanks ignorieren */
sign = 1;

if (s[i]=='+' || s[i]=='-') /* Vorzeichen */
sign = (s[i++]=='+') ? 1 : -1; /* Wenn - dann */
for (n = 0; s[i] >= '0' && s[i] <= '9';i++)
n = 10 * n + s[i] - '0';
return(sign * n);
}
Funktion itoa(n,s)

void itoa (int n, char s[]) /* int n in string s umwandeln */
{

int i, sign;
if ((sign = n) < 0) /* notiere das Vorzeichen */
n = -n; /* n positiv machen */
i = 0;
do { /* Ziffern von rechts her erzeugen */
s[i++] = n % 10 + '0'; /* naechste Ziffer */
} while ((n /= 10) > 0); /* entfernen */
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
reverse(s);
}

void reverse (char s[]) /* string umkehren */
{
int c, i, j;
for (i=0; j=strlen(s)-1; i++,j--) {
c = s[i];
s[i] = s[j];
s[J] = c;
}
}

Funktion lower(c)

char lower (int c) /* c in Kleinbuchstaben umwandeln - ASCII */
{

if (c >= 'A' && c <= 'Z')
return(c + 'a' - 'A');
else
return(c);
}

Umwandlung von Variablen-Typen (casting) int i;
char c;
char s[80];
c = 'A';
i = int(c); /* wandelt char -> int */
printf("%d \n",i);
c = char(i); /* wandelt int -> char */
s[0]=c;
s[1]='\0';
printf("%s\n",s);
Zeichenecho #include "stdio.h"
void main () {
int c;
c = getchar();
while (c!=EOF) {
putchar(c);
c=getchar();
}
}
   

Homepage von PS-Trainer - Entwicklung - an PS-Trainer

Aktuelle Daten dieser Seite Letzte Änderung:
  Geocities