Swap-Funktion in C++

C++ Swap-Funktion


Im folgendem wird eine Swap-Funktion in C++ gezeigt. Eine Swap-Funktion ist eine Methode zum tauschen zweier Werte. Diese wird bspw. für Sortier-Algorithmen wie dem Bubblesort verwendet. Es werden zwei Beispiele der Swap-Methode gezeigt, eine mit Referenzen und eine mit Pointern (Zeiger).

Swap-Funktion mit Pointer

/* Quelle.cpp */
 
#include <iostream>
#include <iomanip>
#include <string>
 
using namespace std;

//Prototyp
void swap(float*, float*);
 
int main(){
	//Werte tauschen
	float a = 3, b = 15;
	cout << "1.) a: " << a << "   b: " << b << endl;
	swap(&a,&b);
	cout << "2.) a: " << a << "  b: " << b << endl;
	//Konsole halten
	string s;
	cin >> s;

}
 
//Swap-Funkton tauscht zwei werte
//via Pointer
void swap(float* a, float* b)
{
	float tmp = *a;
	*a = *b;
	*b = tmp;
}

Swap-Funktion mit Referenz

/* Quelle.cpp */
 
#include <iostream>
#include <iomanip>
#include <string>
 
using namespace std;

//Prototyp
void swap(float&, float&);
 
int main(){
	//Werte tauschen
	float a = 3, b = 15;
	cout << "1.) a: " << a << "   b: " << b << endl;
	swap(a,b);
	cout << "2.) a: " << a << "  b: " << b << endl;
	//Konsole halten
	string s;
	cin >> s;

}
 
//Swap-Funkton tauscht zwei werte
//via Pointer
void swap(float& a, float& b)
{
	float tmp = b;
	b = a;
	a = tmp;
}

Kreisfunktion in C++

Ermitteln der Kreisfläche und des Kreisumfangs


Im folgendem zeige ich ein C++ Programm welches anhand des Radius die Kreisfläche und den Kreisumfang berechnet. Dabei werden die Werte nicht via return zurückgegeben, sondern Variablen als Referenz übergeben. Der Inhalt der Referenzvariablen wird in der Funktion circle geändert und im Hauptprogramm können diese nach Aufruf abgefragt werden. Anschließend erfolgt die Ausgabe vom Radius, Fläche des Kreises und Umfang des Kreises für verschiedene Radien.

Berechnung der Fläche und Umfang eines Kreises


/* Quelle.cpp */

#include <iostream>
#include <iomanip>
#include <string>

using namespace std;

//Prototyp Kreisfunktion
void circle(const double&, double&, double&); 

int main(){
	
	double radius = 0, umfang, flaeche;
	//Headline
	cout << " *** Berechnung Kreiswerte ***" << endl;
	cout << setw(10) << "Radius"<< setw(10) 
			<< "Umfang"<< setw(10) 
			<< "Flaeche" << endl;
	//Ausgabe: Radius, Fläche, Umfang
	for (int i = 0; i < 20; i++)
	{
		radius += 0.5;
		circle(radius, flaeche, umfang);
		
		cout << setw(10) << fixed << setprecision (1) << radius;
		cout << setw(10) << fixed << setprecision (3) << umfang;
		cout << setw(10) << fixed << setprecision (3) << flaeche;
		cout << endl;

	}
	//Halten der Ausgabe
	string x;
	cin >> x;
}

//Berechnet den Kreisumfang und die Kreisfläche
//area = Kreisfläche
//circumference = Kreisumfang
void circle(const double& radius, double& area, double& circumference)
{
	const double PI = 3.1415926536;
	area = PI * radius * radius;
	circumference = 2 * PI * radius;
}

C++ Makro: Maximum, Minimum, Betrag

Ermitteln des Maximums, Minimums und des Betrags


Im folgendem zeige ich ein C++ Beispiel für Makros, welche im Header eingetragen werden. Per Textersatz werden die drei Makros MAX (Maximum), MIN (Minimum) und ABSOLUT (Betrag) in die CPP Datei geschrieben.

Makros im Header definieren

/*
Headerdatei
Makro.h
*/

#ifndef _MAKROH_
#define _MAKROH_
	//Liefert den Betrag von value
	#define ABSOLUT(value) ((value) >= 0 ? value : -(value));
	//Liefert das Maximum von zwei Werten
	#define MAX(a,b) (a >= b ? a : b);
	//Liefert das Minimum von zwei Werten
	#define MIN(a,b) (a >= b ? b : a);
#endif

Makros in der CPP-Datei aufrufen

/* Quelle.cpp */

#include <iostream>
#include <string>
#include "Makro.h"

