. . . . . w w w . m e h l h o p . c o m . . . . .

• vonvorn
• Nomen
• Portrait
• Webseiten
• Astrologie
• Reisen
  • Alpen
    • Ortler
    • Berliner Höhenweg
    • Venedigergruppe
  • Indien
    • der Weg
    • das Land
    • Gepäck
  • Nepal
  • Südamerika
  • Elbe
• Erde
• Deutschland
• Links
• Sonstiges
• Impressum

C++

Header

#include "stdafx.h"
#include<iostream>
#include<string>
using namespace std;

Datentypen

Typ mit Kommastelle: float & double
Double = das Doppelte von float
Float kann direkt hinter Zahl mit „f“ gekennzeichnet (definiert) werden.
Kurzform Addidion: i=i+2 // i+=2
Ingrement: i++ // ++i
cout << i++ : zeigt i an & zählt dann 1 dazu
cout << ++i : zählt 1 dazu & zeigt i dann an
Dekrement: i-- // --i int main(array<System::String ^> ^args)
{
char v1='a';
Console::WriteLine("char \t\t"+v1.GetType());

unsigned char v2='a';
Console::WriteLine("unsigned char \t"+v2.GetType());

short v3=0;
Console::WriteLine("short \t\t"+v3.GetType());

unsigned short v4=0;
Console::WriteLine("unsigned short \t"+v4.GetType());

int v5=0;
Console::WriteLine("int \t\t"+v5.GetType());

unsigned int v6=0;
Console::WriteLine("unsigned int \t"+v6.GetType());

long v7=0;
Console::WriteLine("long \t\t"+v7.GetType());

unsigned long v8=0;
Console::WriteLine("unsigned long \t"+v8.GetType());

float v9=0;
Console::WriteLine("float \t\t"+v9.GetType());

double v10=0;
Console::WriteLine("double \t\t"+v10.GetType());

long double v11=0;
Console::WriteLine("long double \t\t"+v11.GetType());

Console::WriteLine("sizeof(long double) \t\t"+sizeof(long double));

Double v12=0;
Console::WriteLine("Double \t\t"+v12.GetType());

Decimal v13=0;
Console::WriteLine("Decimal \t\t"+v13.GetType());

bool v14=true;
Console::WriteLine("bool \t\t"+v14.GetType());

Boolean v15=false;
Console::WriteLine("Boolean \t\t"+v15.GetType());

return 0;
}

Casting

char v1='A', v2=1;
cout << v1+v2+1000 << endl; // implizides Casting von v1 + v2, weil durch 1000 zu int gecastet wird
cout << v1+int(v2) << endl; // explizides Casting, weil geschrieben int(...) + impl.C. von v1 weil v2=int
cout << 4/5 << endl; // impl.Casting zu int
cout << (float)4/5 << endl; // expl.Casting von 4, impl.C. von 5 zu float

Explizites Casting

durch den Programmierer ausgelöst
(float)z2
float(z1)

Implizites Casting

Wird durch die Konstellation innerhalb des Programms ausgelöst,
macht der PC selbst

Arrays / Felder

Dynamische Felder

Int* feld=new int[anz]

Struct

// ähnlich Array, aber unterschiedliche Variablen-Typen sind möglich
struct person {
string vorname;
string nachname;
int pnr;
};

int _tmain(int argc, _TCHAR* argv[])
{ person Kunde; // Deklaration
Kunde.vorname="Udo";
Kunde.nachname="Meyer";
Kunde.pnr=1;
cout << Kunde.vorname << " " << Kunde.nachname << " ist die Nummer " << Kunde.pnr << endl;
return 0;}

Funktionen

Funktionen müssen deklariert und definiert werden:

//Deklaration
int zw(int x, char z);

int _tmain(int argc, _TCHAR* argv[])
{ cout << "Anzahl der Zeichen: "<< zw(20.0,'-') << endl;
return 0;}

//Definition der Funktion
int zw(int x, char z){
for(int a=1;a<=x;++a){
cout << a << z;}
cout << endl;
return x;}

Return

Return gibt das Ergebnis der Funktion zurück.
Return muss immer angegeben werden, ggf. mit =0,
außer bei void, da gibt es keinen return.
Boolschen Wert zurückgeben:
bool Rechne(int jahr){
return ((jahr%4==0)&&(!(jahr%100==0)||(jahr%400==0)));}

int _tmain(int argc, _TCHAR* argv[])
{ cin >> jahreszahl;
if(Rechne(jahreszahl)) {cout << "K";}
return 0;}

Verschachteln

Funktionsaufrufe können verschachtelt werden
cout<<max(23,max(22,24))<<endl;
int max(int a,int b){eturn(a>b?a:b);} // maximalen Wert berechnen

Parameter

Formale Parameter

Parameter steht in der Deklaration, bzw. Definition

Aktuelle Parameter

Die tatsächlich benutzten Werte.
Ist der Aufruf der Funktion.

Parameterübergabe

