LZW-algorithmus/CArray.hpp at master · bone4/LZW-algorithmus · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/*
 * cArray.hpp
 *
 *  Created on: 11.05.2015
 *      Author: cge0496
 */
/*!
 * \file CArray.hpp
 * \brief Definition des Klassentemplates CArray
*/

#ifndef CARRAY_HPP_
#define CARRAY_HPP_


#include "XOutOfBounds.hpp"


/*!
 * \class CArray
 * \brief Klassentemplate für ein 1 dimensionales Array vom Typ T mit N Feldern
 * Eine Klasse, die über den Konstruktor ein Array dynamisch allokiert, über den Destruktor wieder frei gibt und Methoden zum Zugriff bereit stellt.
 * Jedes angelegte Array (Instanz/Objekt der Klasse) ist vom Typ T, z.B. int, float oder double, und enthält N Felder, von 0 bis N-1.
*/
template <typename T, unsigned int N>
class CArray
{
public:
	CArray();						//!< Konstruktor, legt ein Array an / reserviert Speicher
	CArray(const CArray&);			//!< Kopierkonstruktor
	virtual ~CArray();				//!< Destruktor, gibt das Array wieder frei
	T& operator[](unsigned int);	//!< Methode für den Zugriff auf einzelne Spcherzellen
private:
	T *entries;						//!< privater Pointer auf die Startadresse des Arrays
};

/*!
 * Konstruktor, initialisiert den privaten Speicher mit der Speicheradresse des zugeteilten Arrayspcherplatzes
 */
template <typename T, unsigned int N>
CArray<T,N>::CArray(): entries(new T[N])
{
}

/*!
 * Kopierkonstruktor
 * aktuell ist der Kopierkonstruktor für tiefe Kopien aktiv,
 * d.h. es wird ein komplett neues Array erstellt und alle Inhalte werden kopiert,
 * statt nur einen neuen Pointer auf das Startelement zu erstellen.
 * @param other
 */
// Kopierkonstruktor mit flacher Kopie
/*
template <typename T, unsigned int N>
CArray<T,N>::CArray(const CArray& other): entries(other.entries)
{
}
*/
// Kopierkonstruktor mit tiefer Kopie
template <typename T, unsigned int N>
CArray<T,N>::CArray(const CArray& other): entries(new T[N])
{
	int i;
	for (i=0;i<N;i++) entries[i]=other.entries[i];
}

/*!
 * Destruktor, gibt den reservierten Speicherplatz wieder frei
 */
template <typename T, unsigned int N>
CArray<T,N>::~CArray() {
	delete [] entries;
}
/*!
 * Operator[x], gibt den Inhalt an x. Speicheradresse zurück (WICHTIG: Zählung von 0 bis N-1)
 * @param Z
 * @return Speicherinhalt vom Typ T
 */
template <typename T, unsigned int N>
T& CArray<T,N>::operator[](unsigned int Z) {
	if (Z >= N) throw XOutOfBounds("Außerhalb des Arrays");
	else return entries[Z];
}


#endif /* CARRAY_HPP_ */