using namespace std;

int main(){
	cout << "Maximum von 1 und 2: " << MAX(1,2); cout << endl;
	cout << "Maximum von 3 und 4: " << MAX(3,4); cout << endl;
	cout << "Minimum von 1 und 2: " << MIN(1,2); cout << endl;
	cout << "Minimum von 3 und 4: " << MIN(3,4); cout << endl;
	cout << "Betrag von  3: " << ABSOLUT(3); cout << endl;
	cout << "Betrag von -3: " << ABSOLUT(-3); cout << endl;

	//Konsole offen halten
	string s;
	cin >> s;
}

Rate eine Zahl von 1 bis 15!

Ein kleines C++ Ratespiel


Im folgendem zeige ich den C++ Sourcecode für ein kleines Zahlenratespiel. Dabei wird per Zufall eine Zahl zwischen 1 und 15 bestimmt. Anschließend hat der Spieler 3 Versuche die Zahl zu erraten. Das Spiel ist beliebig oft wiederholbar. Viel Spaß damit ;)

C++ Zahlenraten (Ratespiel)

/*
Zahlenratespiel
beta-source.com
*/

#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
	time_t t;
	int zahl = 0; //Zufallszahl
	int zahlraten; //geratene Zahl
	bool b = false; //richtig geraten?

	char again = 'y'; //nochmal spielen?

	cout << "Erate die Zahl zwischen 1 und 15" << endl;

	while (again == 'y'){
		b = false; //auf Default setzen
		
		time (&t); //sekunden holen
		srand(t); //Zufallsgenerator starten mit sekundenzahl
		zahl = rand() % 15 + 1; // Zufallszahl bestimmen
		
		//3 Rateversuche
		for (int i = 0; i < 3; i++){
			cout << "Versuch " << i + 1 << ": ";
			cin >> zahlraten;

			if (zahlraten == zahl){
				cout << "richtig geraten" << endl;
				b = true;
				break;
			}
			else {b = false;}
		}
		//Bei nicht erraten
		if (!b){ //Wenn nicht erraten
			cout << "Leider hast du die Zahl nicht "
				<< "erraten  die richtige Zahl war: " 
				<< zahl << endl;
		}
		//Nochmal spielen?
		cout << "Nochmal spielen (y = ja, n = nein)?: ";
		cin >> again;
	}
}

Einmaleins ausgeben!

Wie berechnet man das kleine Einmaleins?


Im folgenden wird ein kleines Programm präsentiert welches das kleine Einmaleins ausgibt.

Das Programm wird in C++ auf der Konsole ausgeführt. Daher auch am ende das cin so dass die Konsole stehenbleibt, und das Einmaleins bzw. die Auflistung gesehen werden kann. ;)

Einmaleins mit C++ ausgeben

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

int main()
{
	//Kopfzeile
	cout << setw(5) << "     ";
	for (int i = 1; i <= 10; i++){
		cout << setw(5) << right << i;
	}
	cout << endl;
	//Linie
	cout << setw(5) << "     ";
	cout << setw(50) << 
		"__________________________________________________" 
		<< endl;

	//Einmaleins
	for (int i = 1; i <= 10; i++){
		cout << setw(4) << right << i << "|";

		for (int j = 1; j <= 10; j++){
			cout <<setw(5)<<right<<i * j;
		}
		cout << endl;
	}

	//Konsole bleibt offen
	string s;
	cin >> s;

}

JavaScript – Modulo von großen Zahlen

Wie berechne ich den Modulo von großen Zahlen in JavaScript?


Ein ganz besonderes JavaScript-Ärgernis, ist das rechnen mit großen Zahlen. Wo es in anderen Programmiersprachen fertige Bibliotheken gibt, die das rechnen und Modulo ziehen – für große Zahlen – übernehmen, da stößt man mit JavaScript schnell an die Grenzen. Dennoch kann man – gerade was die Modulo-Bildung angeht – sich relativ einfach behelfen. Gehen wir zurück in die Grundschule.

Wir haben doch irgendwann mal gelernt, wie man per Hand große Zahlen dividieren kann. Dabei nimmt man eine beliebige Anzahl an Stellen links an der Zahl weg, und berechnet aus diesen den Rest. Jetzt nimmt man die nächsten Stellen an der Zahl von links weg, diese ergänzt man um den vorherigen Rest. Aber Vorsicht, dabei schreibt man die Zahlen zusammen, es wird nicht addiert (Rest 7 und Teilstück 49 wird zu 749).

Das ganze macht man solange bis keine Zahl mehr übrig ist. Fertig ist der Modulo von beliebig lange Zahlen in JavaScript! ;)

