Zur Zeit wird gerade in Informatik bei uns programmiert. Und da dachte ich, es wäre doch nett, häufige Funktionen hier mal abzudrucken. Deshalb der kleine Aufwand. Ich hoffe es hilft einigen weiter. Teilweise sind die Funktionen selbst geschrieben, aber auch aus vorhandener Literatur sind die Quellcodes übernommen. Und dann sidn natürlich auch fertige Aufgaben mit dabei.
J. Dankert: C-Tutorial; FH Hamburg
long unsigned int quersum(long unsigned int zahl)
{
long unsigned int a, b, summe;
a = b = summe = 0;
do{
a = zahl / 10; // Gibt ganzzahligen Anteil der Division zurück, weil a eine Ganzzahl ist
b = zahl % 10; // Gibt Rest der Division zurück z.B. 123 / 10 = 12 Rest 3; 3 ist Ergebniss
zahl = a;
summe = summe + b;
}while (a != 0);
return summe;
}
// benötigt #include <MATH.H>
// x Wert und Genauigkeit z.B. eps = 0.0001 übergeben
// liefert den Sinus von x mit einer Genauigkeit von eps zurück
// Bogenmaß
sinus(double x, double eps)
{
double y,a;
int i;
y=0;
a=x;
i=0;
do{
y=y+a;
i=i+2;
a=(-a)*(x*x)/(i*(i+1));
} while (fabs(a) > eps);
return y;
}
// benötigt #include <MATH.H>
// x Wert und Genauigkeit z.B. eps = 0.0001 übergeben
// liefert den Cosinus von x mit einer Genauigkeit von eps zurück
// Bogenmaß
cosinus(double x, double eps)
{
double y,a;
int i;
y=0;
a=1;
i=0;
do{
y=y+a;
i=i+2;
a=(-a)*(x*x)/(i*(i-1));
} while (fabs(a) > eps);
return y;
}
Hier ist ein komplette Programm, mit dem man zwei Matrizen eingeben und addieren kann. Die Größe läßt sich im Kopf unter zeilen und spalten einstellen
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <conio.h>
#include <math.h>
//------------------------------------------------------------
#define zeilen 3
#define spalten 3
#pragma argsused
int main(int argc, char* argv[])
{
double mat_A[zeilen][spalten], mat_B[spalten][zeilen], mat_C[spalten][zeilen];
int z,s;
cout << "Matrix A eingeben:\n";
for (z=0;z<zeilen;z++)
for (s=0;s<spalten;s++)
{
cout << "Geben Sie den Wert fuer Zeile " << z+1 << " und Spalte " << s+1 << " ein.\n";
cin >> mat_A[z][s];
}
cout << "Matrix B eingeben:\n";
for (z=0;z<zeilen;z++)
for (s=0;s<spalten;s++)
{
cout << "Geben Sie den Wert fuer Zeile " << z+1 << " und Spalte " << s+1 << " ein.\n";
cin >> mat_B[z][s];
}
for (z=0;z<zeilen;z++)
{
for (s=0;s<spalten;s++)
{
mat_C[z][s]=mat_A[z][s]+mat_B[z][s];
cout.width(10);
cout.setf(ios_base::right,ios_base::basefield);
cout << mat_C[z][s];
}
cout << '\n';
}
//cout << mat_C[0][0] << mat_C[0][1] << mat_A[0][2] << '\n';
//cout << mat_C[1][0] << mat_C[1][1] << mat_A[1][2] << '\n';
//cout << mat_C[2][0] << mat_C[2][1] << mat_A[2][2] << '\n';
getch();
return 0;
}
//---------------------------------------------------------------------------
Und das gleiche noch einmal, diesmal etwas knapper formuliert
//---------------------------------------------------------------------------
#include <vcl.h>
#include <conio.h>
#include <iostream.h>
#include <math.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int z, s, i, j;
double a[10][10], b[10][10], c[10][10];
cout<<"wieviele Zeilen? ";
cin>>z;
cout<<"wieviele Spalten? ";
cin>>s;
cout<<"Eingabe Matrix A:"<<'\n';
for(i=1;i<=z;i++)
{for(j=1;j<=s;j++)
{cin>>a[i][j];}}
cout<<"Eingabe Matrix B:"<<'\n';
for(i=1;i<=z;i++)
{for(j=1;j<=s;j++)
{cin>>b[i][j];}}
cout<<"Ausgabe Matrix C=B+A :"<<'\n'<<'\n';
for(i=1;i<=z;i++)
{for(j=1;j<=s;j++)
{c[i][j]=a[i][j]+b[i][j];
cout<<c[i][j]<<" ";}
cout<<'\n';}
getch(); return 0;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <iostream.h>
#include <conio.h>
#include <math.h>
#define MAX 100
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
long double x[MAX],s=0, mittel = 0, summe = 0;
int n, m;
cout << "\nBitte Anzahl der Werte eingeben n= :";
cin >> n;
// Wenn mehr Werte eingegeben werden, als dürfen, dann abbrechen
if (n > MAX) return 1;
// Alle Wert Null machen
for (m=0;m<n;++m)
x[m]=0;
// Aller Werte abfragen
for (m=0;m<n;++m)
{
cout << "\nBitte Wert " << m +1 << " eingeben :? ";
cin >> x[m];
}
// Mittelwert errechnen
mittel = 0;
for (m=0;m<n;++m)
{
mittel = mittel + x[m];
}
mittel = mittel / n;
for (m=0;m<n;++m)
{
summe += (x[m] - mittel)*(x[m] - mittel);
}
s = sqrt( 1/(n-1)* summe );
cout << "\n\nDie Standartabweichung beträgt: " << sqrt( 1./((float) n -1) * summe);
getch();
return 0;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <math.h>
#include <iostream.h>
#include <conio.h>
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{double a,x0,x,d,eps;
cout<<"Radikand eingeben";
cin>>a;
if(a<0)cout<<"korrigieren!";
else{
cout<<"Startwert eingeben";
cin>>x0;
cout<<"Eps eingeben";
cin>>eps;
do{
x=(x0+a/x0)/2;
d= fabs(x-x0);
x0=x;
}
while(d>eps);
cout<<"Wurzel="<<x;
}
getch();return 0;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int liter;
double km, verbrauch;
cout<<"Wieviele Kilometer?";
cin>>km;
cout<<"Wieviele Liter?";
cin>>liter;
verbrauch=liter/km*100;
cout<<"Verbrauch"<<verbrauch;
getch();
return 0;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
#include <conio.h>
#include <iostream.h>
#include <vcl.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[])
{
int x, i, y;
do{
cout<<"Eine positive ganze Zahl eingeben:";
cin>>x;
}
while(x<0);
y=1;
for(i=1;i<=x;i++)
{y=y*i;
}
cout<<"x!="<<y;
getch();
return 0;
}
//---------------------------------------------------------------------------
#include <stdio.h>
double indouble ()
{
double x ;
int n ;
do {
n = scanf ("%lf" , &x) ;
while (getchar () != ’\n’) ;
if (n != 1)
{
printf ("Fehler! Neuer Versuch: ") ;
}
} while (n != 1) ;
return x ;
}
/* Die Funktion ’indouble’ liest einen ’double’-Wert ein und nutzt dabei
den Return-Wert von ’scanf’, der angibt, wieviel Werte tatsaechlich
eingelesen wurden. Da nur ein Wert angefordert wird, kann nur
der Return-Wert 1 akzeptiert werden.
Dies wird mit der Schleifenkonstruktion
do {
... <--- Schleifenrumpf
} while ( ... ) <--- Schleifenfuss
realisiert, die im Gegensatz zur ’while’-Schleife die Pruefbedingung
erst am Ende (im Schleifenfuss) hat und also mindestens einmal
durchlaufen wird.
Nach ’scanf’ wird mit der ’stdio’-Funktion getchar (liest ein einzelnes
Zeichen) in einer Schleife, die erst beim Erreichen von ’\n’ (Return)
endet, alles "weggelesen", was eventuell noch im Eingabepuffer
verblieben ist, der also bei der naechsten ’scanf’-Aktion zunaechst
garantiert leer ist.
Das "Weglesen" wird auch dann ausgefuehrt, wenn ’scanf’ mit dem
Return-Wert 1 meldet, dass ein Wert erfolgreich gelesen wurde, denn
auch in diesem Fall kann etwas im Eingabepuffer verblieben sein.
’scanf’ deutet naemlich jedes "Whitespace"-Zeichen (das sind neben
Return z. B. noch Leerzeichen oder die Tabulatortaste) als Ende eines
Wertes. Es ist also in jedem Fall Vorsicht geboten: Eine Eingabe
wie z. B. 21 456.4 wuerde als 21 gedeutet, der Rest bleibt im
Puffer (entweder bis zum naechsten ’scanf’ oder wie in ’indouble’ als
"Futter fuer while (getchar () != ’\n’) ;". */
// Gibt eine Abgefragte Ganzzahl zurück
// geändert aus indouble()
// Quelle: http://www.fh-hamburg.de/rzbt/dankert/c_tutor.html/
// Beschreibung C-Tutorial Seite 42
int inint ()
{
int x ;
int n ;
do {
n = scanf ("%d" , &x) ;
while (getchar () != '\n') ;
if (n != 1)
{
printf ("\nFehler! Ganze Zahl eingeben! Neuer Versuch: ") ;
}
} while (n != 1) ;
return x ;
}
#include <stdio.h>
#include <stdlib.h>
main ()
{
char instrn [100] ;
puts ("Eingabe und Abarbeitung eines System-Aufrufs") ;
puts ("============================================\n") ;
printf ("Betriebssystem-Befehl: ") ;
gets (instrn) ; /* ... liest String ein und ... */
system (instrn) ; /* ... uebergibt ihn an Kommandointerpreter */
puts ("Ende des Programms syscall") ;
return 0 ;
}
/* Programm comdline.c demonstriert die Uebernahme von Parametern
aus der Kommandozeile */
/* Dass ein Return-Wert einer C-Funktion einfach ignoriert werden kann,
wurde bereits mehrfach bemerkt (und im Abschnitt 3.13 genauer behandelt).
Eine Funktion kann jedoch auch die ihr uebergebenen Argumente ignorieren,
was in allen vorangegangenen ’main’-Funktionen praktiziert wurde (die
Klammern waren immer leer).
Tatsaechlich werden ’main’ vom Betriebssystem (genauer: Kommando-Interpreter)
ein Integer-Argument und ein String-Pointer-Array
uebergeben. */
#include <stdio.h>
main (int argc , char *argv [])
{
/* argc - Anzahl der Argumente in der Kommandozeile, mit der
das Programm gestartet wurde (dieser Wert ist
mindestens 1, weil immer der Programmname, mit dem
das Programm ja gestartet werden muss, als ein
Argument zaehlt).
argv - ... enthaelt argc Pointer auf Strings, die aus
der Kommandozeile entnommen wurden. Dabei kann der
Kommando-Interpreter durchaus modifizierend
mitgewirkt haben.
Im Regelfall zeigt argv[0] auf einen String, der dem
Programmnamen entspricht. Wenn weitere (durch Leer-zeichen
getrennte) Zeichenketten in der Kommandozeile
stehen, zeigen die Pointer argv[1] ... argv[argc-1]
auf entsprechende Strings. Zeichenketten in der
Kommandozeile, die in "Double-Quotes" eingeschlossen
sind, werden jeweils (auch wenn sie Leerzeichen oder
andere spezielle Zeichen enthalten) in einem String
erfasst. */
int i ;
printf ("Anzahl der Kommandozeilen-Parameter: %d\n" , argc) ;
for(i =0 ;i < argc ; i++)
printf ("Kommandozeilen-Parameter %d: %s\n" , i , argv [i]) ;
/* ... zeigt, was alles aus der Kommandozeile gelesen wurde. */
return 0 ;
}
/* Bei einem Sprach-Element, das mit dem Betriebssystem so eng zusammen-arbeitet
wie die Kommandozeilen-Auswertung, sind natuerlich einige
Besonderheiten zu erwarten:
* Der Kommando-Interpreter von DOS modifiziert den String, auf den
argv[0] pointert, immer so, dass der gesamte Pfad (einschliesslich
Laufwerksbezeichnung) ergaenzt wird, die C-Shell unter UNIX z. B.
// Funktione löscht den aktuellen Bildschirm mit Hilfe des DOS Befehls CLS
// benötigt stdlib.h
void clrscrn( void )
{
system("cls");
}