function pointer

int max(int x, int y) {

if(x > y) return x; else return y;

}

int min(int x, int y) {

if(x < y) return x; else return y;

}

int main() {

int a = 5, b = 2;

int (*fp)(int, int);

[1] fp = &max; cout << (*fp)(a,b);

[2] fp = &min; cout << (*fp)(a,b);

[3] cout << (*(fp = min))(a,b);

}

→ Output:

[1] 5

[2] 2

[3] 2

function pointer in qsort()...

#include<cstdlib> /* enthlt Prototyp

von qsort() */

int main() {

int ifeld[]={100,22,3,44,6,9,2,1,8,9};

int Groesse=

sizeof(ifeld)/sizeof(ifeld[0]);

[1] qsort(ifeld, Groesse,

sizeof(ifeld[0]), &icmp);

for (int i = 0; i < Groesse; ++i)

cout << ifeld[i];

[2] qsort(ifeld, Groesse,

sizeof(ifeld[0]), &qsumcmp);

for (int i = 0; i < Groesse; ++i)

cout << ifeld[i];

}

→ Output:

[1] 1 2 3 6 8 9 9 22 44 100

[2] 1 100 2 3 22 6 8 44 9 9

...function pointer in qsort()

int qsum(int z) {

if(z) {

int d = z % 10;

return d + qsum(z/10);

}

else return 0;

}

int icmp(const void *a, const void *b) {

int ia = *(int *)a;

int ib = *(int *)b;

if(ia == ib) return 0;

return ia > ib ? 1 : -1;

}

int qsumcmp(const void *a, const void *b) {

int qa = qsum(*(int *)a);

int qb = qsum(*(int *)b);

if(qa == qb) return 0;

return qa > qb ? 1 : -1;

}

template function

template <class T>

void bubbleSort(T* feld, int length) {

for(int i=0;i<length;i++) {

for(int j=i+1;j<length;j++) {

if(feld[j]<feld[i]) {

T tmp=feld[j];

feld[j] = feld[i];

feld[i] = tmp;

}

}

}

}

template function

int main() {

int ifeld[] = {100, 2, 34, 98, 23};

int length;

length=sizeof(ifeld)/sizeof(ifeld[0]);

[1] for(int i=0;i<length;i++)

cout << ifeld[i];

[2] bubbleSort(ifeld, length);

for(int i=0;i<length;i++)

cout << ifeld[i];

double dfeld[] = {3.14159, 1.41421,

2.71828, 2.23606};

length=sizeof(dfeld)/sizeof(dfeld[0]);

[3] for(int i=0;i<length;i++)

cout << dfeld[i];

[4] bubbleSort(dfeld, length);

for(int i=0;i<length;i++)

cout << dfeld[i];

...

}

template function

...

Complex c[5];

c[0].assign(2,1);

c[1].assign(0.2,-1);

c[2].assign(3,-4);

c[3].assign(1,2);

c[4].assign(0.5,0.5);

[5] for(int i=0;i<5;i++) cout << c[i];

[6] bubbleSort(c, 5);

for(int i=0;i<5;i++) cout << c[i];

}

→ Output:

[1] 100 | 2 | 34 | 98 | 23 |

[2] 2 | 23 | 34 | 98 | 100 |

[3] 3.14159 | 1.41421 | 2.71828 | 2.23606 |

[4] 1.41421 | 2.23606 | 2.71828 | 3.14159 |

[5] 2+1i | 0.2-1i | 3-4i | 1+2i | 0.5+0.5i |

[6] 0.5+0.5i | 0.2-1i | 1+2i | 2+1i | 3-4i |

template function II

#include <vector>

bool groesser(int x,int y) { return x > y; }

bool less35(int x) { return x<35;}

int main() {

vector<int> v(10);

vector<int>::iterator it;

[1] for(int i=0;i<v.size();i++)

cout << (v[i] = rand()%50);

[2] sort(v.begin(), v.end());

for(it=v.begin();it!=v.end();++it)

cout << *it;

[3] sort(v.begin(),v.end(),&groesser);

for(it=v.begin();it!=v.end();++it)

cout << *it;

[4] it=find_if(v.begin(),v.end(),&less35);

sort(v.begin(),it);

for(it=v.begin();it!=v.end();++it)

cout << *it;

}

template function II

→ Output:

[1] 33 | 36 | 27 | 15 | 43 | 35 | 36 | 42 |

[2] 15 | 27 | 33 | 35 | 36 | 36 | 42 | 43 |

[3] 43 | 42 | 36 | 36 | 35 | 33 | 27 | 15 |

[4] 35 | 36 | 36 | 42 | 43 | 33 | 27 | 15 |

template class ...

file: vektor.tpl

// === Template-Deklarationen ===

template <class T>

class Vektor {

private:

T* Vek;

int length;

public:

Vektor (int n=1);

~Vektor () { delete[] Vek; }

Vektor (const Vektor<T>&);

Vektor<T>& operator+=(const Vektor<T>&);

template <class M> friend ostream&

operator<<(ostream&,const Vektor<M>&);

};

...

... template class ...

file: vektor.tpl

// === Template-Definitionen ===

...

template <class T>

Vektor<T>::Vektor (int l): length(l) {

Vek = new T[length];

for(int i=0;i<length;i++) Vek[i]=(T)i/2;

}

template <class T>

Vektor<T>::Vektor (const Vektor<T> &x) {

length = x.length;

Vek = new T[length];

for(int i=0;i<length;i++) Vek[i]=x.Vek[i];

}

template <class T> Vektor<T>&

Vektor<T>::operator+=(const Vektor<T> &x) {

for(int i=0;i<length;i++) Vek[i]+=x.Vek[i];

return *this;

}

...

... template class ...

file: vektor.tpl

template <class T> ostream&

operator<<(ostream &s,const Vektor<T> &x) {

s << "\n(" << x.Vek[0];

for(int i=0;i<x.length;i++)

s << ", "<< x.Vek[i] ;

s << ")";

return s << endl;

}

file: main.cpp

#include "vektor.tpl"

int main() {

Vektor<int> iv(5), iw(iv);

Vektor<double> dv(5), dw(dv);

iv += iw; dv += dw;

[1] cout << iv;

[2] cout << iw;

[3] cout << dv;

[4] cout << dw;

}

... template class

→ Output:

[1] (0, 0, 2, 2, 4)

[2] (0, 0, 1, 1, 2)

[3] (0, 1, 2, 3, 4)

[4] (0, 0.5, 1, 1.5, 2)