/**
 * Rechnet den Modulo von beliebig großen zahlen aus
 * @param s: Zahl als String
 * @param mod: modulo Operand (s % mod)
 * @returns: Rest aus s / mod 
 */
this.bignumberModulo = function(s, mod)
{
	//Wie viele Zahlen sollen in den
	//einzelnen Schritten betrachtet werden 
	numberOfChars = 5;
	//sicheres konvertieren auf String
	var z = new String();
	z = s;
	//Teilstück der Zahl, Rest ermitteln 
	var n = "";
	//akuteller Rest
	var rest = 0;

	do {
		//erstes Teilstück der Zahl bestimmen
		n = rest + z.substring(0, numberOfChars);
		//wie lang ist der verbleibende String
		c = z.length;
		//Wenn noch ein Teilstück berechnet
		//werden muss, dann schneide aktuelles
		//Stück weg, so dass dieses nächstes mal
		//nicht mehr betrachtet wird
		if (c > numberOfChars) 
			{z = z.substring(numberOfChars);}
		//hole den rest vom Teilstück
		//wenn noch ein Durchlauf, dann
		//setze rest an nächstes Teil-
		//stück Vorn an
		rest = n % mod;
	} while (c > numberOfChars);
	
	return rest;
};

IBAN-Nummer errechnen

Programm zum errechnen der IBAN-Nummer


Die IBAN-Nummer setzt sich aus vier Komponenten zusammen. Aus einem Länderkürzel (2-Stellig), Prüfziffer (2-Stellig), Bankleitzahl (8 Stellig) und Kontonummer (10 Stellig). Ist die BLZ oder Kontonummer kürzer als 8 bzw. 10 Stellen, so werden diese – links – mit Nullen aufgefüllt.

Länderkürzel & Prüfziffer & Bankleitzahl & Kontonummer

Die Prüfziffer ist dabei das größte Übel, der Rest ist nur zusammensetzen.

Errechnen der IBAN Prüfziffer

Im ersten Schritt ermitteln man den Ländercode. Dabei wird das zweistellige Länderkürzel getrennt und geschaut welche Stelle im Alphabet die einzelnen Buchstaben annehmen. Beispiel “DE” D=4, E=5. Diese werden jeweils mit 9 addiert: D=4+9=13, E=5+9=14. Anschließend hängt man noch zwei Nuller an, somit ist der Ländercode für DE: “131400″. Jetzt setzt man die Nummer wieder zusammen.

BLZ & Kontonummer & Ländercode

  • Von dieser 22 stelligen Nummer zieht man den modulo 97 (Rest von Zahl : 97)
  • Von dem Modulo zieht man 98 ab
  • Da dies immer eine negative Zahl ergibt bildet man den Betrag (negativeZahl * (-1))
  • Ist diese Zahl einstellig, so füllt man diese wieder mit einer Null – links – auf

PHP-Sourcecode

<?php
$i = new Iban();
echo $i->getIBAN("DE","7188 0177","321 0022");

class Iban 
{
	/**
	 * Erzeugt die IBAN-Nummer.
	 * @param $land: Länderkürzel bspw. DE
	 * @param $kontonummer: bisherige Kontonummer
	 * @param $blz: bisherige Bankleitzahl
	 */
	function getIBAN($land, $kontonummer, $blz)
	{
		//Prüfziffer ermitteln
		$checkdigits = $this->getCheckDigits($land, $kontonummer, $blz);
		//Iban zusammensetzen
		$land = strtoupper($land);
		$blz = $this->fillString($blz, 0, 8);
		$kontonummer = $this->fillString($kontonummer, 0, 10);
		$iban = $land.$checkdigits." ".$blz." ".$kontonummer;
		//einzelne Stringlänge checken 
		if (strlen($land) != 2 ||
			strlen($checkdigits) != 2 ||
			strlen($blz) != 8 ||
			strlen($kontonummer) != 10)
		{$iban = false;}
		
		return $iban;
	}

	/**
	 * Erstellt die IBAN-Prüfnummer
	 * @param $land
	 * @param $kontonummer
	 * @param $blz
	 */
	private function getCheckDigits($land, $kontonummer, $blz)
	{
		$land = strtoupper($land);
		$blz = $this->fillString($blz, 0, 8);
		$kontonummer = $this->fillString($kontonummer, 0, 10);
		
		//Land zu Zahl
		if (strlen($land) != 2 ||
			strlen($blz) != 8 ||
			strlen($kontonummer) != 10)
			{return false;}
		else
		{
			//Buchstaben zu Zahl umwandeln
			$countrynumber = "";
			for ($i = 0; $i < 2; $i++) {
				$c = substr($land,$i,1);
				//Ascii-Wert - 64
				//A = 1, B = 2 ... 
				$c = ord($c)-64;
				$c = $c + 9;
				$countrynumber = $countrynumber.$c; 
			}
			$countrynumber = $countrynumber."00";
			
			$c = $blz.$kontonummer.$countrynumber;
			//Rechnen mit großen zahlen = bcmod
			$c = bcmod($c, 97);
			$c = ($c-98)*(-1);
			$c = $this->fillString($c, "0", 2);
			
			return $c;
		}
		
		
	}
	
