C und die Welt von Assembler - Teil 3

Die Arbeitsweise einer CPU
Wie eine CPU aufgebaut ist, wissen wir nun. Doch zu Wissen wie sie aufgebaut ist, heißt noch lange nicht zu Wissen wie sie arbeitet. Was macht eine CPU mit dem Maschinencode? Dieser Frage wollen wir nun auf den Grund gehen. Fangen wir am Anfang an.

Man nehme an jemand hätte ein Programmcode geschrieben und diesen mit einem Assembler in den Maschinencode compiliert. Jetzt sind die Einsen und Nullen irgendwo im Arbeitsspeicher.

Ein Programm besteht aus einer Reihe von Befehlen. Diese werden vom Prozessor bearbeitet. Dies geschieht folgendermaßen.

1. Zum Anfang wird der Programmzähler auf die Adresse des Speicherplatzes gesetzt. In dieser Adresse befindet sich der Code des nächsten Befehls. 
2. Der Befehlscode wird aus dem Arbeitsspeicher geholt und dekodiert.
3. Jetzt wird der Befehl ausgeführt. Wäre der Befehl "LSR". So würde der Prozessor alle Werte im Stack um eine Position nach Links verschieben.
4. Danach wird der Programmzähler erhöht und ein neuer Zyklus beginnt.

Die Highways des Computer: Die Busse
Wie schon erwähnt sind die CPU und die Arbeitsspeicher(RAM) durch Bussysteme miteinander verbunden. Diese Digitalen Autobahnen befördern eine Unmenge an Daten zwischen all den Komponenten im PC. Man unterscheidet zwischen drei Bussysteme.

1. Der Datenbus
   Der Datenbus überträgt Daten zwischen Computerbestandteilen innerhalb eines Computers oder zwischen verschiedenen Computern. Die Bezeichnungen 4-Bit-, 8-Bit-, 16-Bit-, 32-Bit- oder 64-Bit-CPU bezeichnen in der Regel die Breite des internen Datenpfades einer solchen CPU. Der Prozessor kann auf den Datenbus in
   zwei Richtungen zugreifen: lesend und schreibend. So eine Verbindung, die in
   beide Richtungen möglich ist, bezeichnet man auch als bidirektional.
2. Der Adressbus
   Der Adressbus ist im Gegensatz zum Datenbus ein Bus, der nur Speicheradressen überträgt. Die Busbreite, also die Anzahl der Verbindungsleitungen, bestimmt dabei, wie viel Speicher direkt adressiert werden kann. Der Adressbus leitet Informationen nur in eine Richtung, nämlich vom
   Steuerwerk des Prozessors zum Arbeitsspeicher. Er wird daher als unidirektional
   bezeichnet.
   Bei einem System mit 32 Adressleitungen können 2³² =  4 GB angesprochen werden. Bei einem 64-Bit-System können sogar 2⁶⁴ =  16 Exabyte angesprochen werden. Um mehr als 4 GB RAM ansprechen zu können benötigt man demnach ein 64-Bit-System.
   
   Die 8086/8088-CPU beispielsweise besitzt einen 20 Bit breiten Adressbus. Damit
   kann sie auf  1 MB Speicher zugreifen. Allerdings müsste dafür das Register in der CPU auch 20 Bit aufweisen. Da sich in diesem Register die Adresse befindet, bevor sie auf den Adressbus geht. Die 8086/8088-CPU hat allerdings nur ein 16 Bit Register. Damit können lediglich 65 KB direkt adressiert werden.
   Um dennoch auf die 1 MB Speicher zugreifen zu können, werden zwei Register benötigt. Mit zwei 16-Bit-Registern kann man 4 GB Arbeitsspeicher ansprechen. Teilt man die Adresse auf die beiden Register auf, so dass 16 Bit vom einten und 4 Bit vom anderen Register genutzt werden, hat man eine 20 Bit Adresse.
3. Der Kontroll- / Steuerbus
   Der Kontrollbus ist ein Teil des Bussystems, welcher die Steuerung des Bussystems bewerkstelligt. Hierzu zählen unter anderem
   
   • die Leitungen für die Lese-/Schreib-Steuerung, 
   • Interrupt-Steuerung, 
   • Buszugriffssteuerung, 
   • die Taktung (falls ein Bustakt erforderlich ist), 
   • Reset- und Statusleitungen. 
   Der Kontrollbus koordiniert den Adress- und den Datenbus. Er sorgt dafür, dass nicht mehrere Komponenten gleichzeitig darauf zugreifen.

Nun kennen wir die Hardware nochmals ein wenig besser.


C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

C und die Welt von Assembler - Teil 2

Die CPU und ihre Partner
Da der Programmcode von Assembler dazu dient CPU's zu Programmieren, sollte man die CPU verstehen. Die CPU (CentralProcessingUnit) ist der Kern jedes Computers. Hier werden die Berechnungen, welche man Programmiert, durchgeführt.
Neben der CPU gibt es im Computer noch einige wichtige Komponenten. Dies währen:

• ein Speicher z.Bsp. RAM ( RandomAccessMemory), oder eine Harddisk
• I/O (Input/Output, Ein- /Ausgabegeräte) z.Bsp. Tastatur, Bildschirm, usw.
• Bus - System. Als Bus System sind Leitungen zu verstehen welche die einzelnen Komponenten verbinden. Diese befinden sich meistens auf einer Motherboard.

Die CPU unterteilt man in:

1. Prozessor (Steuerwerk)
Der Prozessor verarbeitet alle eingehenden Informationen in Form von elektrischen Signalpegeln und steuert deren Weiterleitung
• in den internen Speicher,
• auf externe Speichergeräte wie z.B die Festplatte,
• auf Ausgabegeräte wie Bildschirm oder Drucker
Oft werden vom Prozessor Informationen an die ALU weitergeleitet.
2. ALU (ArithmeticLogicUnit) 
   Die ALU kann arithmetische und logische Funktionen berechnen. Dabei sind die möglichen Operationen auf folgende eingeschränkt:

• Arithmetisch:
  
  • Addition (ADD)
  • Subtraktion (SUB)
• Logisch:
  
  • Negation (NOT)
  • Konjunktion (AND)
  • Disjunktion (OR)
  • Vergleich (compare, CMP)
  • Kontravalenz (XOR)
