Zufallsdaten @ C++

Ganze und Gleitkomma-Zufallszahlen, Zeichen, Strings, ...

Die Erzeugung von Zufallszahlen ist fixer Bestandteil aller modernen Programmiersprachen. Diese Seite demonstriert einige rtypische Anwendungen von Zufallszaheln in C/C++
C/C++ Klassiker der modernen Programmiersprachen
Zufalls-Funktionen Konstante RAND_MAX, Funktionen rand() und srand()
Gleitkomma 0..z..1 Gleitkomma-Zufallszahlen im fixen Bereich 0..z..1
Gleitkomma (zmin,zmax) Gleitkomma-Zufallszahlen in einem beliebigen Bereich zmin..z..zmax
Normalverteilt Normal ('Gauss')-verteilte Gleitkomma-Zufallszahlen
Ganze Zahlen Ganze Zufalls-Zahlen in einem beliebigen Bereich izmin..iz..izmax
Zeichen und Strings Zeichen (Ziffern, Buchstaben, ...) und Strings aus beliebigen ASCII-Bereichen
Bibliothek Organisation der Funktionen in einer portablen Datei
Verwandte Themen Zufallszahlen

Standard Zufalls-Funktionen
● Der Standard Zufallszahlen-Generator befindet sich in der Library <math.h>
Er liefert Ganze Pseudo-Zufallszahlen im Bereich 0...z...RAND_MAX

● Die maximale Zufallszahl wird in der Library <stdlib.h> mit der globalen Makro-Konstanten RAND_MAX definiert. Der Wert beträgt in 32-Bit-Systemen meist (2^15)-1 = 32767 und wird hier lediglich ausgegeben, jedoch im Programm nicht verwendet.

● Vor Verwendung sollte man den Zufalls-Generator mit Funktion srand() einmalig initialisieren. Das Argument dieser Funktion bestimmt den Anfang der Pseudo-Zufallsfolge. Damit auch der Anfang halbwegs zufällig gewählt wird, verwendet man dazu normalerweise die → Funktion time() deren Rückgabe-Wert sich jede Sekunde ändert.

● Windows-Systeme liefern trotz Initialisierung meist gleiche oder ähnliche Zufalls-Folgen. Man kann das verhindern, wenn man - wie in den beiden abgeschalteten Zeilen - mindestens den ersten Zufallswert, manchmal die ersten 10..20 Zufallswerte einholt und verwirft.

● In der for-Schleife wird der ganzzahligen Variablen j bei jedem Durchlauf der Rückgabe-Wert des Zufalls-Generators = der Funktion rand() zugewiesen. Der Zahlwenwert liegt zwischen 0 und RAND_MAX 		C-Programm zur Demonstration einfacher Zufalls-Werte:
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main() {
int i,j;
printf("RAND_MAX=%d\n",RAND_MAX);
srand(time(NULL));
// j = rand();
// for(i=0;i<20;i++) {j=rand();}
for(i=0;i<10;i++) {
j = rand();
printf("%d, ",j);
}
printf("\n");
return 0;
}
Typische Ausgabe:
*
● Der erste vom Zufalls-Generator gelieferte Wert ist stark von der aktuellen Sekunde abhängig. Um diesen meist unerwünschten Effekt auszuschalten, kann man den ersten von Funktion gelieferten Wert verwerfen - im Beispiel durch Aktivierung der mit Kommentar-Zeichen // abgeschalteten Zeile. ● Dieser Zufalls-Generator genügt für alle typischen Anwendungen. Für hohe Ansprüche muss man einen anderen Zufalls-Generator programmieren oder aus einer Bibliothek laden. Man findet dazu im Internet zahlreiche Beispiele.
Die erzeugten Zufallszahlen sind im Intervall 0...RAND_MAX (pseudo)-gleichmäßig verteilt.
Beispiel: Die Wahrscheinlichkeit, dass eine Zufallszahl in der ersten Hälfte 0...RAND_MAX/2 liegt, ist genau gleich groß wie jene für die 2.Hälfte RAND_MAX/2...RAND_MAX, nämlich 50%. 		Alle weiteren auf dieser Seite vorgestellten Anwendungen leiten sich von dieser Grund-Form ab.
Zufallszahlen werden häufig zum Test von Programmen verwendet. Wenn dabei ein Fehler entdeckt wird, dann ist es sinnvoll, genau diese Folge von Zufallszahlen zu wiederholen, bis der Fehler entdeckt und beseitigt wurde.
In diesem Fall initialisiert man den Zufalls-Generator mit einer beliebigen konstanten Zahl, z.B. mit 123
Der Generator liefert danach bei wiederholter Verwendung immer die gleiche Folge von (Pseudo)-Zufallszahlen. 		Erzeugung immer der gleichen Zahlen-Folge von Pseudo-Zufallszahlen:
srand(123);
for(i=0;i<10;i++) {
j = rand();
printf("%d, ",j);
}