	/**
	 * Füllt einen String $s mit $fillwith 
	 * bis zum $charcount-Zeichen auf.
	 * Entfernt alle Leerzeichen!
	 * @param $s: aufzufüllender String
	 * @param $fillwith: Zeichen zum Auffüllen
	 * @param $charcount: Auffüllen bis Zeichen
	 */
	private function fillString($s, $fillwith, $charcount)
	{
		//Leerzeichen eliminieren
		$s = str_replace(" ", "", $s);
		//wie viele Zeichen auffüllen sollen aufgefüllt werden?
		$c = $charcount - strlen($s);
		if ($c > 0)
		{
			//Auffüllen
			for ($i = 0; $i < $c; $i++) 
				{$s = $fillwith.$s;}
		}
		
		return $s;
	}
}
?>

Größe von Datentypen in C++

Wie viel Speicher benötigt eine Variable in C++?


In C++ gibt es die verschiedensten Datentypen für Zeichen, Ganzzahl und Gleitkommazahl. Anbei ein kleines Programm welches die Größe von Datentypen in C++ ermittelt. Ein Programm zur Ermittlung der Datentypen und deren Speichergröße ist deswegen sinnvoll, da diese vom 32 Bit System zum 64 Bit Betriebssystem abweichen können.

Mit der Funktion sizeof() lässt sich die benötigte Größe pro Datentyp und Betriebssystemart ermitteln.

Speichergröße einer Variable in C++

#include <iostream>
using namespace std;

int main()
{
	cout << "Size of Datatyps in C++" << endl;
	cout << " char\t" << sizeof(char) << "Byte" << endl;
	cout << " short\t" << sizeof(short) << "Byte" << endl;
	cout << " int\t" << sizeof(int) << "Byte" << endl;
	cout << " long\t" << sizeof(long) << "Byte" << endl;
	cout << " float\t" << sizeof(float) << "Byte" << endl;
	cout << " double\t" << sizeof(double) << "Byte" << endl;
	cout << " long double\t"<< sizeof(long double)<<"Byte"<<endl;
	cout << " long long\t" << sizeof(long long) << "Byte"<<endl;
	
	return 0;
}

Primzahl bestimmen

Wie prüft man eigentlich, ob eine Zahl eine Primzahl ist?


Ein kleiner und simpler Code, wie man Primzahlen bestimmen kann. Dabei muss man wissen, dass bei der Schleife – welche die einzelnen Divisionen prüft – nur bis zur Wurzel der zu prüfenden Zahl abgefragt werden muss. So verringern sich die Gesamtabfragen und die Primzahl kann einfacher bestimmt werden. Desweiteren möchte ich hinzufügen, dass es auch kürzere Wege gibt die Primzahl zu prüfen, jedoch ist dies der verständlichste Weg.

JAVA

/**
 * Is a number a primenumber?
 * @param number : checking number
 * @return : true = primenumber, false = no primenumber
 */
public boolean isprimenumber(int number)
{
	//Eine Zahl die nur durch eins oder 
	//sich selbst teilbar ist, ist eine Primzahl
	
	//0 und 1 sind keine Primzahlen
	if (number <= 1) return false;

	//Alle Zahlen bis zur wurzel von number testen
	int n = (int) Math.sqrt(number);
	
	//Alle Zahlen testen
	for (int i = 2; i < n+1; i++) {
		if (i != number)
		{
			//Wenn es keinen Rest gibt
			//ist Zahl teilbar
			if ((number%i)==0) 
				return false;
		}
	}
	//Primzahl		
	return true;
}

PHP

/**
 * Is a number a primenumber?
 * @param number : checking number
 * @return : true = primenumber, false = no primenumber
 */
function isprimenumber($number)
{
	//Eine Zahl die nur durch eins oder 
	//sich selbst teilbar ist, ist eine Primzahl
	
	//0 und 1 sind keine Primzahlen
	if ($number <= 1) return false;

	//Alle Zahlen bis zur wurzel von number testen
	$n = bcsqrt($number);
	
	//Alle Divisionen testen
	for ($i = 2; $i < $n+1; $i++) {
		if ($i != $number)
		{
			//Wenn es keinen Rest gibt
			//ist Zahl teilbar
			if (($number%$i)==0) 
				return false;
		}
	}
	
	//Primzahl		
	return true;
}