• Sonstige:
  • Rechts- und Linksverschiebung (arithmetische Shift, ASR/ASL)
  • Rechts- und Linksverschiebung (logisches Verschieben, LSR/ASL)
  • Rechts- und Linksrotation (ROL, ROR)
  • Register-Manipulationen und Bit-Veränderungen (Bits setzen, löschen und testen)
3. Interner Speicher (Register)
   Informationen, auf die der Prozessor schnell zugreifen muss, werden im internen Speicher (sogenannter flüchtiger Speicher in Speicherchips) abgelegt.
   
   • RAM(Random-Access-Memory)
     Von allen internen Speicher eines Computers ist der RAM einer der langsamsten. Dies weil er nicht direkt in der CPU ist sondern meistens über einen Bus auf der Motherboard mit dieser verbunden. Dafür ist er um einiges größer als andere interne Speicher. Hier werden die Programme welche zurzeit ausgeführt werden Gespeichert. Je nach Betriebssystem und Hardware Konfiguration variiert die Wichtigkeit oder auch die Einsatzweise des RAM's.
   • Register
     Der Speicherbereich innerhalb einer CPU welcher direkt mit dem Prozessor verbunden ist nennt man Register.  Diese Speicher sind die schnellsten Speicher eines Computers. Da sie direkt in der CPU sind und so über kein Bussystem verlangsamt werden.
     Es gibt verschiedene Typen von Registern:
     
     • Datenregister (Akkumulator)
       Datenregister werden benutzt, um Operanden für die ALU und deren Resultate zu speichern.
     • Adressregister(Datenverarbeitung)
       Adressregister werden benützt um Speicheradressen von Operanden oder Befehlen zu berechnen. Das Adressregister bestimmt wie der Prozessor die Operanden findet und wie er die Ergebnisse abspeichern soll.
     • Frei verwendbare Register
       In modernen RISC-CPUs, so PowerPC oder Sun SPARC, heißen die Datenregister allgemeine oder frei verwendbare Register, da sie sich beliebig als Daten- oder Adressregister einsetzen lassen.
     • Stapelregister
       Stapelregister sind Adressregister zur Verwaltung von Stapelspeichern.
       Ein Stapel kann eine theoretisch beliebige, in der Praxis jedoch begrenzte Menge von Objekten aufnehmen. Elemente können nur oben auf den Stapel gelegt und auch nur von dort wieder gelesen werden. Elemente werden übereinander gestapelt und in umgekehrter Reihenfolge vom Stapel genommen.
     • Spezialregister (Hilfsregister für Prozessor)
       
       • Befehlszählregister, auch Programmzähler oder Befehlszähler.
       •  Befehlsregister, speichert den aktuellen Befehl
       •  Basisregister
       •  Segmentregister
       •  Statusregister, geben bestimmte Zustände nach Ausführung eines Befehls an
       •  Interrupt-Steuerregister
   Das Zusammenspiel dieser Komponenten ermöglicht das Berechnen einiger Befehle. Welche im Programmcode geschrieben und mit Assembler übersetzt werden. Diese befehle beinhalten einfache Schritte welche die CPU ausführen kann. Eine clevere Kombination dieser befehle ermöglicht schlussendlich, komplexe Berechnungen wie sie Heute von den Meisten Computern ausgeführt werden.

C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

C und die Welt von Assembler - Teil 1

Assembler - need to know
Um Prozessoren programmieren zu können benötigt man eine Programmiersprache. Nun gibt es unzählige, verschiedene Sprachen, neben den bekannten Sprachen wie C, C++, C#, Turbo Phyton und Pascal gibt es den Assembler.
Assembler ist eigentlich ein Übersetzer oder Compiler welcher den "Assembler"(Programm)-Code in die Maschienensprache übersetzt.
Die Maschienensprache ist die Sprache des Prozessors welche aus null und eins besteht:
Als Beispiel Übersetzt er folgende Befehle in den Maschienencode:

Da das Dualsystem (0101 1100)  ungeeignet zum Programmieren ist, benützt man einen Assembler und schreibt das Programm im Assembler Code(mov). Dies ist viel einfacher und erspart viel Zeit.
Je nach Prozessor können die vorhandenen Befehle variieren. In den gebräuchlichen PC's werden allerdings Prozessoren verwendet, welche mit dem 8086 von Intel kompatibel sind. So gibt es doch noch eine gewisse Kompatibilität.
Im Gegensatz zu anderen höheren Programmiersprachen wie C oder Java, benötigt der Assembler für jeden Schritt eine Anweisung. Wobei bei den Hochsprachen mit einer Anweisung mehrere Schritte ausgeführt werden. Dies führt automatisch zu mehr Befehlen, für gleiche Anwendungen.

Einige Gründe für die Verwendung von Assemblersprache:

1.  Treiber werden weitgehend in Maschinensprache geschrieben.
2. Anspruchsvolle Programme (z. B. Spiele) werden meist erst in einer Hochsprache
   geschrieben - und laufen unzumutbar langsam. Ersetzt man später einige kritische (am häufigsten durchlaufene) Programmteile durch Maschinensprache, wird das gesamte Programm wesentlich schneller. Ersetzt man nur ein Prozent des Programms an den richtigen Stellen durch Assemblercode, läuft das Programm 10- bis 100-mal schneller!
3. Jeder Compiler erzeugt auch aus einer Hochsprache ohnehin letztlich ein Programm in Maschinensprache. 
4. Bei industriellen Steuerungen mit Echtzeit-Anforderungen, d.h. die sofort reagieren müssen, ist die Verwendung von Maschinensprache häufig notwendig.
5. Beschäftigung mit Maschinensprache erfordert und fördert zugleich das Verständnis für das Funktionieren der Hardware.

Gratis Assembler zum Üben. :

• NASM-Projektseite bei SourceForge

C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

C- Password Eingabe

Das Programm:
Ein Programm wird mit einem Code geschützt. Der Benutzer hat drei Versuche.
Mit Hilfe einer Do-While-Schlaufe werden die Anzahl Versuche begrenzt.
Die if Funktionen überprüfen die Richtigkeit der Zahl.

