====== C++ Crashkurs / Übung 4 ======

Lösung mit "list" (doppelt verkettete Liste). Iteratoren.

**Ueb2c.h:**

<code c++>
// File : Ueb2c.h
//

#include "..\stdafx.h"

#include "Ueb2c.VerketteteListe.h"

using namespace Ueb2c;

#include <list>

int _ueb (int argc, _TCHAR* argv[])
{
	// Lösung mit list (doppelt verkettete Liste):
	std::list<int> v;
	v.push_back(4711); // push_back() - Element am Ende der Kette anhängen
	v.push_back(815);
	v.push_back(42);

	std::cout << "Liste mit vector:" << std::endl;
	for (auto iter1 = v.begin(); iter1 != v.end(); iter1++)
	{
		std::cout << "    " << *iter1 << std::endl;
	}

	CListe* pListe = new CListe();
	pListe->ElementAnhaengen(4711);
	pListe->ElementAnhaengen(815);
	pListe->ElementAnhaengen(42);

	std::cout << "Liste iteriert mit prefix-operator:" << std::endl;
	for (auto iter2 = pListe->begin(); iter2 != pListe->end(); ++iter2)
	{
		std::cout << "    " << *iter2 << std::endl;
	}
	std::cout << "Liste iteriert mit postfix-operator:" << std::endl;
	for (auto iter3 = pListe->begin(); iter3 != pListe->end(); iter3++)
	{
		std::cout << *iter3 << std::endl;
	}

	delete pListe;

	return 0;
}

// EOF
</code>

**Ueb2c.VerketteteListe.h:**

<code c++>
// File : Ueb2c.VerketteteListe.h
//

namespace Ueb2c
{
	class CListe; // Vorabdeklaration

	class CListenElement
	{
	friend CListe;

	private:
		int		nInhalt;
		CListenElement*	pNaechster;

	public:
		CListenElement (int newInhalt)
		{
			nInhalt = newInhalt;
			pNaechster = nullptr;
		}

		~CListenElement ()
		{
			delete pNaechster;
			pNaechster = nullptr;
		}

		int GetInhalt ()
		{
			return nInhalt;
		}

		CListenElement* GetNaechster ()
		{
			return pNaechster;
		}
	};

	class CListeIterator
	{
	private:
		CListenElement* element;

	public:
		CListeIterator (CListenElement* pElem)
		{
			element = pElem;
		}

		bool operator!=(CListeIterator another)
		{
			return (this->element != another.element);
		}

		CListeIterator& operator++()
		{
			element = element->GetNaechster();

			return *this;
		}

		int operator*()
		{
			return element->GetInhalt();
		}
	};

	class CListe
	{
	public:
//		struct LISTEN_ELEMENT	// Nicht mehr nötig
//		{
//			int		nInhalt;
//			LISTEN_ELEMENT*	pNaechster;
//		};

		CListenElement*	pStart;

		CListe ()
		{
			pStart = nullptr;
		}
		
		~CListe ()
		{
			delete pStart;
			pStart = nullptr;
		}

		CListeIterator begin ()
		{
			return CListeIterator(pStart);
		}

		CListeIterator end () // Soll die Position "hinter" dem letzten Elemen liefern
		{
//			CListenElement* pLetztes = pStart;	// Nicht mehr nötig
//			while (pLetztes->GetNaechster() != nullptr) pLetztes = pLetztes->GetNaechster();

//			return CListeIterator(pLetztes->GetNaechster());
			return CListeIterator(nullptr); // Am Ende der Kette liefert GetNaechster() immer nullptr zurück
		}

		void ElementAnhaengen (int nInhalt)
		{
			auto pNeu = new CListenElement(nInhalt);

			if (pStart == nullptr)
			{
				pStart = pNeu;
			}
			else
			{
				CListenElement* pLetztes = pStart;
				while (pLetztes->GetNaechster() != nullptr) pLetztes = pLetztes->GetNaechster();
				pLetztes->pNaechster = pNeu;
			}
		}

	private:
//		void ElementFreigeben (LISTEN_ELEMENT* pElement) // Nicht mehr nötig - das übernimmt der Destructor
//		{
//			if (pElement->pNaechster != NULL) ElementFreigeben(pElement->pNaechster);
//			free(pElement);
//			pElement = NULL;
//		}
	};

}

// EOF
</code>


**Programm.cpp:** - Der Einstiegspunkt

<code c++>
// Programm.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include "Ueb2c.h"

int _tmain (int argc, _TCHAR* argv[])
{
	return _ueb(argc, argv);
}

// EOF
</code>

**stdafx.h:**

<code c>
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//

#pragma once

#include "targetver.h"

#include <stdio.h>
#include <tchar.h>

// TODO: reference additional headers your program requires here

#include <malloc.h>
#include <iostream>

// EOF
</code>

**targetver.h:**

<code c>
// Including SDKDDKVer.h defines the highest available Windows platform.

// If you wish to build your application for a previous Windows platform, include WinSDKVer.h and
// set the _WIN32_WINNT macro to the platform you wish to support before including SDKDDKVer.h.

#pragma once

#include <SDKDDKVer.h>
</code>

----
Stand: 19.09.2014
 --- //[[feedback.jk-wiki@kreick.de|: Jürgen Kreick]]//

EOF