Stack-Programmierung
JavaScript, PHP, Java

Die Stack-Programmierung beschreibt ein Speicherverfahren, bei dem auf einem Stapel gespeichert wird.


Das Verfahren stellt ein LIFO-Prinzip (Last In First Out) dar. Dabei werden Werte nacheinander auf einen Stapel gelegt, diese können dann in umgekehrter Reihenfolge wieder vom Stack herunter genommen werden. Das heißt, legt man die Werte “X”, “C”, “9″ der Reihe nach auf den Stack, können sie nur in der Folge “9″, “C”, “X” wieder entnommen werden. Nimmt man einen Wert vom Stapel, wird dieser zurückgegeben und verschwindet vom Stack.

Mit der Methode PUSH wird ein Wert auf den Stapel gelegt, dabei wird der Zeiger – welcher auf die höchste Adresse des Stacks zeigt – weiter gezählt. Die höchste Speicheradresse nennt man ToS (Top of Stack). Mit der POP Methode wird ein Wert vom Stack herunter genommen, dabei zählt der TOS-Pointer ebenfalls runter. Ist die niedrigste Speicheradresse BoS (Bottom Of Stack) erreicht und POP aufgerufen, wird nichts mehr zurückgegeben.

Java

/**
 * Just a simple Stack-Class
 * @author MrKnowing.com
 */
public class Stack {
	/**
	 * contains the TopOfStack-address
	 */
	private int tos;
	/**
	 * contains all Stack-Values
	 */
	private String[] stackArray;
	/**
	 * Default constructor
	 */
	public Stack() {
		tos = -1;
		stackArray = new String[256];
	}
	/**
	 * puts one object to top of Stack
	 * @param s : string-Value
	 * @return true = value added, false = stackoverflow
	 */
	public boolean push(String s) {
		if ((tos + 1) < stackArray.length) {
			tos++;
			stackArray[tos] = s;
			return true;
		} else {
			// Stackoverflow
			return false;
		}
	}
	/**
	 * returns the value of tos-address
	 * @return value of tos-address, no entry available = null
	 */
	public String pop() {
		if (tos >= 0) {
			String s = stackArray[tos];
			tos--;
			return s;
		} else {
			return null;
		}
	}
}

PHP

/**
 * Just a simple Stack-Class
 * @author MrKnowing.com
 */
class Stack
{
	/**
	 * contains the TopOfStack-address 
	 */
	private $tos;
	/**
	 * contains all Stack-Values
	 */
	private $stackArray;
	/**
	 * maximum of tos-address
	 */
	private $maxTos;
	
	/**
	 * Default constructor
	 */
	function Stack()
	{
		$this->maxTos = 256;
		$this->tos = -1;
	}
	
	/**
	 * puts one object to top of Stack
	 * @param s : Object-Value
	 * @return true = value added, false = stackoverflow
	 */
	function push($s)
	{
		if (($this->tos+1) < $this->maxTos)
		{
			$this->tos++;
			$this->stackArray[$this->tos] = $s;
			return true;
		}
		else
		{
			//Stackoverflow
			return false;
		}
	}
	
	/**
	 * returns the value of tos-address
	 * @return value of tos-address, no entry available = null
	 */
	function pop()
	{
		if ($this->tos >= 0)
		{
			$s = $this->stackArray[$this->tos];
			$this->tos--;
			return $s;
		}
		else
			{return null;}
	}
}

JavaScript

/**
 * Just a simple Stack-Class
 * @author MrKnowing.com
 */
var Stack = function()
{
	/**
	 * contains the TopOfStack-address 
	 */
	var tos = -1;
	/**
	 * contains all Stack-Values
	 */
	var stackArray = new Array(256);
	
	/**
	 * puts one object to top of Stack
	 * @param s : Object-Value
	 * @return true = value added, false = stackoverflow
	 */
	this.push = function(s)
	{	
		if ((tos+1) < stackArray.length)
		{
			tos++;
			stackArray[tos] = s;
			return true;
		}
		else
		{
			//Stackoverflow
			return false;
		}
	};
	
	/**
	 * returns the value of tos-address
	 * @return value of tos-address, no entry available = null
	 */
	this.pop = function()
	{
		if (tos >= 0)
		{
			s = stackArray[tos];
			tos--;
			return s;
		}
		else
			{return null;}
	};	
}