/*cout<<sum2(v1,v2)<<" "<<v1<<endl;
pas by reference
Referenz als Parameter*/
int sum2(int & a,int b){
a=23;
return a+b;}

/*cout<<sum3(&v1,v2)<<" "<<v1<<endl;
pas by reference
Zeiger als Parameter*/
int sum3(int * a,int b){
*a=23;
return *a+b; }


int _tmain(int argc, _TCHAR* argv[])
{ int v1=3,v2=4;
cout<<sum(v1,v2)<<" "<<v1<<endl;
cout<<sum2(v1,v2)<<" "<<v1<<endl;
cout<<sum3(&v1,v2)<<" "<<v1<<endl;
return 0;}

Polymorphie

= Vielestaltigkeit
= überladen
Ein Programm mit mehreren Varianten einer Funktion.
ZB: summe(...)

---

double summe(int v1, int v2, int v3) {return v1+v2+v3;}
double summe(int v1, int v2) {return v1+v2;}

int _tmain(int argc, _TCHAR* argv[])
{ cout << summe(2,2) << endl;
cout << summe(2,2,2)<< endl;
return 0;}

---

double summe(int v1, int v2, int v3) {return v1+v2+v3;}
double summe(int v1, int v2) {return v1+v2;}
//double summe(double v1, int v2=22); // von rechts nach links deklarieren
//double summe(double v1, int v2) {return v1+v2;}
double summe(double v1=33, int v2=22);
double summe(double v1, int v2) {return v1+v2;}

int _tmain(int argc, _TCHAR* argv[])
{ cout << summe(2,2) << endl;
cout << summe(2,2,2)<< endl;
cout << summe(2.3, 2)<< endl;
//cout << summe(2.3)<< endl;
cout << summe()<< endl;
cout << summe(4)<< endl;
return 0;}

Um Daten vom Hauptprogramm zu Funktionen und zurück zu transportieren werden return, Referenzen oder Pointer verwendet.

Referenz

int x=9;
int &z=x;
cout << z << endl; // 9
cout << &z << endl; // 001EFE6C

---

void swap(int &v1, int &v2){
int rette=0;
rette=v1;
v1=v2;
v2=rette;}

int main(){
int v1=3, v2=0;
swap(v1, v2);
cout << v1 << v2;
return 0;}

---

int Rechne(int anzahl, int &AusProdukt){
int summe=0, wert=0;
for(int i=1;i<=anzahl;i++){
cout << "Wert Nummer " << i << " ";
cin >> wert;
summe+=wert;
AusProdukt*=wert; }
return summe;}

int _tmain(int argc, _TCHAR* argv[])
{ int anzahl=0;
int produkt=1;
cout << "Anzahl der Werte: ";
cin >> anzahl;
cout << "Summe: " << Rechne(anzahl, produkt) << endl;
cout << "Produkt: " << produkt << endl;
return 0;}

