====== C++ Crashkurs / Übung 8 ======

Smart-Pointer und Templates mit verschachtelten Typen.

**Ueb4b.h:**

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

#include "..\stdafx.h"

#include <string>
#include <memory>

#include "Ueb4b.VerketteteListe.h"

using namespace Ueb4b;

template<class T>
void ListeAusgeben (const CListe<T>& liste, const char* pszHeader)
{
	std::cout << pszHeader << std::endl;
	for (auto iter = liste.begin(); iter != liste.end(); ++iter)
	{
		std::cout << "    " << *iter << std::endl;
	}
}


int _ueb (int argc, _TCHAR* argv[])
{
	auto pListe1 = std::make_shared<CListe<std::string>>();

	pListe1->ElementAnhaengen("47-11");
	pListe1->ElementAnhaengen("0-8-15");
	pListe1->ElementAnhaengen("Die Antwort auf alle Fragen...");

	ListeAusgeben(*pListe1, "Liste:");

//	delete pListe1; // Wird durch Smart Pointer automatisch erledigt

	return 0;
}

// EOF
</code>

**Ueb4b.VerketteteListe.h:**

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

namespace Ueb4b
{
	template<class TElement>
	class CListe
	{
	private:
		class CListenElement
		{
		friend CListe;

		private:
			TElement nInhalt;
//			CListenElement*	pNaechster;
			std::shared_ptr<CListenElement> pNaechster;

		public:
			CListenElement (TElement newInhalt)
			{
				nInhalt = newInhalt;
//				pNaechster = nullptr; // Initialisierung erfolgt durch Smart Pointer
			}

			~CListenElement ()
			{
//				delete pNaechster; // Keine Freigabe nötig - das erledigt der Destructor von dem Smart Pointer
//				pNaechster = nullptr;
			}

			TElement GetInhalt ()
			{
				return nInhalt;
			}

//			CListenElement* GetNaechster ()
			std::shared_ptr<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();
				element = element->GetNaechster().get();

				return *this;
			}

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

	public:
//		CListenElement* pStart;
		std::shared_ptr<CListenElement> pStart;

		CListe ()
		{
//			pStart = nullptr;
		}

		CListe (const CListe& other)
		{
//			pStart = nullptr;

			for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
		}

//		~CListe () // Destructor kann wegfallen, weil sowieso leer.
//		{
//			delete pStart;
//			pStart = nullptr;
//		}

		CListe& operator=(const CListe& other)
		{
//			if (pStart != nullptr) delete pStart;
			pStart = nullptr; // Freigabe erfolgt automatisch

			for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);

			return *this;
		}

		CListeIterator begin () const
		{
//			return CListeIterator(pStart);
			return CListeIterator(pStart.get());
		}

		CListeIterator end () const
		{
			return CListeIterator(nullptr);
		}

		void ElementAnhaengen(TElement nInhalt)
		{
//			auto pNeu = new CListenElement(nInhalt);
			auto pNeu = std::make_shared<CListenElement>(nInhalt);

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

	};
}

// EOF
</code>


**Programm.cpp:** - Der Einstiegspunkt

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

#include "stdafx.h"

#include "Ueb4b.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