JK-Wiki edv:prg:cpp:crashkurs

edv:prg:cpp:crashkurs:part_01_intro

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:20+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 1 ======
	+
	+	C-Funktionen versus C++ globale Funktionen, Klassen-Funktionen und statische Klassen-Funktionen.
	+
	+	Ueb1.h:
	+
	+	<code c++>
	+	// File : Ueb1.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include "Ueb1.NameMangling.h"
	+
	+
	+	int _ueb (int argc, _TCHAR* argv[])
	+	{
	+	CFoo f;
	+
	+	Foo(); // C-Funktion
	+	Bah(); // Globale Funktion
	+	CFoo::Foo(); // Statische Funktion einer Klasse
	+	f.Bah(); // Methode einer Instanz
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb1.NameMangling.h:
	+
	+	<code c++>
	+	// File : Ueb1.NameMangling.h
	+	//
	+
	+	#include "Ueb1.PrintFunctionInfo.h"
	+
	+
	+	extern "C"
	+	{
	+	void Foo ()
	+	{
	+	PRINT_INFO("C-function Foo()");
	+	}
	+	}
	+
	+
	+	void Bah ()
	+	{
	+	PRINT_INFO("Global function Bah()");
	+	}
	+
	+
	+	class CFoo
	+	{
	+	public:
	+	static void Foo ()
	+	{
	+	PRINT_INFO("Static member function CFoo::Foo()");
	+	}
	+
	+	void Bah ()
	+	{
	+	PRINT_INFO("Member function CFoo::Bah()");
	+	}
	+	};
	+
	+	// EOF
	+	</code>
	+
	+	Ueb1.PrintFunctionInfo.h:
	+
	+	<code c++>
	+	// File : Ueb1.PrintFunctionInfo.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#define PRINT_INFO(header) PrintInfo(__FUNCTION__, __FUNCDNAME__, __FUNCSIG__, header)
	+
	+
	+	void PrintInfo (const char* FUNCTION, const char* FUNCDNAME, const char* FUNCSIG, const char* pszHeader)
	+	{
	+	std::cout << std::endl
	+	<< "Info: " << pszHeader << std::endl
	+	<< " Function name : " << FUNCTION << std::endl
	+	<< " Decorated function name: " << FUNCDNAME << std::endl
	+	<< " Function signature : " << FUNCSIG << std::endl;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Programm.cpp: - Der Einstiegspunkt
	+
	+	<code c++>
	+	// Programm.cpp : Defines the entry point for the console application.
	+	//
	+
	+	#include "stdafx.h"
	+
	+	#include "Ueb1.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

edv:prg:cpp:crashkurs:part_02_klassen_2a

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:22+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 2 ======
	+
	+	Beispiele für einige "Fallen", die durch unachtsame Programmierung (in C) entstehen können. Später - mit darauf folgenden Beispielen wird gezeigt, wie man solche Fallen mit C++-Mittel aus dem Weg räumen kann.
	+
	+	Ueb2a.h:
	+
	+	<code c++>
	+	// File : Ueb2a.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include "Ueb2a.VerketteteListe.h"
	+
	+	int _ueb (int argc, _TCHAR* argv[])
	+	{
	+	// Liste von ints anlegen
	+
	+	// Positiv-Fall: alles richtig gemacht
	+	LISTE* pListe = ErzeugeListe();
	+	InitialisiereListe(pListe);
	+	ElementAnhaengen(pListe, 4711);
	+	ElementAnhaengen(pListe, 815);
	+	ElementAnhaengen(pListe, 42);
	+
	+	std::cout << "Liste 1:" << std::endl;
	+
	+	for (LISTEN_ELEMENT* iter = pListe->pStart; iter != NULL; iter = iter->pNaechster)
	+	{
	+	std::cout << " " << iter->nInhalt << std::endl;
	+	}
	+
	+	ListeFreigeben(pListe);
	+	free(pListe);
	+
	+	// Böse 1: Liste nicht initialisiert
	+	LISTE* pListe2 = (LISTE*) malloc(sizeof(LISTE));
	+	ElementAnhaengen(pListe2, 4711);
	+
	+	// Böse 2: Liste ist NULL
	+	LISTE* pListe3 = NULL;
	+	ElementAnhaengen(pListe3, 4711);
	+
	+	// Böse 3: Listenelemente werden manipuliert
	+	LISTE* pListe4 = ErzeugeListe();
	+	InitialisiereListe(pListe4);
	+	ElementAnhaengen(pListe4, 4711);
	+	ElementAnhaengen(pListe4, 815);
	+	ElementAnhaengen(pListe4, 42);
	+
	+	std::cout << "Liste 1 manipuliert:" << std::endl;
	+	for (LISTEN_ELEMENT* iter = pListe4->pStart; iter != NULL; iter = iter->pNaechster)
	+	{
	+	iter->nInhalt += 9999;
	+	iter->pNaechster = pListe4->pStart;
	+	std::cout << " " << iter->nInhalt << std::endl;
	+	}
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb2a.VerketteteListe.h:
	+
	+	<code c++>
	+	// File : Ueb2a.VerketteteListe.h
	+	//
	+
	+	struct LISTEN_ELEMENT
	+	{
	+	int nInhalt;
	+	LISTEN_ELEMENT* pNaechster;
	+	};
	+
	+	struct LISTE
	+	{
	+	LISTEN_ELEMENT* pStart;
	+	};
	+
	+	LISTE* ErzeugeListe ()
	+	{
	+	LISTE* pListe = (LISTE*) malloc(sizeof(LISTE));
	+	pListe->pStart = NULL;
	+	return pListe;
	+	}
	+
	+	void InitialisiereListe (LISTE* pListe)
	+	{
	+	pListe->pStart = NULL;
	+	}
	+
	+	void ElementAnhaengen (LISTE* pListe, int nInhalt)
	+	{
	+	LISTEN_ELEMENT* pNeu = (LISTEN_ELEMENT*) malloc(sizeof(LISTEN_ELEMENT));
	+	pNeu->pNaechster = NULL;
	+	pNeu->nInhalt = nInhalt;
	+
	+	if (pListe->pStart == NULL)
	+	{
	+	pListe->pStart = pNeu;
	+	}
	+	else
	+	{
	+	LISTEN_ELEMENT* pLetztes = pListe->pStart;
	+
	+	while (pLetztes->pNaechster != NULL) pLetztes = pLetztes->pNaechster;
	+
	+	pLetztes->pNaechster = pNeu;
	+	}
	+	}
	+
	+	void ElementFreigeben (LISTEN_ELEMENT* pElement)
	+	{
	+	if (pElement->pNaechster != NULL) ElementFreigeben(pElement->pNaechster);
	+
	+	free(pElement);
	+	}
	+
	+	void ListeFreigeben (LISTE* pListe)
	+	{
	+	ElementFreigeben(pListe->pStart);
	+	}
	+
	+	// EOF
	+	</code>
	+
	+
	+	Programm.cpp: - Der Einstiegspunkt
	+
	+	<code c++>
	+	// Programm.cpp : Defines the entry point for the console application.
	+	//
	+
	+	#include "stdafx.h"
	+
	+	#include "Ueb2a.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

edv:prg:cpp:crashkurs:part_02_klassen_2b

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:21+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 3 ======
	+
	+	Die Listenimplementierung wird in eine Klasse "CListe" überführt. Dadurch entfällt die Initialisierung und Freigabe der inneren Struktur der Klasse. Diese Aufgabe übernehmen Constructor und Destructor.
	+
	+	Das schützt gegen vergessene Initialisierung und Freigebe des Speichers, hindert jedoch die fehlerhafte Datenmanipulation nicht.
	+
	+	Ueb2b.h:
	+
	+	<code c++>
	+	// File : Ueb2b.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include "Ueb2b.VerketteteListe.h"
	+
	+	using namespace Ueb2b;
	+
	+	int _ueb (int argc, _TCHAR* argv[])
	+	{
	+	CListe* pListe = new CListe();
	+	//InitialisiereListe(pListe); // Nicht mehr nötig - die Initialisierung geschieht im Constructor
	+	pListe->ElementAnhaengen(4711);
	+	pListe->ElementAnhaengen(815);
	+	pListe->ElementAnhaengen(42);
	+
	+	std::cout << "Liste 1:" << std::endl;
	+	for (LISTEN_ELEMENT* iter = pListe->pStart; iter != NULL; iter = iter->pNaechster)
	+	{
	+	std::cout << " " << iter->nInhalt << std::endl;
	+	}
	+
	+	//free(pListe); // free() wird duch delete ersetzt, so dass der Destructor der Klasse aufgerufen wird
	+	delete pListe;
	+	pListe = NULL;
	+
	+	// Böse 3: Listenelemente werden manipuliert
	+	CListe* pListe4 = new CListe();
	+	//InitialisiereListe(pListe4);
	+	pListe4->ElementAnhaengen(4711);
	+	pListe4->ElementAnhaengen(815);
	+	pListe4->ElementAnhaengen(42);
	+
	+	std::cout << "Liste 4 manipuliert:" << std::endl;
	+	for (LISTEN_ELEMENT* iter = pListe4->pStart; iter != NULL; iter = iter->pNaechster)
	+	{
	+	iter->nInhalt += 9999;
	+	iter->pNaechster = pListe4->pStart;
	+	std::cout << " " << iter->nInhalt << std::endl;
	+	}
	+	delete pListe4;
	+	pListe4 = NULL;
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb2b.VerketteteListe.h:
	+
	+	<code c++>
	+	// File : Ueb2b.VerketteteListe.h
	+	//
	+
	+	namespace Ueb2b
	+	{
	+	struct LISTEN_ELEMENT
	+	{
	+	int nInhalt;
	+	LISTEN_ELEMENT* pNaechster;
	+	};
	+
	+	class CListe
	+	{
	+	public:
	+	LISTEN_ELEMENT* pStart;
	+
	+	public:
	+	CListe ()
	+	{
	+	pStart = NULL;
	+	}
	+
	+	~CListe ()
	+	{
	+	ElementFreigeben(pStart);
	+	}
	+
	+	void ElementAnhaengen (int nInhalt)
	+	{
	+	LISTEN_ELEMENT* pNeu = (LISTEN_ELEMENT*) malloc(sizeof(LISTEN_ELEMENT));
	+	pNeu->pNaechster = NULL;
	+	pNeu->nInhalt = nInhalt;
	+
	+	if (pStart == NULL)
	+	{
	+	pStart = pNeu;
	+	}
	+	else
	+	{
	+	LISTEN_ELEMENT* pLetztes = pStart;
	+	while (pLetztes->pNaechster != NULL) pLetztes = pLetztes->pNaechster;
	+	pLetztes->pNaechster = pNeu;
	+	}
	+	}
	+
	+	private:
	+	void ElementFreigeben (LISTEN_ELEMENT* pElement)
	+	{
	+	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 "Ueb2b.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

edv:prg:cpp:crashkurs:part_02_klassen_2c

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:21+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== 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

edv:prg:cpp:crashkurs:part_02_klassen_2d

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:22+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 5 ======
	+
	+	Die Iteratoren und Listen hängen eng zusammen. Die Iteratoren sollten daher innerhalb der ListenKlasse untergebracht werden.
	+
	+	Ueb2d.h:
	+
	+	<code c++>
	+	// File : Ueb2d.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include "Ueb2d.VerketteteListe.h"
	+
	+	using namespace Ueb2d;
	+
	+	void ListeAusgeben (const CListe& 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[])
	+	{
	+	CListe liste1;
	+	liste1.ElementAnhaengen(4711);
	+	liste1.ElementAnhaengen(815);
	+	liste1.ElementAnhaengen(42);
	+
	+	// step 1:
	+	ListeAusgeben(liste1, "Liste 1:");
	+
	+	// step 2:
	+	{
	+	CListe liste2 = liste1;
	+	liste2.ElementAnhaengen(88);
	+	ListeAusgeben(liste2, "Liste 2:");
	+	}
	+	ListeAusgeben(liste1, "Liste 1 nach Liste 2:");
	+
	+	// step 3:
	+	{
	+	CListe liste3;
	+	liste3.ElementAnhaengen(77);
	+	liste3 = liste1;
	+	liste3.ElementAnhaengen(88);
	+	ListeAusgeben(liste3, "Liste 3:");
	+	}
	+	ListeAusgeben(liste1, "Liste 1 nach Liste 3:");
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb2d.VerketteteListe.h:
	+
	+	<code c++>
	+	// File : Ueb2d.VerketteteListe.h
	+	//
	+
	+	namespace Ueb2d
	+	{
	+	class CListe;
	+
	+	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; // Iterator muss das Listenelement kennen
	+
	+	public:
	+	CListeIterator (CListenElement* pElem)
	+	{
	+	element = pElem;
	+	}
	+
	+	bool operator!=(CListeIterator another) // Iterator muss zwei Elemente vergleichen können
	+	{
	+	return (this->element != another.element);
	+	}
	+
	+	CListeIterator& operator++() // Iterator muss zum nächsten Element wechseln können
	+	{
	+	element = element->GetNaechster();
	+
	+	return *this;
	+	}
	+
	+	int operator*() // Iterator muss den Inhalt aus dem referenzierten Element liefern können
	+	{
	+	return element->GetInhalt();
	+	}
	+	};
	+
	+	class CListe
	+	{
	+	public:
	+	CListenElement* pStart;
	+
	+	CListe ()
	+	{
	+	pStart = nullptr;
	+	}
	+
	+	CListe (const CListe& other) // Copy-Constructor: alle Elemente des other-Objekts werden kopiert
	+	{
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+	}
	+
	+	~CListe ()
	+	{
	+	delete pStart;
	+	pStart = nullptr;
	+	}
	+
	+	CListe& operator=(const CListe& other) // Zuweisungsoperator: alle Elemente des other-Objekts werden kopiert
	+	{
	+	if (pStart != nullptr) delete pStart;
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+
	+	return *this;
	+	}
	+
	+	CListeIterator begin () const // Liefert Referenz auf das erste Element
	+	{
	+	return CListeIterator(pStart);
	+	}
	+
	+	CListeIterator end () const // Liefert Referenz hinter dem letzten Element
	+	{
	+	return CListeIterator(nullptr);
	+	}
	+
	+	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;
	+	} // if
	+	}
	+	};
	+	}
	+
	+	// EOF
	+	</code>
	+
	+
	+	Programm.cpp: - Der Einstiegspunkt
	+
	+	<code c++>
	+	// Programm.cpp : Defines the entry point for the console application.
	+	//
	+
	+	#include "stdafx.h"
	+
	+	#include "Ueb2d.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

edv:prg:cpp:crashkurs:part_03_templates_3a

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:22+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 6 ======
	+
	+	Durch Templates schreibt man Klassen ohne sie an konkrete Datentypen zu binden. Der konkrete Typ wird in der Deklaration und Definition durch Platzhalter ersetzt.
	+
	+	Ueb3a.h:
	+
	+	<code c++>
	+	// File : Ueb3a.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include "Ueb3a.VerketteteListe.h"
	+
	+	using namespace Ueb3a;
	+
	+	#include <list>
	+
	+	int _ueb (int argc, _TCHAR* argv[])
	+	{
	+	// Lösung mit list kann _auch_ andere Datetypen:
	+	std::list<double> v;
	+	v.push_back(4711);
	+	v.push_back(0.815);
	+	v.push_back(42);
	+
	+	std::cout << "Liste mit vector<double>:" << std::endl;
	+	for (auto iter1 = v.begin(); iter1 != v.end(); iter1++)
	+	{
	+	std::cout << " " << *iter1 << std::endl;
	+	}
	+
	+	auto pListe = new CListe<double>();
	+	pListe->ElementAnhaengen(4711);
	+	pListe->ElementAnhaengen(0.815);
	+	pListe->ElementAnhaengen(42);
	+
	+	std::cout << "Liste mit double als Datentyp:" << std::endl;
	+	for (auto iter2 = pListe->begin(); iter2 != pListe->end(); ++iter2)
	+	{
	+	std::cout << " " << *iter2 << std::endl;
	+	}
	+
	+	delete pListe;
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb3a.VerketteteListe.h:
	+
	+	<code c++>
	+	// File : Ueb3a.VerketteteListe.h
	+	//
	+
	+	namespace Ueb3a
	+	{
	+	template<class TElement>
	+	class CListe
	+	{
	+	private:
	+	class CListenElement
	+	{
	+	friend CListe;
	+
	+	private:
	+	TElement nInhalt;
	+	CListenElement* pNaechster;
	+
	+	public:
	+	CListenElement (TElement newInhalt)
	+	{
	+	nInhalt = newInhalt;
	+	pNaechster = nullptr;
	+	}
	+
	+	~CListenElement ()
	+	{
	+	delete pNaechster;
	+	pNaechster = nullptr;
	+	}
	+
	+	TElement 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;
	+	}
	+
	+	TElement operator*()
	+	{
	+	return element->GetInhalt();
	+	}
	+	};
	+
	+	public:
	+	CListenElement* pStart;
	+
	+	CListe ()
	+	{
	+	pStart = nullptr;
	+	}
	+
	+	CListe (const CListe& other)
	+	{
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+	}
	+
	+	~CListe ()
	+	{
	+	delete pStart;
	+	pStart = nullptr;
	+	}
	+
	+	CListe& operator=(const CListe& other)
	+	{
	+	if (pStart != nullptr) delete pStart;
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+
	+	return *this;
	+	}
	+
	+	CListeIterator begin () const
	+	{
	+	return CListeIterator(pStart);
	+	}
	+
	+	CListeIterator end () const
	+	{
	+	return CListeIterator(nullptr);
	+	}
	+
	+	void ElementAnhaengen (TElement nInhalt)
	+	{
	+	auto pNeu = new 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 "Ueb3a.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

edv:prg:cpp:crashkurs:part_04_stl_4a

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:21+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 7 ======
	+
	+	STL - Verwendung von "std::string".
	+
	+	Ueb4a.h:
	+
	+	<code c++>
	+	// File : Ueb4a.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include "Ueb4a.VerketteteListe.h"
	+
	+	#include <string>
	+
	+	using namespace Ueb4a;
	+
	+	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 = new CListe<std::string>();
	+
	+	pListe1->ElementAnhaengen("47-11");
	+	pListe1->ElementAnhaengen("0-8-15");
	+	pListe1->ElementAnhaengen("Die Antwort auf alle Fragen...");
	+
	+	ListeAusgeben(*pListe1, "Liste mit Zeichenketten:");
	+
	+	delete pListe1;
	+
	+	// ------------
	+
	+	auto pListe2 = new CListe<std::string>();
	+	char buffer[1024];
	+
	+	strcpy_s(buffer, sizeof(buffer), "47-11");
	+	pListe2->ElementAnhaengen(buffer);
	+
	+	strcpy_s(buffer, sizeof(buffer), "0-8-15");
	+	pListe2->ElementAnhaengen(buffer);
	+
	+	strcpy_s(buffer, sizeof(buffer), "Die Antwort auf alle Fragen...");
	+	pListe2->ElementAnhaengen(buffer);
	+
	+	ListeAusgeben(*pListe2, "Liste mit _dynamischen_ Zeichenketten:");
	+
	+	delete pListe2;
	+
	+	// ------------
	+
	+	auto pListe3 = new CListe<std::string>();
	+
	+	std::string buffer2;
	+	for (int i = 0; i < 5; ++i)
	+	{
	+	buffer2 = std::to_string(i + 1);
	+	pListe3->ElementAnhaengen("Eintrag #" + buffer2 + "...");
	+	}
	+
	+	ListeAusgeben(*pListe3, "Liste mit berechneten Zeichenketten:");
	+
	+	delete pListe3;
	+
	+	return 0;
	+
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb4a.VerketteteListe.h:
	+
	+	<code c++>
	+	// File : Ueb4a.VerketteteListe.h
	+	//
	+
	+	namespace Ueb4a
	+	{
	+	template<class TElement>
	+	class CListe
	+	{
	+	private:
	+	class CListenElement
	+	{
	+	friend CListe;
	+
	+	private:
	+	TElement nInhalt;
	+	CListenElement* pNaechster;
	+
	+	public:
	+	CListenElement (TElement newInhalt)
	+	{
	+	nInhalt = newInhalt;
	+	pNaechster = nullptr;
	+	}
	+
	+	~CListenElement ()
	+	{
	+	delete pNaechster;
	+	pNaechster = nullptr;
	+	}
	+
	+	TElement 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;
	+	}
	+
	+	TElement operator*()
	+	{
	+	return element->GetInhalt();
	+	}
	+	};
	+
	+	public:
	+	CListenElement* pStart;
	+
	+	CListe ()
	+	{
	+	pStart = nullptr;
	+	}
	+
	+	CListe (const CListe& other)
	+	{
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+	}
	+
	+	~CListe ()
	+	{
	+	delete pStart;
	+	pStart = nullptr;
	+	}
	+
	+	CListe& operator=(const CListe& other)
	+	{
	+	if (pStart != nullptr) delete pStart;
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+
	+	return *this;
	+	}
	+
	+	CListeIterator begin () const
	+	{
	+	return CListeIterator(pStart);
	+	}
	+
	+	CListeIterator end () const
	+	{
	+	return CListeIterator(nullptr);
	+	}
	+
	+	void ElementAnhaengen (TElement nInhalt)
	+	{
	+	auto pNeu = new 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 "Ueb4a.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

edv:prg:cpp:crashkurs:part_04_stl_4b

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:21+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== 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

edv:prg:cpp:crashkurs:part_04_stl_4c

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:22+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 9 ======
	+
	+	Weitere Ausbaustufe mit Templates.
	+
	+	Ueb4c.h:
	+
	+	<code c++>
	+	// File : Ueb4c.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include <string>
	+	#include <vector>
	+	#include <list>
	+	#include <map>
	+
	+	// Damit man nicht für jeden Typ eine eigene Bearbeitungsfunktion schreiben muss...
	+
	+	//template<class T>
	+	//void ListeAusgeben (const std::vector<T>& liste, const char* pszHeader)
	+	//{
	+	// std::cout << pszHeader << std::endl;
	+	// for (auto iter = liste.begin(); iter != liste.end(); ++iter)
	+	// {
	+	// std::cout << " " << *iter << std::endl;
	+	// }
	+	//}
	+	//
	+	//template<class T>
	+	//void ListeAusgeben (const std::list<T>& liste, const char* pszHeader)
	+	//{
	+	// std::cout << pszHeader << std::endl;
	+	// for(auto iter = liste.begin(); iter != liste.end(); ++iter)
	+	// {
	+	// std::cout << " " << *iter << std::endl;
	+	// }
	+	//}
	+
	+	// ...man legt auch für die Argumente ein Template an:
	+	template<class T>
	+	void ListeAusgeben (const T& container, const char* pszHeader)
	+	{
	+	std::cout << pszHeader << std::endl;
	+	// ! korrekt, es geht aber besser
	+	//for (auto iter = container.begin(); iter != container.end(); ++iter)
	+	// ! so ist sicherer, weil auch mit Objekten funktioniert, die keine Methoden begin() und end() haben
	+	for (auto iter = std::begin(container); iter != std::end(container); ++iter)
	+	{
	+	std::cout << " " << *iter << std::endl;
	+	}
	+	}
	+
	+
	+	// Für Typen mit mehreren Werten
	+	template<class _Ty1, class _Ty2>
	+	std::ostream& operator << (std::ostream& strm, const std::pair<_Ty1, _Ty2>& pair)
	+	{
	+	strm << "key = " << pair.first << "; value = " << pair.second;
	+	return strm;
	+	}
	+
	+
	+	int _ueb (int argc, _TCHAR* argv[])
	+	{
	+	auto pVector = std::vector<std::string>(); // Vector mit Strings
	+
	+	//pVector->ElementAnhaengen("47-11");
	+	//pVector->ElementAnhaengen("0-8-15");
	+	//pVector->ElementAnhaengen("Die Antwort auf alle Fragen...");
	+	pVector.push_back("47-11");
	+	pVector.push_back("0-8-15");
	+	pVector.push_back("Die Antwort auf alle Fragen...");
	+
	+	//ListeAusgeben(*pVector, "vector<>");
	+	ListeAusgeben(pVector, "vector<>");
	+
	+	std::cout << pVector[2];
	+
	+	//delete pVector;
	+
	+	// -----
	+
	+	auto pList = std::list<std::string>(); // Liste mit Strings
	+
	+	//pList->ElementAnhaengen("47-11");
	+	//pList->ElementAnhaengen("0-8-15");
	+	//pList->ElementAnhaengen("Die Antwort auf alle Fragen...");
	+	pList.push_back("47-11");
	+	pList.push_back("0-8-15");
	+	pList.push_back("Die Antwort auf alle Fragen...");
	+
	+	ListeAusgeben(pList, "list<>");
	+
	+	//delete pList;
	+
	+	auto pMap = std::map<std::string, int>(); // Map mit Strings/Zahlen
	+
	+	pMap["AA"] = 123;
	+	pMap["BB"] = 456;
	+	pMap["CC"] = 789;
	+
	+	ListeAusgeben(pMap, "map<>");
	+
	+	auto pMap2 = std::map<std::string, std::string>(); // Map mit Strings/Strings
	+
	+	pMap2["AA"] = "aaaaaaaaaa";
	+	pMap2["BB"] = "xxxxxxxxxxxx";
	+	pMap2["CC"] = "cccccccccccccc";
	+
	+	ListeAusgeben(pMap2, "map2<>");
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Programm.cpp: - Der Einstiegspunkt
	+
	+	<code c++>
	+	// Programm.cpp : Defines the entry point for the console application.
	+	//
	+
	+	#include "stdafx.h"
	+
	+	#include "Ueb4c.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

edv:prg:cpp:crashkurs:part_05_exceptions_5a

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:21+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== C++ Crashkurs / Übung 10 ======
	+
	+	Exceptions.
	+
	+	Ueb5a.h:
	+
	+	<code c++>
	+	// File : Ueb5a.h
	+	//
	+
	+	#include "..\stdafx.h"
	+
	+	#include <memory>
	+
	+	#include "Ueb5a.VerketteteListe.h"
	+
	+	using namespace Ueb5a;
	+
	+	#include <list>
	+
	+	void Test ()
	+	{
	+	CListe<int>* pListe= new CListe<int>();
	+
	+	try
	+	{
	+	pListe->ElementAnhaengen(4711);
	+	pListe->ElementAnhaengen(815);
	+	pListe->ElementAnhaengen(42);
	+	pListe->ElementAnhaengen(0);
	+
	+	std::cout << "Liste iteriert mit prefix-operator:" << std::endl;
	+	for (auto iter2 = pListe->begin(); iter2 != pListe->end(); ++iter2)
	+	{
	+	std::cout << " " << *iter2 << std::endl;
	+	}
	+	}
	+	catch (std::string ex) // Exceptions vom Typ std::string fangen
	+	{
	+	std::cerr << "Exception: " << ex.c_str() << std::endl;
	+	auto s = std::string("Ein Fehler in ");
	+	s += ((const char*) __FUNCTION__);
	+	s += "aufgetreten.";
	+	throw s; // Exception werfen
	+	//throw; // Ohne Argumente gibt einfach die urspruengliche Exception weiter
	+	}
	+
	+	delete pListe;
	+	}
	+
	+	int _ueb (int argc, _TCHAR* argv[])
	+	{
	+	try
	+	{
	+	Test();
	+	}
	+	catch (...) // Exceptions beliebiger Typs fangen
	+	{
	+	std::cerr << "Im Programm ist irgendein Fehler aufgetreten..." << std::endl;
	+	}
	+
	+	return 0;
	+	}
	+
	+	// EOF
	+	</code>
	+
	+	Ueb5a.VerketteteListe.h:
	+
	+	<code c++>
	+	// File : Ueb5a.VerketteteListe.h
	+	//
	+
	+	namespace Ueb5a
	+	{
	+	template<class TElement>
	+	class CListe
	+	{
	+	private:
	+	class CListenElement
	+	{
	+	friend CListe;
	+
	+	private:
	+	TElement nInhalt;
	+	std::shared_ptr<CListenElement> pNaechster;
	+
	+	public:
	+	CListenElement (TElement newInhalt)
	+	{
	+	int iTmp;
	+
	+	nInhalt = newInhalt;
	+
	+	iTmp = 100 / nInhalt; // Exception provozieren
	+	if (iTmp > 0) iTmp++;
	+	}
	+
	+	~CListenElement ()
	+	{
	+	}
	+
	+	TElement GetInhalt ()
	+	{
	+	return nInhalt;
	+	}
	+
	+	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().get();
	+
	+	return *this;
	+	}
	+
	+	TElement operator*()
	+	{
	+	return element->GetInhalt();
	+	}
	+	};
	+
	+	public:
	+	std::shared_ptr<CListenElement> pStart;
	+
	+	CListe ()
	+	{
	+	}
	+
	+	CListe (const CListe& other)
	+	{
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+	}
	+
	+	CListe& operator=(const CListe& other)
	+	{
	+	pStart = nullptr;
	+
	+	for (auto iter = other.begin(); iter != other.end(); ++iter) ElementAnhaengen(*iter);
	+
	+	return *this;
	+	}
	+
	+	CListeIterator begin () const
	+	{
	+	return CListeIterator(pStart.get());
	+	}
	+
	+	CListeIterator end () const
	+	{
	+	return CListeIterator(nullptr);
	+	}
	+
	+	void ElementAnhaengen (TElement nInhalt)
	+	{
	+	if (nInhalt == 0) throw std::string("DIV0"); // Exception werfen
	+
	+	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 "Ueb5a.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