Referenz als Konstante
void ausgabe(const int &rav){
// rav=88; // in diesem Fall käme es zu einer Fehlermeldung weil rav nun eine Konstante ist
cout << rav << endl;}
int main(){
int var=55;
ausgabe(var);
cout << var << endl;

Zeiger / Pointer

drei mal die selbe Ausgabe (Pointer auf Array):
int A[10]={0};
int *z=A;
z[3]=33;
cout << A[3] << endl;
cout << z[3] << endl;
cout << *(z+3) << endl;
- - -
void swap(int *v1, int *v2){
int rette=0;
rette=*v1;
*v1=*v2;
*v2=rette;}

int main(){
int v1=3, v2=0;
swap(&v1, &v2);
cout << v1 << v2;
return 0;}
---
int i=1;
int *pi=&i; // findet im stek statt
cout << *pi << endl; // Ausgabe “1”
int x=2345;
cout << x << endl; // Inhalt der Variable x 2345
cout << &x << endl << endl; // Adresse der Variable x 0012FF60
int *z;
z=&x;
cout << z << endl; // Adresse der Variable x 0012FF60
cout << &z << endl; // Adresse des Zeigers *z 0012FF54
cout << *z << endl; // Inhalt der Variable x 2345
---
void test(int feld[]){ //int * feld ODER int feld[] ist ein Pointer
feld[0]=11;}


int _tmain(int argc, _TCHAR* argv[]){
int feld[]={1,2,3,4,5};
test(feld); // eine Adresse wird übergeben, kein Wert direkt, der Wert steht im Feld
cout<<feld[0]<<endl; // Ausgabe: 11
return 0;}

delete

int *p=new int[1000];
p[0]=88;
cout << p[0] << endl;
delete p;
// mit DELETE wird der Speicher gelöscht (aber nicht der Pointer) im Heap
cout << p[0] << endl;
p=NULL;
// Der Pointer wird gelöscht, sollte am Ende jeden Programms gemacht werden (delete + Null)
// cout << p[0] << endl;

Konstanten

mit const deklarierierte Variablen können nicht verändert werden
zB.: const int a=22
Konstante als Referenz siehe unter Referenz...

Static

void merke(){
static int a=100;
// mit static initialisierte Variablen merkt sich das Programm
// für Klassen wichtig
cout << "Merke: " << a << endl;
a++;}


int main(){
merke();
merke();
return 0;}

if else

return(a<b?a:b) entspricht: if(a<b){a} else {b}

---

int maximum(int x, int y){
if(x>y) return x;
else return y;
}

Zählschleife

for(int z=0; z<4; z++){...}

switch case

void rechne(double & ergebnis)

{ int z1,z2;
char rechenzeichen;
ergebnis=0;
cout << "Geben Sie eine Rechenaufgabe ein: ";
cin >> z1 >> rechenzeichen >> z2;
//return ;
switch(rechenzeichen)
{ case '+': ergebnis = z1+z2; break;
case '-': ergebnis = z1-z2; break;
case '*': ergebnis = z1*z2; break;
case '/': ergebnis = z1/z2; break;
default: cout << "unbekanntes Rechenzeichen...\n";
}
}


int _tmain(int argc, _TCHAR* argv[])
{ double ergebnis=0;
rechne(ergebnis);
cout<< "Ergebnis: "<<ergebnis << '\n';
return 0;
}

---

int _tmain(int argc, _TCHAR* argv[])
{
int mon,tag,jahr,sum;
for(cout<<"Jahr: ",cin>>jahr, //Datum eingeben
cout<<"Monat: ",cin>>mon,
cout<<"Tag: ",cin>>tag;
mon!=0;
cout<<"Jahr: ",cin>>jahr, //Datum eingeben
cout<<"Monat: ",cin>>mon,
cout<<"Tag: ",cin>>tag)
if((tag>0)&&( //Datum auf gültigkeit prüfen
((mon==1||mon==3||mon==5||mon==7||mon==8
||mon==10||mon==12)&&(tag<32))||
((mon==2)&&(tag<29))||
((mon==2)&&(tag=29)&&((jahr%4==0)&&(!(jahr%100==0)||(jahr%400==0))))||
((mon==4||mon==6||mon==9||mon==11)&&(tag<31))))
{sum=tag; //Tag auf Summe speichern
switch(mon) //Monate in Tage umrechnen
{
case 12:sum+=30;
case 11:sum+=31;
case 10:sum+=30;
case 9:sum+=31;
case 8:sum+=31;
case 7:sum+=30;
case 6:sum+=31;
case 5:sum+=30;
case 4:sum+=31;
case 3:if((jahr%4==0)&&(!(jahr%100==0)||(jahr%400==0)))
sum+=29; //Schaltjahr
else
sum+=28;
case 2:sum+=31;
default:;
}
cout<<tag<<'.'<<mon<<'.'<<jahr<<" ist der "<<sum<<". Tag\n";
}
else
cout<<"Datum falsch\n";
return 0;}

Modulo

Gibt den ganzzahligen Rest aus.
ZB: hm%60

Speicherformen

• Code-Segment
• Daten-Segment
• Stack (Stabelspeicher)
• Heap

Güldigkeitsbereiche

Datei, Klasse, Block

// jeder Block ist ein Güldigkeitsbereich
int main(){
int a=1; // lokale Variable, weil intern angelegt
cout << "1.Variable = " << a << endl;
{int a=2;
cout << "2.Variable = " << a << endl;
{int a=3;
cout << "3.Variable = " << a << endl;}
cout << "2.Variable = " << a << endl;}
cout << "1.Variable = " << a << endl;
return 0;}

Fakultät

{ int fakultaet=1;
for(int i=1;i<10;i++){
fakultaet*=i;
std::cout << "Die Fakultät von " << i << "!" << " ist " << fakultaet << std::endl;
}
1!=1 1
2!=2 1*2
3!=6 1*2*3
4!=24 1*2*3*4

Rekursion

unsigned int fakultaet(unsigned int zahl) {
if (zahl <= 1) {
return 1; // Die Fakultät von 0 und 1 ist als 1 definiert.}
return fakultaet(zahl - 1) * zahl;}


int _tmain(int argc, _TCHAR* argv[])
{ unsigned int zahl;
std::cout << "Bitte Zahl eingeben: ";
std::cin >> zahl; // Zahl einlesen
std::cout << "Die Fakultät von " << zahl << " ist " << fakultaet(zahl) << "!" << std::endl;
return 0;}

Sortierung

int _tmain(int argc, _TCHAR* argv[])
{ int Anz=5,s=0;
int a[]={101,82,43,4,31};
bool Schalter=false;
int Zwischenspeicher;
for (s=0;s<Anz && Schalter==false;){
Schalter=true;
for(int i=0;i<Anz-1;i++){
if(a[i]>a[i+1]){
Zwischenspeicher=a[i];
a[i]=a[i+1];
a[i+1]=Zwischenspeicher;
Schalter=false;
cout<<"Tausch"<<endl;}
}
Anz=Anz-1;
}
cout<<a[0]<<endl<<a[1]<<endl<<a[2]<<endl<<a[3]<<endl<<a[4]<<endl;
return 0;}