Gleitkomma-Zufallszahlen im Bereich   0..z..1
Die Zufalls-Generatoren vieler → Programmiersprachen liefern - anders als C/C++ - Gleitkomma-Zufallszahlen im Bereich 0..1
Beispiele:
Kalkulations-Programme (LibreOffice, OpenOffice, MS-Excel mit Funktion =ZUFALLSZAHL()
Basic (LibreOffice-Basic, Visual Basic, VBA), Java, Javascript, Perl, PHP, Python, SQL, ... 		Daher sind viele Algorithmen und praktische Beispiele auf derartige Zufallszahlen zugeschnitten.
Das Beispiel unten demonstriert ihre Erzeugung mit einer C/C++ Funktion.
● Zunächst werden die für Zufallszahlen benötigten Bibliotheken eingebunden, zusätzlich <stdio.h> zur Ausgabe mit printf()

● Danach folgt die Deklaration der beiden Funktionen my_init_random() und my_random_01() sowie der globalen Variablen myrnd_max

● Das Programm main() wurde durch Verwendung von 2 Funktionen übersichtlicher gestaltet.
• Zuerst wird der Zufalls-Generator mit Funktion my_init_random() initialisiert.
• Danach werden in der for-Schleife mit Funktion my_random_01() einige Gleitkomma-Zufallszahlen erzeugt, an die Variable x zugewiesen und ausgegeben.

● Die Funktion my_init_random() führt die Initialisierung des Zufalls-Generators aus, so wie im ↑ ersten Kapitel dieser Seite gezeigt.
• Hier wird auch der Wert der globalen Variablen myrnd_max zugewiesen, und zwar der in eine Gleitkomma-Zahl umgewandete Wert der Konstanten RAND_MAX
• Wenn man eine der beiden abgeschalteten Zeilen aktiviert, dann verwirft die Funktion den ersten oder die ersten 10 vom Generator gelieferten Werte.

● Die Funktion my_random_01() liefert bei jedem Aufruf eine Gleitkomma-Zahl im Bereich 0..1
Damit man die Typ-Umwandlung der ganzzahligen Konstanten RAND_MAX nicht jedesmal durchführen muss, ist der Wert in der Gleitkomma-Variablen myrnd_max gespeichert. Bei Verwendung eines großzügigen Compilers kann man diese Variable evtl. weglassen und direkt durch RAND_MAX dividieren.

● Die von Funktion my_random_01() gelieferten Werte kann man in allen Algorithmen verwenden, welche gleichmäßig verteilte Zufallszahlen 0..z..1 einsetzen. 		C-Programm mit Funktion my_random_01() zur Erzeugung von Gleitkomma-Zufallszahlen im Bereich 0..z..1
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

void my_init_random(void);
double my_random_01(void);
double myrnd_max;

int main() {
int i;
double x;
my_init_random();
for(i=0;i<10;i++) {
x = my_random_01();
printf("%f, ",x);
}
printf("\n");
return 0;
}

void my_init_random(void) {
int i,j;
myrnd_max=(double)RAND_MAX;
srand(time(NULL));
// j=rand();
// for(i=0;i<20;i++) {j=rand();}
}

double my_random_01(void) {
return (double)rand()/myrnd_max;
}
Typische Ausgabe:
*

Gleitkomma-Zufallszahlen in einem beliebigen Bereich
Das Beispiel enthält kein vollständiges C/C++ Programm, sondern zeigt nur die Änderungen gegenüber den Gleitkomma-Zahlen im fixen Bereich 0..z..1 im Kapitel ↑ oben.

Verwenden sie zusätzlich oder alternativ zur Funktion my_random_01() die Funktion my_random_double()

In diesem Fall muss man die Bereichs-Grenzen als Gleitkomma-Argumente angeben - im Beispiel den Bereich 10.0 bis 20.0 (kann auch negative Werte enthalten). 		Funktion my_random_double() zur Erzeugung von Pseudo-Zufallszahlen in einem beliebigen Bereich:
// Deklaration:
double my_random_double(double,double);
// Funktion:
double my_random_double(double zmin, double zmax) {
return (double)rand()*(zmax-zmin)/myrnd_max+zmin;
}
Typische Anwendung:
for(i=0;i<10;i++) {
x = my_random_double(10.0,20.0);
printf("%f, ",x);
}
Typische Ausgabe:
*

Normalverteilte Zufallszahlen
Alle bisher ↑ demonstrierten Beispiele erzeugen gleichmäßig verteilte Zufallszahlen im jeweiligen Intervall, welches durch seine Grenzen klar definiert ist.

● Normalverteilte Zahlen 'streuen' um einen Mittelwert, wobei die Häufigkeit (Wahrscheinlichkeit) mit zunehmendem Abstand vom Mittelwert abnimmt. Ein Maß für die Geschwindigkeit der Abnahme ist die Standardabweichung. Es gibt keine Grenzen, da die Wahrscheinlichkeit in großer Entfernung vom Mittelwert zwar sehr klein, jedoch niemals =0 wird.

● Der hier verwendete → Polar-Algorithmus benötigt die Funktionen sqrt() (Quadratwurzel) und log() (Natürlicher Logarithmus) der Bibliothek <math.h>
Beide Funktionen kann man bei Bedarf (z.B. für einen einfachen MikroProzessor) auch ohne Library als Reihen-Entwicklung programmieren (→ Wurzel, → Logarithmus).
Die Funktion arbeitet in dieser Form mit gleichmäßig verteilten Gleitkomma-Zufallszahlen im Bereich 0..1, die hier mit der oben vorgestellten ↑ Funktion my_random_01() erzeugt werden.

Typische Ausgabe:
*
 C/C++ Programm zur Berechnung von normal-verteilten Zufallszahlen:
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

void my_init_random(void);
double my_random_01(void);
double my_random_normal(double,double);
double myrnd_max;

int main() {
int i;
double m,s,r;
my_init_random();
m = 10.0; // mean value
s = 1.0; // standard deviation
for(i=0;i<10;i++) {
r = my_random_normal(m,s);
printf("r01 = %f\n",r);
}
return 0;
}

void my_init_random(void) {
int i,j;
myrnd_max = (double)RAND_MAX;
srand(time(NULL));
}

double my_random_01(void) {
return (double)rand()/myrnd_max;
}

double my_random_normal(double my_mean,double my_stdev) {
double v,w,x1,x2,z;
v = 1;
while(v>=1) {
x1 = 2 * my_random_01() - 1;
x2 = 2 * my_random_01() - 1;
v = x1 * x1 + x2 * x2;
}
w = sqrt((-2 * log(v)) / v);
z = my_stdev * x1 * w + my_mean;
return z;
}

Ganze Zufallszahlen in einem beliebigen Bereich
Das Beispiel enthält kein vollständiges C/C++ Programm, sondern zeigt nur die Änderungen gegenüber den Gleitkomma-Zahlen im fixen Bereich 0..z..1 im Kapitel ↑ oben.

Verwenden sie zusätzlich oder alternativ die Funktion my_random_int()

In diesem Fall muss man die Bereichs-Grenzen als ganzzahlige Argumente angeben - im Beispiel den Bereich 1 bis 6 (kann auch negative Werte enthalten).

Die Funktion verwendet u.a. den Modulo-Operator %, welcher den Rest bei ganzzahliger Division liefert.

♦ Details zur Modulo-Funktion 		Funktion my_random_int() zur Erzeugung von ganzen Pseudo-Zufallszahlen in einem beliebigen Bereich:
// Deklaration:
int my_random_int(int,int);
// Funktion:
int my_random_int(int izmin, int izmax) {
return (rand() % (izmax-izmin+1) )+ izmin;
}
Typische Anwendung (Würfel):
for(i=0;i<10;i++) {
wuerfel = my_random_int(1,6);
printf("%f, ",wuerfel);
}
Typische Ausgabe:
*

Zufalls-Zeichen
Alle ASCII-Zeichen werden intern mit einer ganzen Zahl dargestellt, welche dem jeweiligen → ASCII-Code entspricht.

Die Großbuchstaben A..Z werden intern durch die ganzen Zahlen 65..90 (→ ASCII-Code) dargestellt, die man mit einem Zufalls-Generator nach dem Muster der Funktion my_random_int() (Kapitel ↑ oben) erzeugen kann.

♦ Details zum ASCII-Code 		Funktion my_random_AZ() zur Erzeugung von zufälligen Großbuchstaben:
// Deklaration:
char my_random_AZ(void);
// Funktion:
char my_random_AZ(void) {
return (rand() % 26) + 65;
}
Typische Anwendung:
char c;
for(i=0;i<20;i++) {
c = my_random_AZ();
printf("%c, ",c);
}
Typische Ausgabe:
*
Nach dem Muster der Funktion my_random_AZ() und mit Hilfe einer → ASCII-Code-Tabelle kann man Zufalls-Zeichen aus jedem beliebigen ASCII-Bereich erzeugen.

Die Aufgabe wird etwas schwieriger, wenn die Zeichen aus mehreren, nicht zusammenhängenden ASCII-Bereichen kommen sollen. Das Beispiel rechts demonstriert Lösungen für einige oft verlangte Bereiche.

Die Funktion my_random_char() erwartet als Argument ic eine ganze Zahl 0...7, welche den jeweiligen Zeichen-Bereich auswählt. Nach diesem Muster sollte es keine Schwierigkeiten bereiten, beliebige andere Zeichen-Bereiche zu ergänzen:
icBereichicBereich
0Ziffern 0..940..9 und A..Z
1Hex 0..F50..9 und a..z
2Großbuchstaben A..Z6A..Z und a..z
3Kleinbuchstaben a..z70..9 und A..Z und a..z

Eine Besonderheit ist die Möglichkeit, mit Zeichen und ganzen Zahlen gemischt zu rechnen, z.B.:
c = 'A' + i;
Das Zeichen 'A' entspricht dem ASCII-Code und damit der ganzen Zahl 65, daher ist diese Anweisung äquivalent zu
c = 65 + i;
 Funktion my_random_char() zur Erzeugung zufälliger Zeichen aus unterschiedlichen Bereichen:
// Deklaration:
char my_random_char(int);
// Funktion:
char myrnd_char(int ic) {
char c;
int i;
switch (ic) {
case 0: {
i = my_random_int(0,9);
c = '0' + i;
break;
}
case 1: {
i = my_random_int(0,15);
if (i<10) {c='0'+i;}
else {c='A'+i-10;}
break;
}
case 2: {
i = my_random_int(0,25);
c = 'A' + i;
break;
}
case 3: {
i = my_random_int(0,25);
c = 'a' + i;
break;
}
case 4: {
i = my_random_int(0,35);
if(i<10) {c = '0' + i;}
else {c = 'A' + i -10;}
break;
}
case 5: {
i = my_random_int(0,35);
if(i<10) {c = '0' + i;}
else {c = 'a' + i - 10;}
break;
}
case 6: {
i = my_random_int(0,51);
if(i<26) {c = 'A' + i;}
else {c = 'a' + i - 26;}
break;
}
case 7: {
i = my_random_int(0,61);
if(i<10) {c = '0' + i;}
else if (i<36) {c = 'A' + i - 10;}
else {c = 'a' + i - 36;}
break;
}
default:
c = '$';
}
return c;
}
Typische Anwendung (Ziffern + Großbuchstaben):
char c;
for(i=0;i<20;i++) {
c = my_random_char(4);
printf("%c, ",c);
}
Typische Ausgabe:
*

Zufalls-String

Diese Funktion erzeugt einen String aus Zufalls-Zeichen eines ausgewählten ASCII-Bereichs.

● Es ist die Aufgabe des aufrufenden Programms, einen String ausreichender Länge (hier s als letztes Argument) als Pointer zur Verfügung zu stellen. In diesem String wird das Ergebnis zurückgegeben.

● Weitere Argumente der Funktion sind die minimale und maximale String-Länge, und die Auswahl der Zeichen (ic) , so wie in Funktion my_random_char() angegebeben.
Die Funktion verwendet 2 andere Funktionen, die bereits vorher auf dieser Seite vorgestellt wurden:

● Funktion my_random_int() wird verwendet, um die zufällige Länge des erzeugten Strings festzulegen. Wenn man die Funktion my_random_string() mit Argumenten minlen=maxlen aufruft, dann erzeugt sie einen String fixer Länge, ansonsten wird die Länge zwischen minlen und maxlen zufällig gewählt.
Mit den beiden Argumenten minlen und maxlen wird eine einfache Sicherheits-Maßnahme demonstriert: Keine der beiden Variablen kann <0 werden, und wenn minlen>maxlen, dann werden die beiden Werte vertauscht.

● Funktion my_random_char() erzeugt je 1 Zeichen des Zufalls-Strings. Ihr Argument bestimmt den Zeichen-Bereich, aus dem die Zufalls-Zeichen ausgewählt werden (hier die Zahl 3, das entspricht dem Bereich der Kleinbuchstaben a..z).

● In jedem Durchlauf der for-Schleife wird 1 Zeichen hinzugefügt. Der Array-Pointer i ist absichtlich vom Schleifen-Zähler j entkoppelt. Zuletzt wird das abschließende Null-Byte angefügt. Die Funktion gibt keine Daten zurück, da sie direkt auf den als Pointer übergebenen String str schreibt. 		Funktion my_random_string() zur Erzeugung eines Strings mit vorgegebener oder zufälliger Länge aus Zufalls-Zeichen:
// Deklaration
void my_random_string(int,int,int,char*);

// Funktion:
my_random_string(int minlen,int maxlen,int ic,char *str) {
int i,j,len;
if(minlen<0) {minlenn = 0;}
if(maxlen<0) {maxlen = 0;}
if(minlen>maxlen) {
len = minlen;
minlen = maxlen;
maxlen = len;
}
i = 0;
if(maxlen>0) {
len = my_random_int(minlen,maxlen);
for(j=0;j<len;j++) {
str[i++] = my_random_char(ic);
}
}
str[i]='\0';
}

Typische Anwendung (String aus 10..20 Kleinbuchstaben):
char s[32];
my_random_string(10,20,3,s);
printf("s=%s\n",s);

Typische Ausgabe:
*

Bibliothek der Zufalls-Funktionen
Bei der Entwicklung verwendet man häufig Zufalls-Daten, um ein Programm zu testen. Derartige Daten lassen sich auf einfache Weise und in sehr großer Anzahl automatisch erzeugen. In diesem und ähnlichen Fällen ist es sinnvoll, die Zufalls-Funktionen in eine eigene Funktions-Bibliothek (z.B. my_random.cpp) auszulagern.
Die zu testenden Programme (z.B. main() ) und Quelltext-Dateien werden dabei wesentlich kleiner und übersichtlicher.
Zur Verwendung einer eigenen kleinen Funktions-Bibliothek sind jeweils mindestens 3 Text-Dateien erforderlich:
• Eine Header-Datei, z.B. my_random.h
• Eine Funktionen-Datei, z.B. my_random.cpp
• Das Anwendungs-Programm, z.B. main.cpp 		Header-Datei und Funktionen-Datei kann man ohne Änderung für beliebig viele Projekte verwenden.
Das Anwendungs-Programm erfordert nur eine winzige Anpassung.

Header-Datei

Im Beispiel rechts wird eine Header-Datei vorgestellt. Man kann sie unterschiedlich organisieren, die hier vorgestellte Version ist lediglich eine Möglichkeit.

Die Datei enthält typisch
• Die Verknüpfung mit allen benötigten Bibliotheken
• Die Deklarationen aller verwendbaren Funktionen
• Die Deklarationen der globalen Konstanten und Variablen. 		Beispiel einer Header-Datei my_random.h
// Libraries:
#include <stdlib.h>   // definition of RAND_MAX
#include <math.h>   // rand(), srand()
#include <time.h>   // time()

// Global function declarations
void my_init_random(void);
int my_random_int(int,int);
double my_random_01(void);
double my_random_double(double,double);
double my_random_normal(double,double);
char my_random_AZ(void);
char my_random_char(int);
void my_random_string(int,int,int,char*);

// Global variable declarations
double myrnd_max;

Funktionen-Datei

Im Beispiel rechts wird eine Quelltext-Datei vorgestellt, welche alle hier vorgestellten Funktionen enthält.

Fast alle Kommentare wurden zur Kürzung weggelassen.
♣ Wenn sie selbst Bibliotheken erstellen, dann sind Kommentare wichtig und empfehlenswert. Man kommentiert typisch: Zweck der Funktion, Argumente, Rückgabe-Wert(e).

Die Namen der Funktionen wurden so gewählt, dass möglichst keine Kollisionen mit Standard-Funktionsnamen auftreten.

• Funktion my_init_random() initialisiert den Zufallsgenerator mit einem Zufallswert.
• Funktion my_random_int() erzeugt ganzzahlige Zufallswerte.
• Funktion my_random_01() erzeugt Gleitkomma-Zufallszahlen im Bereich 0..1
• Funktion my_random_double() erzeugt Gleitkomma-Zufallszahlen.
• Funktion my_random_normal() erzeugt normalverteilte Gleitkomma-Zufallszahlen.
• Funktion my_random_AZ() erzeugt zufällige Großbuchstaben.
• Funktion my_random_char() erzeugt Zufalls-Zeichen aus verschiedenen Bereichen.
• Funktion my_random_string() erzeugt Zufalls-Strings verschiedener Länge.
• Details zu den hier in kompakter Form enthaltenen Funktionen finden sie in den ↑ vorangehenden Kapiteln dieser Seite. 		Beispiel einer Funktionen-Datei my_random.cpp
#include "my_random.h"

void my_init_random(void) {
int i;
myrnd_max = (double)RAND_MAX;
srand(time(NULL));
i = rand();   // skip result
}

int my_random_int(int imin, int imax) {
return (rand() % (imax-imin+1))+imin;
}

double my_random_01(void) {
return (double)rand()/myrnd_max; }

double my_random_double(double zmin,double zmax) {
return (double)rand()*(zmax-zmin)/myrnd_max+zmin;
}

double my_random_normal(double my_mean,double my_stdev) {
double v,w,x1,x2;
v=1;
while (v>=1) {
x1 = 2 * my_random_01() - 1;
x2 = 2 * my_random_01() - 1;
v = x1 * x1 + x2 * x2;
}
w = sqrt((-2 * log(v)) / v);
return (my_stdev * x1 * w) + my_mean;
}

char my_random_AZ(void) {
return (rand() % 26)+65;
}

char my_random_char(int ic) {
char c;
int i;
switch (ic) {
case 0: { // 0...9
i = my_random_int(0,9);
c = '0' + i;
break;
}
case 1: { // 0...F
i = my_random_int(0,15);
if (i<10) {c = '0' + i;}
else {c = 'A' + i - 10;}
break;
}
case 2: { // A...Z
i = my_random_int(0,25);
c = 'A' + i;
break;
}
case 3: { // a...z
i = my_random_int(0,25);
c = 'a' + i;
break;
}
case 4: { // 0...9 & A...Z
i = my_random_int(0,35);
if(i<10) {c = '0' + i;}
else {c = 'A' + i -10;}
break;
}
case 5: { // 0...9 & a..z
i = my_random_int(0,35);
if(i<10) {c = '0' + i;}
else {c = 'a' + i - 10;}
break;
}
case 6: { // A...Z & a..z
i = my_random_int(0,51);
if(i<26) {c = 'A' + i;}
else {c = 'a' + i - 26;}
break;
}
case 7: { // 0...9 & A...Z & a...z
i = my_random_int(0,61);
if(i<10) {c = '0' + i;}
else if (i<36) {c = 'A' + i - 10;}
else {c = 'a' + i - 36;}
break;
}
default: {c = '$';}
}
return c;
}

void my_random_string(int minlen,int maxlen,int ic,char *str) {
int i,j,len;
if (minlen<0) {minlen = 0;}
if (maxlen<0) {maxlen = 0;}
if (minlen>maxlen) {
len = minlen;
minlen = maxlen;
maxlen = len;
}
i=0;
if (maxlen>0) {
len = my_random_int(minlen,maxlen);
for (j=0;j<len;j++) {
str[i++] = my_random_char(ic);
}
}
str[i] = '\0';
}

Anwendungs-Programm

Das Beispiel demonstriert die Anwendung der Funktionen-Bibliothek:

● Dazu wird lediglich die Header-Datei (hier my_random.h) mit #include eingebunden, allerdings nicht mit <> spitzen Klammern, da die Header-Datei in einem lokalen Pfad liegt - normalerweise im gleichen Verzeichnis / Ordner wie die Quelltext-Dateien *.cpp

• Außerdem muss man alle Bibliotheken einbinden, die vom Programm zusätzlich und unabhängig von den Bibliotheks-Funktionen verwendet werden, hier z.B. <stdio.h> für die Funktion printf()

● Im Programm stehen alle Funktionen der Bibliothek zur Verfügung, so wie rechts demonstriert. 		Beispiel eines Anwendungs-Programms main.cpp, welches ibn diesem Fall 100 ganze ZufallsZahlen erzeugt und ausgibt.
#include <stdio.h>
#include "my_random.h"

int main() {
int i,j;
my_init_random();
for(i=0;i<100;i++) {
j = my_random_int(10,20);
printf("%d, ",j);
}
printf("\n");
}

Compiler

Um ein ausführbares Programm (Linux-Binary, Windows *.exe) herzustellen, beachten sie die Hinweise des verwendeten Compilers.

♣ Tipp: Alle verwendeten Dateien (Header-Datei, Funktionen-Quelltext, AnwendungsProgramm-Quelltext, ...) sollten sich im gleichen Verzeichnis / Ordner befinden.

Vorteile

Bei Anwendung der vorgestellten Arbeitstechnik ergeben sich u.a. diese Vorteile:
• Portable Funktionen: Alle Funktionen der Bibliothek lassen sich rasch und einfach mit beliebigen Anwendungs-Programmen verwenden. Man kann die Bibliothek (bei sauberer Programmierung) auf allen gängigen Betriebssystemen verwenden.
• Übersicht: Durch Ausgliederung der Funktionen wird das Anwendungs-Programm wesentlich kleiner, übersichtlicher und einfacher zu debuggen.

Klasse

Eine Funktionen-Bibliothek ist ein großer Fortschritt in der Technik der Programmierung. Mit zunahmender Anzahl der verwendeten Bibliotheken machen sich jedoch neue Probleme bemerkbar, z.B. unerwünschte Wechselwirkungen der zahlreichen Konstanten, Variablen und Funktionen.
Eine moderne Lösung ist die Einbindung der Funktions-Bibliothek in eine Klasse (class). Damit werden die Objekte 'gekapselt', unerwünschte Wechselwirkungen unterbunden, und die Sicherheit der Anwendung wesentlich verbessert.
Diese Arbeitstechnik geht über den hier vorgestellten Rahmen hinaus und wird vorläufig nicht demonstriert.
Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   C++   >   Zufallszahlen