/*
Titel: Eingabeprüfung
Datei password.cpp
Autor: Jonathan Ernst
Datum: 26.08.2011
 Rev : 2.0
Funktion:
Password: Ein Programm wird mit einem Code geschützt. Der Benutzer hat drei Versuche.
*/
#pragma hdrstop                                      //compiler anweisung
#pragma argsused                                     //compiler anweisung
#include                                    //Biblioothek Tastatur laden
#include                                    //Bibliothek I/O laden
#include                                     //Bibliothek math laden
//-------------------------------------------------------------------------------------------
int main(void)                                    //aufruf funktion hauprprogramm
{
int code = 1234;                                //Deklaration Variable code
int password = 0;                               //Deklaration Variable password
int zaler = 0;                                  //Deklaration Variable zahler

 printf("Hallo,\nLieber Internet Benutzer, sie haben jetzt die \nM\224glichkeit sich f\201r das Programm anzumelden.\nDazu ben\224tigen wir ihr Password."); //Textausgabe
 printf("\n\nIhr Password: ");      //Textausgabe
 scanf("%i", &password);            //eingabe des Passwords


 if (code != password)                           //Konntrolliert die Richtigkeit des Passwortes
   {
         do        //while schlaufe bis password ok ist.
         {
              printf("\n\nIhr Password: ");       //Textausgabe
              scanf("%i", &password);            //eingabe des Passwords
              zaler = zaler +1;                 //zählt anzahl versuche.
         }
         while (( code != password)&&(zaler < 2));      //Drei Versuche Das Password richtig einzugeben.
   }

if (code != password)                             //Konntrolliert die Richtigkeit des Passwortes
   {
         printf("Sorry, sie haben es nicht geschaft.");       //Textausgabe
         getch();

   }
else                                                               //Wenn das Password Richtig ist.
   printf("Gratulation sie haben den richtigen Code eingegeben!");    //Textausgabe

getch();
return(0);
}

Der Compilierte Code :

C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

C- Eingabeprüfung

Das Programm:
In diesem Programm wird die While-Schlaufe eingesetzt. Diese wiederholt den Programmteil solange die eingegebene Zahl nicht zwischen 100 und 1000 liegt.

Mit den Funktionen if und else werden die eingegebenen Werte mit den festgelegten Werten verglichen. Wenn die Zahl im richtigen Zahlenbereich liegt so wird die Variable: "Entscheidung", gleich "e" gesetzt. Dies bewirkt ein Ende der While-Schlaufe.

Der Benutzer wird im Dialog aufgefordert, eine Zahl einzugeben. Das Programm prüft, ob die
eingegebene Zahl im gültigen Wertebereich liegt.

/*
Titel: Eingabeprüfung
Datei eingabeprüfung.cpp
Autor: Jonathan Ernst
Datum: 08.07.2011
 Rev : 1.2

Funktion:
Eingabeprüfung: Der benutzer wird im Dialog aufgefordert,
eine zahl einzugeben. Das Programm prüft, ob die
eingegebene Zahl im gültigen Wertebereich liegt.

*/
#pragma hdrstop                                      //compiler anweisung
#pragma argsused                                     //compiler anweisung
#include                                    //Biblioothek Tastatur laden
#include                                    //Bibliothek I/O laden
#include                                     //Bibliothek math laden


//-------------------------------------------------------------------------------------------
int main(void)                                    //aufruf funktion hauprprogramm
{
float eingabe = 0;                                //Deklaration Variable eingabe
float wertebereichvon = 100;                      //Deklaration Variable wertebereich von
float wertebereichbis = 1000;                     //Deklaration Variable wertebereich bis
char entscheidung = 'a';                                    //Deklaration variable exit
char scan = 'a';                                    //Deklaration variable scan


while(entscheidung != 'e' )
{
printf("\nGeben sie ihre Zahl ein: ");
scanf("%f", &eingabe);                    //Texteingabe

if ((eingabe > wertebereichvon)&&(eingabe < wertebereichbis))
{
printf(" Die Zahl wurde akzeptiert!");
getch();
entscheidung = 'e';
}
else
{
printf("\nerror - bitte zahl nocheinmal eingeben." );
getch();
entscheidung = 'o';
}

getch();

}
return(0);

}

Der Compilierte Code :

C - Zeitungspapier zum Mond

