003
09.11.2009, 12:04 Uhr
ao
(Operator)
|
Code-Redundanz ist (fast) immer schlecht. Du könntest eine weitere Klasse einführen, die nur die relevanten Implementierungen enthält. Etwa so (ohne Test hingekritzelt):
| C++: |
template<typename _Ty>
class Interface
{
public:
virtual operator _Ty* (void) = 0;
virtual _Ty summe(void) = 0;
};
// eine Impl.-Klasse, die die Funktionen statisch implementiert
template<typename _Ty, size_t _n>
class ArrayImpl
{
public:
// Hier steckt an zentraler Stelle das Knowhow,
// wie eine Array-Summe berechnet wird
static _Ty summe (_Ty * array, size_t len)
{
_Ty result = 0;
for (int i = 0; i < len; i++)
{
result += array[i];
}
return result;
}
};
// Realisierung eines statischen Arrays
template<typename _Ty, size_t _n>
class Statisch : public Interface<_Ty>
{
private:
enum { _elCount = _n };
_Ty _array[_n > 0 ? _n : 1];
protected:
enum { _elSize = sizeof(_Ty) };
public:
// Konstruktion eines statischen Arrays
Statisch(void)
{
memset (_array, 0, sizeof (_array));
}
// Summe über das Array: ArrayImpl aufrufen
virtual _Ty summe(void)
{
return ArrayImpl::summe (_array, _n);
}
};
// Realisierung eines dynamischen Arrays
template<typename _Ty>
class Dynamisch : public Interface<_Ty>
{
private:
_Ty* _array;
size_t len;
public:
// Konstruktion eines dynamischen Arrays
// Unterschied zum statischen: Die Länge zur Compilezeit unbekannt
// und wird daher zur Laufzeit festgehalten.
Dynamisch(size_t n)
: _array(new _Ty[n]())
, len (n)
{
memset(_array, 0, sizeof (*_array) * n);
}
~Dynamisch(void) {
delete[] this->_array;
}
// Summe über das Array: ArrayImpl aufrufen.
virtual _Ty summe(void)
{
return ArrayImpl::summe (_array, len);
}
};
|
Dieser Post wurde am 09.11.2009 um 12:05 Uhr von ao editiert. |
