daten2.h ----------------------------------------------------------------------------------------------------------
#include <iostream>
using namespace std;
#ifndef DATEN2_H_
#define DATEN2_H_

class Daten{
	private:
		int iwert;
	public:
		Daten(int iVal):iwert(iVal){
			cout << "Objekt [Daten] erzeugt\n";
		}
		~Daten(){}
		int vergleichen(const Daten&);
		void anzeigen() const;
		int get_iwert() const { return iwert; }
		friend bool operator <(const Daten& Dobj1, const Daten& Dobj2){
			if(Dobj1.iwert < Dobj2.iwert)
			{
				return true;
			}else{
				return false;
			}
		}
		friend bool operator ==(const Daten& Dobj1, const Daten& Dobj2){
			if(Dobj1.iwert == Dobj2.iwert){
				return true;
			}else{
				return false;
			}
		}
};

int Daten::vergleichen(const Daten& d){
	if(iwert > d.iwert){ 
		return 1; 
	}else if(iwert < d.iwert){
		return -1;
	}
	return 0;
}

void Daten::anzeigen() const{
	cout << iwert << '\n' << endl;
}
#endif
daten2.h END ----------------------------------------------------------------------------------------------------
temp.h ----------------------------------------------------------------------------------------------------------
#include <iostream>
#include <cstring>
using namespace std;
#ifndef TEMP_H_
#define TEMP_H_

class Temperatur{
	private:
		int grad;
		char monat[20];
	public:
		Temperatur(int iVal, char* m=""):grad(iVal)
		{
			strncpy(monat, m, 20);
			cout << "Objekt [Temperatur] erzeugt\n";
		}
		~Temperatur(){}
		int vergleichen(const Temperatur&);
		void anzeigen() const;
		friend bool operator <(const Temperatur& Tobj1, const Temperatur& Tobj2){
			if(Tobj1.grad < Tobj2.grad)
			{
				return true;
			}else{
				return false;
			}
		}
		friend bool operator ==(const Temperatur& Tobj1, const Temperatur& Tobj2){
			return(!(strcmp(Tobj1.monat, Tobj2.monat)));
		}
};

int Temperatur::vergleichen(const Temperatur& d){
	if(grad > d.grad){
		return 1;
	}else if(grad < d.grad){
		return -1;
	}
	return 0;
}

void Temperatur::anzeigen() const{
	cout << monat << " : " << grad << '\n';
}
#endif
temp2.h END -----------------------------------------------------------------------------------------------------
main.cpp --------------------------------------------------------------------------------------------------------
#include <list>
#include <iostream>
#include "daten2.h"
#include "temp.h"
using namespace std;

void input_func(list<Temperatur>& tempList);
void input_func(list<Daten>& datenList);
void alles_anzeigen(list<Daten>& ref1, list<Temperatur>& ref2);

int main(){
	//Verkettete Listen der Klassen 'Daten' und 'Temperatur'
	list<Daten> dElemente;
	list<Temperatur> tElemente;
	
	input_func(dElemente);
	input_func(tElemente);
	
	cout << "Listen werden sortiert ...\n";
	// Jetzt wird der operator < benoetigt
	dElemente.sort();
	tElemente.sort();
	
	alles_anzeigen(dElemente, tElemente);
	
	// Die Komplette liste neu zuweisen
	list<Daten> dElementeNeu = dElemente;
	if(dElementeNeu.empty()){
		cout << "\ndElementeNeu ist leer\n";
	}else{
		cout << "\ndElementeNeu konnte nicht geleert werden\n";
	}
	
	cout << "\nDrehe die Listen um ...\n";
	// reverse dreht die ganze Sache auf den Kopf
	dElemente.reverse();
	tElemente.reverse();
	alles_anzeigen(dElemente, tElemente);
	
	cout << "\nEntferne doppelte Eintraege ...\n";
	// Doppelte Eintraege werden dank unique entfernt
	dElemente.unique();
	tElemente.unique();
	alles_anzeigen(dElemente, tElemente);
	
	cout << "\nListe <Daten> mischen ...\n";
	// Liste wird gemischt und sortiert
	dElemente.merge(dElementeNeu);
	dElemente.sort();
	alles_anzeigen(dElemente, tElemente);
	
	if(dElementeNeu.empty()){
		cout << "\ndElementeNeu ist leer\n";
	}else{
		cout << "\ndElementeNeu konnte nicht geleert werden\n";
	}
	
	// Liste des Typs Daten mit 3 Elementen mit dem Wert 111 erzeugen
	list<Daten> dElementeGanzNeu(3, Daten(111));
	
	// Inhalt von dElementeGanzNeu am Anfang von dElemente einfuegen
	cout << "3 Elemente am anfang von <Daten> einfuegen ...\n";
	dElemente.splice(dElemente.begin(), dElementeGanzNeu);
	alles_anzeigen(dElemente, tElemente);
	return 0;
}

// Fuktion zum Einlesen der Eigenschaften fuer Temperatur
void input_func(list <Temperatur>& tempList){
	int grad;
	char monat[20];
	for(;;){
		cout << "Monat eingeben: ";
		if((!(cin >> monat))){
			strcpy(monat,"keine Angabe");
		}
		cout << "Temperatur eingeben ( 0-70C ( 99=Ende ) ): ";
		if((!(cin >> grad))||grad==99){
			break;
		}
		if(grad > 70||grad<0){
			grad=30;
		}
		tempList.push_back(Temperatur(grad,monat));
	}
}
void input_func(list <Daten>& datenList){
	int iwert;
	for(;;){
		cout << "Wert eingeben (0=Ende): ";
		if((!(cin >> iwert))||iwert==0){
			break;
		}
		datenList.push_back(Daten(iwert));
	}
}

void alles_anzeigen(list<Daten>& ref1, list<Temperatur>& ref2){
	for(list<Daten>::iterator iter = ref1.begin();
	    iter!=ref1.end(); ++iter){
		iter->anzeigen();
	}
	for(list<Temperatur>::iterator iter = ref2.begin();
	    iter!=ref2.end(); ++iter){
		iter->anzeigen();
	}
}
main.cpp END -----------------------------------------------------------------------------------------------------------------