Das Programm:
Berechnen Sie wie viele Faltungen mit Zeitungspapier der Dicke 0.05 mm notwendig sind, damit die papierstapelhöhe der Distanz Mond - Erde entspricht. ca.(384'000 km)

/*
Titel: Zeitungspapier
Datei zeitungspapier.cpp
Autor: Jonathan Ernst
Datum: 01.07.2011
Rev.1.1

Funktion:
Berechnen Sie wie viele Faltungen mit Zeitungspapier
der Dicke 0.05 mm notwendig sind, damit die papierstapelhöhe
der Distanz Mond - Erde entspricht. ca.(384'000 km)

*/
#pragma hdrstop                                      //compiler anweisung
#pragma argsused                                     //compiler anweisung
#include                                    //Biblioothek Tastatur laden
#include                                    //Bibliothek I/O laden
#include                                     //Bibliothek math laden


//-------------------------------------------------------------------------------------------
int main(void)                                         //aufruf funktion hauprprogramm
{
   double distanz = 384000000000;                        //Deklaration variable distanz Mond-Erde
   float zahler = 0;                                   //Deklaration variable zahler
   double dicke = 0.05;                                    //Deklaration variable dicke

while ( dicke<=distanz)                         //while schlaufe, solange dicke kleiner oder gleich distanz ist ist.

{
    dicke = dicke * 2;                     
     zahler++;                          //berechnung zahler

}

printf("Ein Zeitungspapierst\201ck muss %.0f mal gefaltet werden,\nbis es die Distanz Mond->Erde erreicht. ", zahler);      //textausgabe
getch();                                                  //warte auf enter

   return(0);                                                //ende
}

Der Compilierte Code :

C - simple programs
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!

C - Maximum Minimum Durchschnitt berechnen

Das Programm:
Das bestimmen des höchsten und des kleinsten Wertes einer beliebig langen Zahlen Reihe ist eine der drei Aufgaben welche das unten-stehende Programm ausführen kann.

Als Zusatz wurde ihm die Fähigkeit verliehen aus den gegebenen Zahlen den Durchschnitt und die  Summe zu berechnen. Außerdem kann es sich merken wie viele Zahlen eingegeben wurden.

/*----------------------------------------------------------------------------------------------------
Titel: MinMax & Durchschnitt & Fakultät
Datei: minmax.cpp
Autor: Jonathan Ernst
Datum: 28.09.2011
Funktion: Ein Programm welches die höchste und die tiefste Zahl sowie den Durchschnitt
einer beliebig langen Zahlen-Reihe ermittelt 
--------------------------------------------------------------------------------------------*/
#include   //Bibliothek Tastatur laden
#include   //Bibliothek I/O laden
#include   //Bibliothek math laden

float minimum(float a, float min) //Funktion zur Bestimmung der kleinsten Zahl
{
if (a < min)                  //wenn a kleiner als das Minimum ist     
min = a;               //wird das Minimum = a gesetzt     
return(min);                  //das Minimum wird zurück gegeben. 
} 
float maximum(float a, float max) //Funktion zur Bestimmung der grössten Zahl 
{       
 if (a > max)               //wenn a grösser als das Maximum ist
max = a;                   //wird das Maximum = a gesetzt
return(max);               //das Maximum wird zurückgegeben
}
float durch(float summe, float counter) //Funktion zur Berechnung des Durchschnittes
{     
float durchschnitt = summe/counter; // durchschnitt wird berechnet in dem man die Summe aller Zahlen geteilt durch die Anzahl der Zahlen rechnet.
return(durchschnitt);               //der durchschnitt wird zurückgegeben
}


int main(void)                 //das Hauptprogramm
{

float a = 0;              //definition der Variable a
float min = 1000000;      //definition der Variable min
float max= 0;             //definition der Variable max
int counter = 0;          //definition der Variable counter
float durchschnitt = 0;   //definition der Variable durchschnitt
char loop = 'a';          //definition der Variable loop
float summe = 0;          //definition der Variable summe

do                        //start der do- while Schlaufe
{         counter++;      //zählt die Anzahl Schleifen durchgänge und somit auch die Anzahl der eingegebenen Zahlen
printf("Geben sie eine Zahl ein: "); //Textausgabe
scanf("%f",&a);                      //Texteingabe
min = minimum(a,min);                //Aufruf der Funktion zur bestimmung der kleinsten Zahl
max = maximum(a,max);                //Aufruf der Funktion zur bestimmung der grössten Zahl
summe = summe +a;                    //Berechnung der Summe
durchschnitt = durch(summe, counter);//Aufruf der Funktion zur bestimmung des Durchschnittes
printf("Wollen sie eine  neue Zahl eingeben? j/n :"); //Textausgabe
fflush(stdin);                       // löscht den tastatur puffer
loop = getchar();                    //liest zeichen ein, um Schleife zu beenden

}while (loop != 'n');                          //entscheidet wie viele male die Schleife durchgeführt werden soll.

printf("\nMin\t\t= %.2f\nMax\t\t= %.2f\nSumme\t\t= %.2f\nAnzahl Zahlen\t: %i\nDurchschnit\t= %.2f",min,max,summe,counter,durchschnitt); //Textausgabe
getch();//damit das Fenster noch offen bleibt
return 0;//gibt 0 zurück
}//ende

Der Compilierte Code/ The compiled Code:

C - simple programs --------------------------------------------------------------------------------- Captain Malgardi Malgardis Crew become a fan on Facebook : Malgardi Fan!

C - Sinuskurve zeichnen

Die Sinuskurve:

Eine Sinuskurve entsteht wenn, man, am Rand einer Runden Scheibe einen Bleistift befestigt und die Scheibe dreht, während dem sie sich auf einer geraden Linie fortbewegt. Durch diese Bewegung entsteht eine Sinusähnliche Kurvenform. Diese Lässt sich auch berechnen. Das in C geschriebene Programm zeichnet eine Sinuskurve im Konsolenfenster.
 















------------------------------------------------------------------------------------------------
Zur berechnung des Sinus wird der befehl a=sin();, aus der Bibliothek <math.h> verwendet.

/*----------------------------------------------------------------------------------------------------
Titel: Sinuskurve
Datei: Sinuskurve.cpp
Autor: Jonathan Ernst
Datum: 27.09.2011
Funktion: Das Programm zeichnet eine Sinus Kurve
--------------------------------------------------------------------------------------------*/
#include   //Bibliothek Tastatur laden
#include   //Bibliothek I/O laden
#include   //Bibliothek math laden
#include 
#define PI 3.14159          //definiere PI


void sinus(int hohe, int anzahl) // Unterprogramm welches die Sinus Kurve zeichnet.
{
int Matrix[700][700];            // erstellt eine Matrix der grösse 700x700
int x,y,z = 0;                   // definition der variabeln x.y.z werden für die For schlaufen benötigt.
float wert = 0;                  //definition Variable wert = 0 wird zur berechnung des Sinus verwendet
int ss = 0;                      //definition Variable ssbestimmt die x achse der Matrix
for( z = 0; z < anzahl;z++)        //bestimmt wie vielmal die Sinuskurve gezeichnet wird

{
 for(ss=0;ss < (hohe*2);ss++)      //bestimmt anzahl spalten
 {
                 
  for(y=0;y < 360;y++)             //bestimmt vieviel mal die Rechnung des Sinus durchgeführt werden soll. 360 = ein Kreis
    {
     wert=sin((y*2*PI)/(360));   //berechnung des Sinus wertes
     wert=wert*hohe;             //den Wert des Sinus wird an die höhe der Matrix angepasst
     if (wert == wert)           // wert in integer umformen
     ss = wert+hohe;             // wert in integer umformen + die höhe
    Matrix[y][ss]=88888;         //zeichnet 88888 an jeweiliger position welche durch den Wert des sinus bestimmt wird.     
    }
      for(y=0;y<360;y++)         //bestimmt die länge des Matrix ( 360 Zeilen)
        {
          for(ss=0;ss<(hohe*2+1);ss++)  //bestimmt die höhe des Matrix
           {
               printf("%3d ",Matrix[y][ss]); //zeichnet den Matrix
            }
            printf("\n"); //Zeilen umschlag
        }
   }
}
}

int main(void) //hauptprogramm
{
    int hohe = 0;     //defonition Variable Höhe
    int anzahl = 0;   //definition Variable anzahl
    char exit = 'a';  //definition Variable a
     do               //do schlaufe, um das Programm zu wiederholen
    {
    printf("Welche höhe soll die Sinus Kurve haben? (z.bsp 50) : "); //Textausgabe
    scanf("%i", &hohe); //Texteingabe
    printf("Wie viele male soll der Sinus gezeichnet werden? : ");//Textausgabe
    scanf("%i",&anzahl);//Texteingabe
    sinus(hohe,anzahl); //Aufruf des unterprogrammes welches den Sinus zeichnet
    getch(); //wartet auf enter taste
    printf("Wollen sie einen weiteren Sinus Zeichnen? j/n");//Textausgabe
    fflush(stdin); //löscht tastatur puffer
    exit = getchar(); //liest buchstaben ein
} while (exit !='n'); // bestimmt ob Programm wiederholt werden soll oder nicht

    return (0);//gibt 0 zurück
}//ende

Der Compilierte Code/ The compiled Code:

 

Einstellungen im Konsolenfenster:

- Schriftart ganz klein.
- Anzahl Zeilen und Spalten auf maximum schalten.
So kann die "Auflösung" vergrössert werden. !

C - simple programs --------------------------------------------------------------------------------- Captain Malgardi Malgardis Crew become a fan on Facebook : Malgardi Fan!

C - Dezimal Hexadezimal Wandler

Das Programm:
Eine über die Tastatur eingelesene natürliche Zahl ist einer Funktion zu übergeben,
die eine Umwandlung in den Hex-Code vornimmt.

/*
Titel: Dezimal-Hex-Wandler
Datei dezhex.cpp
Autor: Jonathan Ernst
Datum: 19.09.2011

Funktion:
Eine über die Tastatur eingelesene natürliche Zahl ist einer Funktion zu übergeben,
die eine Umwandlung in den Hex-Code vornimmt.
*/
#include 
#include 
#include 
#include 
#include 
//-------------------------------------------------------------------------------------------
char result[100];      // Bestimmt eine Zeichenkette result mit 100 Speicherplätzen

void dechex (int deci) // Funktion dechex
{
//bestimmen der Variablen:

int zahl = 1;          //definition Variable zahl
int rest = 0;          //definition Variable rest
int counter = 0;       //Definition Variable counter, zählet +
int counterminus = 1;  //definition Variable counterminus, zählt minus
int x = 0;             //definition Variable x
int decim = deci;      //definition variable decim = deci, übernimmt den Wert der dezimalzahl.

strcpy(result," ");    //setzt den String result = 0

while (zahl !=0)        //Erste while schlaufe zur berechnung der Anzahl stellen welche die Hexzahl haben wird.
{
zahl = decim/16;        //Berechnet: beispiel: dezimal Zahl 77 : 16 = 4, 4 wird in Variable Zahl gespeichert.
rest = decim - (zahl*16);//berechnet den Restwert. : 77-(4*16)=77-64=13
decim = zahl;            //die Zahl 13 währe die höchstwertige ziffer der hex-zahl
counter++;               //zählt die anzahl Zyklen
}
counterminus = counter;   // counterminus wird mit counter gleichgesetzt, counterminus wird benützt um die Reihenfolge der hex-Ziffern zu bestimmen.
zahl = 1;                 // setzt zahl wieder gleich 1

while (zahl !=0)          //zweite Schleife, Jetzt werden die erhaltenen Werte in einem String (result) gespeichert.
{
zahl = deci/16;             //Berechnet: beispiel: dezimal Zahl 77 : 16 = 4, 4 wird in Variable Zahl gespeichert.
rest = deci - (zahl*16);    //berechnet den Restwert. : 77-(4*16)=77-64=13
deci = zahl;                //die Zahl 13 währe die höchstwertige ziffer der hex-zahl

if (rest == 0)                //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='0'; } // beim ersten Durchgang hat Counterminus den höchsten wert, somit wird die Ziffer auf die Letzte stelle geschrieben.

if (rest == 1)                //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='1'; } // beim zweiten durchgang wird die zweitletzte stelle beschrieben.

if (rest == 2)                //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='2'; }  //schreibt den Wert 2 in string Result an angegebener (counter minus) stelle

if (rest == 3)                //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='3'; } //schreibt den Wert 3 in string Result an angegebener (counter minus) stelle

if (rest == 4)                //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='4'; } //schreibt den Wert 4 in string Result an angegebener (counter minus) stelle

if (rest == 5)               //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='5'; }//schreibt den Wert 5 in string Result an angegebener (counter minus) stelle

if (rest == 6)               //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='6'; }//schreibt den Wert 6 in string Result an angegebener (counter minus) stelle

if (rest == 7)               //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='7'; }//schreibt den Wert 7 in string Result an angegebener (counter minus) stelle

if (rest == 8)               //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='8'; } //schreibt den Wert 8 in string Result an angegebener (counter minus) stelle

if (rest == 9)               //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='9'; }//schreibt den Wert 9 in string Result an angegebener (counter minus) stelle

if (rest == 10)              //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='A'; } //schreibt den Wert A in string Result an angegebener (counter minus) stelle

if (rest == 11)             //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{result[counterminus]='B'; }//schreibt den Wert B in string Result an angegebener (counter minus) stelle

if (rest == 12)            //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{result[counterminus]='C'; }//schreibt den Wert C in string Result an angegebener (counter minus) stelle

if (rest == 13)             //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{ result[counterminus]='D'; } //schreibt den Wert D in string Result an angegebener (counter minus) stelle

if (rest == 14)             //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{result[counterminus]='E'; }//schreibt den Wert E in string Result an angegebener (counter minus) stelle

if (rest == 15)             //  wenn der rest = null wäre würde diese Ziffer angezeigt.
{result[counterminus]='F'; } //schreibt den Wert F in string Result an angegebener (counter minus) stelle

counterminus--;             // zählt runter.
}
printf("%s",result);        //schreibt das Resultat!! in hex, string result

}

int main(void)               //Aufruf

{
int dec = 0; //Deklaration Variable dec
char exit = 'a';

while ( exit != 'n')
{ 
printf("\n Bitte geben Sie eine Dezimal Zahl ein: "); //Ausgabe Text
scanf("%i",&dec); // Texteingabe

printf("\n %i schreibt man in Hexadezimalsystem so: ", dec); //Ausgabe Text
dechex(dec); //Funktionsaufruf hexdec

printf("\nM\224chten sie eine andere Zahl umwandeln? j/n ");
fflush(stdin);
exit = getchar();
fflush(stdin);
} //warte
return 0; //ende
}

Der Compilierte Code/ The compiled Code:

C - simple programs --------------------------------------------------------------------------------- Captain Malgardi Malgardis Crew become a fan on Facebook : Malgardi Fan!

C - Vorzeichen bestimmen (+/-)

Das Programm:
Funktion:
Eine funktion sign soll einen übergebenen Wert (Typ float) testen und
folgendes zurückliefern:
Wert < 0 -> -1
Wert = 0 -> 0
Wert > 0 -> +1

/*
Titel: Funktion 1
Datei funkt1.cpp
Autor: Jonathan Ernst
Datum: 09.09.2011
 Rev : 1.0
Funktion:
Eine funktion sign soll einen übergebenen Wert (Typ float) testen und
folgendes zurückliefern:
Wert < 0 -> -1
Wert = 0 ->  0
Wert > 0 -> +1
*/
#pragma hdrstop                                      //compiler anweisung
#pragma argsused                                     //compiler anweisung
#include                                    //Biblioothek Tastatur laden
#include                                    //Bibliothek I/O laden
#include                                     //Bibliothek math laden
//-------------------------------------------------------------------------------------------

int sign(float a)                                  //deklaration des Unterprogrammes sign
{
int bestimmung = 0;                 //Deklaration Variable bestimmung

if(a < 0)                           //if abfrage
    bestimmung = -1;

if(a > 0)                           //if abfrage
    bestimmung = 1;

if(a == 0)                         //if abfrage
    bestimmung = 0;

return(bestimmung);                 // gibt das Resultat der if abfrage zurück
}
int main (void)                    //Hauptprogram
{
float wert = 0;                    //Deklaration Variable
int ausgabe = 0;                   //Deklaration Variable
char exit = 'a';                   //Deklaration variable exit
char scan = 'a';                   //Deklaration variable scan

while ( exit != 'n')                         //while schlaufe, solange exit nicht = f ist.
 {


printf("\nGuten Tag, bitte geben sie eine Zahl ein: ");     //Textausgabe
scanf("%f", &wert);                                        //texteingabe
ausgabe = sign(wert);                                    //Aufruf Funktion sign

if(ausgabe > 0)                                         // bestimmt das vorzeichen + bei der ausgabe
printf("Dazu sage ich nur +%i!", ausgabe);
else
printf("Dazu sage ich nur %i!", ausgabe);              // wenn die ausgabe kein plus hat.

getch();

printf("\n\n\nM\224chten sie eine weiter Zahl anzeigen? j/n ");   //textausgabe
scanf("%1s", &scan);                                       //Texteingabe
exit = scan;                                                // setze exit = scan
}
}

Der Compilierte Code/ The compiled Code:

C - simple programs
---------------------------------------------------------------------------------
Captain MalgardiMalgardis Crewbecome a fan on Facebook : Malgardi Fan!

Textrahmen im C zeichnen

Das Programm:
Funktion: Einer Funktion sollen die Koordinaten (x1,y1,x2,y2) übergeben werden.
Die Funktion soll daraus einen Textrahmen der entsprechenden Position und Grösse zeichnen.

/*----------------------------------------------------------------------------------------------------
Titel: Funkt (7) Textrahmen
Datei: textramen.cpp
Autor: Jonathan Ernst
Datum: 14.09.2011
Funktion: Einer Funktion sollen die Koordinaten (x1,y1,x2,y2) übergeben werden.
Die Funktion soll daraus einen Textrahmen der entsprechenden Position und Grösse zeichnen.
--------------------------------------------------------------------------------------------*/
#include   //Bibliothek Tastatur laden
#include   //Bibliothek I/O laden
#include   //Bibliothek math laden

int textramen(int xabstand,int yabstand,int xbreite,int ylange)  //Unterprogramm zur Berechnung des Bogenmasses
{
    int x = 0;    // Deklaration Variable x dient als Zähler
    int y = 0;    // Deklaration Variable y dient als Zähler
    int z = 0;    // Deklaration Variable z dient als Zähler

 if((xabstand < (68-xbreite))&&(xbreite > 2)&&(xbreite < 68))  //kontrolliert die Korrektheit der eingegebenen Zahlen
 {
  for (x=0; x < yabstand; x++)               // bestimmt y1 Koordinate
    printf("\n");                                      // geht eine Zeile runter

  for (x=0; x < xabstand; x++)               // bestimmt x1 Koordinate
    printf(" ");                                        // zeichnet lehrschlag

    printf("\311");                                   // zeichnet Zeichen ?

  for (x=2; x < xbreite; x++)                    // widerholt die printf Anwendung  x2 mal
    printf("\315");                                    // zeichnet Zeichen ?


    printf("\273\n");                                 // zeichnet Zeichen ?

  for (x=2; x < ylange; x++)                    // wiederholt die Zeichnung der ? Symbole y2 mal
    {

      for (y=0; y < xabstand; y++)             // bestimmt den  Abstand x1
        printf(" ");                                      // zeichnet lehrschlag

        printf("\272");                                // zeichnet Zeichen ?

      for ( z=2; z < xbreite; z++)    // bestimmt den Abstand zwischen ?
        printf(" ");                                      // zeichnet lehrschlag

        printf("\272\n");                             // zeichnet Zeichen ?

    }
  for (x=0; x < xabstand; x++)                 // bestimmt x1 Koordinate
    printf(" ");                                          // zeichnet lehrschlag

    printf("\310");                                     // zeichnet Zeichen ?

  for (x=2; x < xbreite; x++)                    // wiederholt die printf Anwendung  x2 mal
    printf("\315");                                    // zeichnet Zeichen ?

    printf("\274");                                   // zeichnet Zeichen ?
      }

else
   printf("\n\232berpr\201fen Sie ihre Eingabe.\nBeachten Sie diese Werte:\n (x1 = position x) nicht gr\224sser als 68 und (68 - x2)\n (x2 = breite) min. 2, max. 68.\n");    // wenn die eingegebenen Zahlen nicht den Vorgaben entsprechen kommt dieser Text. 
                               
}
 
int main(void)                 //Aufruf Funktion Hauptprogramm
{        //Beginn Hauptprogramm
int x1 = 0;   //Deklaration Variable x1
int x2 = 0;  //Deklaration Variable x2
int y1 = 0;  //Deklaration Variable y1
int y2 = 0; //Deklaration Variable y2
int change = 0;

printf("\n Bitte geben Sie die Koordinaten ein:\n x1, y1 (position), x2, y2 (gr\224sse). :");  //Ausgabe Text
  scanf("%i,%i,%i,%i",&x1,&y1,&x2,&y2);                               // Texteingabe
printf("\n Bitte geben Sie eine belibige Zahl ein: ");  //Ausgabe Text
  scanf("%i",&change);

  for ( int i = 0; i < change; i++)
{
textramen(x1,y1,x2,y2);
gotoxy(x1=x1-2,y1++);
}
              //Funktionsaufruf textramen
 
fflush(stdin);                                             //Tastaturpuffer lehren.
getch();                  //warte
return 0;                  //ende
}

Der Compilierte Code/ The compiled Code:

C - simple programs --------------------------------------------------------------------------------- Captain Malgardi Malgardis Crew become a fan on Facebook : Malgardi Fan!

C - Spannungsteiler / Voltage divider

Das Programm

Berechnen sie die Ausgangsspannung eines belasteten Spannungsteilers bei 10 Positionen.

Calculate UL of an Voltage divider in 10 positions.

Rges = R1 + ((R2 * RL)/(R2 + RL))
Iges = Uo / Rges
U1 = R1 * Iges
U2 = Uo - U1

/*----------------------------------------------------------------------------------------------------
Titel: Spannungsteiler
Datei: spannungsteiler.cpp
Autor: Jonathan Ernst
Datum: 31.08.2011
Funktion: Berechnen sie die Ausgangsspannung eines belasteten Spannungsteilers bei 10 Positionen.
--------------------------------------------------------------------------------------------*/
#include //Bibliothek Tastatur laden
#include //Bibliothek I/O laden
#include //Bibliothek math laden

int main(void) //Aufruf Funktion Hauptprogramm

{ //Beginn Hauptprogramm

float Uo = 0; //Deklaration Variable Spannung Uo
float U1 = 0; //Deklaration Variable Spannung U1
float U2 = 0; //Deklaration Variable Spannung U2
float Rges = 0; //Deklaration Variable Gesammt Widerstand
float R1 = 0; //Deklaration Variable Wiederstand R1
float R2 = 0; //Deklaration Variable Wiederstand R2
float RL = 0; //Deklaration Variable Lastwiederstand
float Iges = 0; //Deklaration Variable Gesammt Strom
float Rpoti = 0; //Deklaration Variable Wiederstand des Potentiometers
float Pot1 = 0; //Deklaration Variable Position Potentiometer
float Pot2 = 100; //Deklaration Variable invertierrt Position Potentiometer.
float step = 10;

printf("\n Bitte geben sie die Klemmenspannung Uo in V ein: "); //Ausgabe Text
scanf("%f",&Uo); //Daten einlesen

printf("\n Bitte geben sie den Widerstand des Potentiometers in Ohm ein: "); //Ausgabe Text
scanf("%f",&Rpoti); //Daten einlesen

printf("\n Bitte geben sie den Last-Widerstand in Ohm ein: "); //Ausgabe Text
scanf("%f",&RL); //Daten einlesen

for (Pot1 = Pot1; Pot1 < 110; Pot1 + step)
{
     Pot2 = Pot2 - Pot1;
     R1 = Rpoti * Pot1;
     R2 = Rpoti * Pot2;
     Pot2 = 100;
     Rges = R1 + ((R2 * RL)/(R2 + RL));
     Iges = Uo / Rges;
     U1 = R1 * Iges;
     U2 = Uo - U1;

     printf("\n Bei einer Position von %1.0f prozent betr\204gt die Spannung \201ber RL %0.2fV. ",Pot1, U2); //Ausgabe Text

     Pot1 = Pot1 + step;
}

getch(); //warte
return 0; //ende
}

Der Compilierte Code/ The compiled Code:

Bitte geben sie die Klemmenspannung Uo in V ein: 20
Bitte geben sie den Widerstand des Potentiometers in Ohm ein: 40
Bitte geben sie den Last-Widerstand in Ohm ein: 30

Bei einer Position von 0 prozent beträgt die Spannung über RL 20.00V.
Bei einer Position von 10 prozent beträgt die Spannung über RL 1.38V.
Bei einer Position von 20 prozent beträgt die Spannung über RL 0.72V.
Bei einer Position von 30 prozent beträgt die Spannung über RL 0.48V.
Bei einer Position von 40 prozent beträgt die Spannung über RL 0.36V.
Bei einer Position von 50 prozent beträgt die Spannung über RL 0.29V.
Bei einer Position von 60 prozent beträgt die Spannung über RL 0.24V.
Bei einer Position von 70 prozent beträgt die Spannung über RL 0.21V.
Bei einer Position von 80 prozent beträgt die Spannung über RL 0.18V.
Bei einer Position von 90 prozent beträgt die Spannung über RL 0.15V.
Bei einer Position von 100 prozent beträgt die Spannung über RL 0.00V.

C - simple programs --------------------------------------------------------------------------------- Captain Malgardi Malgardis Crew become a fan on Facebook : Malgardi Fan!

C - Erdradius / Earth radius berechen

Das Programm:
-Wie gross wäre der Abstand zwischen dem Erdumfang und einem 1m längeren Umfang, wenn man diese ineinander legen würde?
-How big would be the distance between earth's circumference and an 1m extended circumference if you would lay them into each other.

/*----------------------------------------------------------------------------------------------------
Titel: Erdradius
Datei: erdradiuse.cpp
Autor: Jonathan Ernst
Datum: 07.06.2011
Funktion: Erdradius Formeln
--------------------------------------------------------------------------------------------*/
#include   //Bibliothek Tastatur laden
#include   //Bibliothek I/O laden
#include   //Bibliothek math laden

int main(void) //Aufruf Funktion Hauptprogramm
{         //Beginn Hauptprogramm
float Umfanggeg = 0;   //Deklaration Variable Umfang Gegeben
float Eingabe1 = 0;    //Deklaration Variable Eingabe1
float Umfangges = 0;   //Deklaration Variable Umfang Gesucht
float Radius1 = 0;    //Deklaration Variable Radius Gegeben
float Radius2 = 0;    //Deklaration Variable Radius Gesucht
float Differenz = 0;   //Deklaration Variable Resultat (Differenz)

printf("\n Bitte geben sie den Umfang in km ein : ");  //Ausgabe Text
  scanf("%fkm",&Umfanggeg);        //Daten einlesen

printf("\n Bitte geben sie den Abschnit den sie dem \n Umfang beifuegen moechten in km ein: ");  //Ausgabe Text
  scanf("%fkm",&Eingabe1);        //Daten einlesen

Umfangges = Umfanggeg + Eingabe1;         //ADDITION von Unfanggeg und Eingabe 1
printf("\n Der urspruengliche Umfang1 ist: %0.2fkm \n",Umfanggeg);   //Ausgabe Text
printf("\n Sie haben dem Umfang %fkm zugefuegt.\n",Eingabe1);   //Ausgabe Text
printf("\n Jetzt betraegt der Umfang2 %0.3fkm.\n",Umfangges);    //Ausgabe Text

Radius2 = Umfanggeg / (2 * 3.141592);      //Radius 1 berechnen. 
Radius1 = Umfangges / (2 * 3.141592);      //Radius 2 berechnen.
Differenz = Radius1 - Radius2;      //Differenz von Radius 1 und 2 Berechnen

printf("\n Der Abstand zwischen Umfang1 und Umfang2 betraegt %0.5fkm.\n", Differenz);   //Ausgabe Text

getch();           //warte
return 0;            //ende
}

Der Comilierte Code/ the compiled code:

It doesn't matter how big the circumference of an object is, what matters is that you extend the circumference of the second object by the same amount.

If you extend a random circumference with 1m you'll allways get 0.15898cm. Try it, you'll see!

Es ist egal mit welchem Umfang man rechnet, das entscheidende ist die Differenz. Verändert man die Grösse um welche man einen zweiten Umfang erweitert verändert sich auch der Abstand der beiden Kreise.


C - simple programs
---------------------------------------------------------------------------------
Captain MalgardiMalgardis Crewbecome a fan on Facebook : Malgardi Fan!

C - Altgrad in Bogenmass umrechnen

Das Programm:
Codieren Sie die Funktion "Altgrad_Bogen", die einen Winkel vom Gradmass ins Bogenmass umrechnet.
Code the function "Altgrad_Bogen", which converts an angle from degrees into radiants.

/*----------------------------------------------------------------------------------------------------
Titel: Funkt (4) Winkel
Datei: winkel.cpp
Autor: Jonathan Ernst
Datum: 14.09.2011
Funktion: Codieren Sie die Funktion "Altgrad_Bogen", die einen Winkel vom Gradmass ins Bogenmass umrechnet.
--------------------------------------------------------------------------------------------*/
#include   //Bibliothek Tastatur laden
#include   //Bibliothek I/O laden
#include   //Bibliothek math laden
#define PI 3.14159          //definiere PI

float Altgrad_Bogen( float a )  //Unterprogramm zur berechnung des Bogenmasses
{
    a = (a * 2 * PI)/360;           // Berechnung des bogenmasses Winkelmass = 2 * PI (Bogenmass)
    return(a);                //gibt den Wert von a (bogenmass) zurück
}

int main(void)                 //Aufruf Funktion Hauptprogramm
{        //Beginn Hauptprogramm
float altgrad = 0;   //Deklaration Variable altgrad
float bogenmass = 0;  //Deklaration Variable bogenmass
char exit = 'a';                   //Deklaration variable exit


while ( exit != 'n')                         //while schlaufe, solange exit nicht = f ist.
 {

printf("\n Bitte geben Sie einen Winkel an: ");  //Ausgabe Text
  scanf("%f",&altgrad);                               // Texteingabe

bogenmass = Altgrad_Bogen(altgrad);                 //Funktionsaufruf Altgrad_Bogen

printf("\n Das Bogenmass des Winkels betr\204gt: %0.2f rad \n", bogenmass);   //Ausgabe Text
fflush(stdin);                                             //Tastaturpuffer lehren.
getch();                  //warte
printf("\n\n\nM\224chten sie eine weiter Zahl anzeigen? j/n ");   //textausgabe
exit=getchar();

}
return 0;                  //ende
}

Der Compilierte Code/ The compiled Code:

C - simple programs
---------------------------------------------------------------------------------
Captain MalgardiMalgardis Crewbecome a fan on Facebook : Malgardi Fan!

C - Durchschnitt / Average bestimmen

Das Programm:
Develop a Programm to calculate an the average of an undefined long row of numbers.
Entwickeln Sie ein Programm, das den Durchschnitt einer unbestimmt langen Zahlenreihe berechnet.

#include 

/*
Titel: durchnschnitt
Datei durchschnitt.cpp
Autor: Jonathan Ernst
Datum: 01.07.2011


Funktion:
Entwickeln Sie ein Programm, das den Durchschnitt einer
unbestimmt langen Zahlenreihe berechnet.

*/
#pragma hdrstop                                      //compiler anweisung
#pragma argsused                                     //compiler anweisung
#include                                    //Biblioothek Tastatur laden
#include                                    //Bibliothek I/O laden
#include                                     //ibliothek math laden


//-------------------------------------------------------------------------------------------
int main(void)                                         //aufruf funktion hauprprogramm
{
   char exit = 'a';                                    //Deklaration variable exit
   char scan = 'a';                                    //Deklaration variable scan
   float eingabe = 0;                                  //Deklaration variable eingabe
   float zahler = 0;                                   //Deklaration variable zahler
   float summe = 0;                                    //Deklaration variable summe
   float ubertrag = 0;                                 //Deklaration variable ubertrag
   float result = 0;                                   //Deklaration variable result
   

    printf("Um den Durchschnitt einer unbestimmt \nlangen Zahlenreihe zu berechnen, \nm\201ssen sie nun einige Zahlen eingeben.\n");    //ausgabe Text

do
{
    do  
   {    printf("\nGeben sie eine Zahl ein: ");       //Textausgabe
           scanf("%f", &eingabe);                    //Texteingabe

       summe = ubertrag + eingabe;                    //berechnung summe
       ubertrag = summe;                              //berechnung
       zahler = zahler+1;                             //erechnung zähler


       printf("\n\nDr\201cken sie 1 um eine neue Zahl einzugeben,\noder 2 f\201r Berechnung des Durchschnittes.\n ");    //Textausgabe
       fflush(stdin);
       exit = getchar();
}while ( exit != '2');                       //while schlaufe, solange exit nicht = f ist.

result = summe / zahler;                             //berechnung resultat

printf("\n\n\nDer Durchschnitt der eingegebenen Zahlen ist : %0.2f ", result);      //textausgabe
getch();                                                  //warte auf enter

printf("\n\n\nM\224chten sie einen weiteren Durchschnitt berechnen? j/n ");   //textausgabe
fflush(stdin);
exit = getchar();                                         // setze exit = scan

eingabe = 0;                                                // setze eingabe = 0
zahler = 0;                                                 // setze zahler = 0
summe = 0;                                                  // setze summe = 0
ubertrag = 0;                                               // setze uertrag = 0
result = 0;                                                 // setze result = 0
}while ( exit != 'n');                         //while schlaufe, solange exit nicht = f ist.
return(0);                                                //ende
}

Der Compilierte Code :

C - simple programms
---------------------------------------------------------------------------------
Captain Malgardi
Malgardis Crew
become a fan on Facebook : Malgardi Fan!