designfrage templates

miller_m

wie immer interessieren mich design fragen mehr als alles andere. nun zu meiner
neusten

beispiel 1:

template<
	class Renderdata_,
	class RendererSortFunc_,
	template<class, class> class Renderqueue_>
class Renderer
{
    private:
	Renderqueue_<
		Renderdata_,
		RendererSortFunc_>	m_Queue;
};

nachteile:
- vofür brauch der renderer den tp RendererSortFunc_? (schon klar wofür allerdings habe ich ein tp mehr)
- falls der user wünscht eine eiges implementierte queue zu verwenden muss
diese zwei tp übernehmen

bespiel 2:

template<
	class Renderdata_,
	class Renderqueue_,
class Renderer
{
	public:
		explicit Renderer(const Renderqueue_ *pQueue) // ..

nachteil:
- fehler anfälliger da die queue und der renderer mit der gleichen Renderdata_ klasse arbeiten sollten

hoffe habe mich verständlich ausgedrückt. meinungen, wünsche, kritik, vorschläge
bitte jetzt.

evilissimo

Naja Generell muss der jenige der die Queue neu bauen will, einfach nur 2 template parameter zur Verfügung stellen, ob er diese verwendet ist ansich sein Bier, aber das wäre auch irgendwie ziemlich dumm das net zu tun. Also seine Klasse nicht gleich Generisch zu gestalten.

MfG

miller_m

diese meinung vertrette ich eigentlich auch.
aber stellt sich die frage wenn er mehr tp für seine queue braucht?
wenn er weniger braucht mach er halt nen dummy tp mit rein, aber sollte man
dem user so etwas zu muten können?
wie findest du das die instanzierung innerhalb der renderer klasse, dacht mir
das dieses ein vernüntiger weg den der user sollte eigentlich nicht direkt
in die queue eingreifen können.
vielleicht mach ich mir auch zu viel gedanken über das design.

evilissimo

aber stellt sich die frage wenn er mehr tp für seine queue braucht?

Da geht mehr als du denkst -.-
Das ist ein nicht getestetes Beispiel aber soll dir nur grob zeigen das es geht:

template < typename NormalType , typename Additional1Type > struct TypeDummy1{};
template < typename NormalType , typename Additional1Type , typename Additional2Type > struct TypeDummy2{};

struct Additional1{};
struct Additional2{};
struct Normal{};

template<
    class Renderdata_,
    class RendererSortFunc_,
    template<class, class> class Renderqueue_>
class Renderer
{
    private:
    Renderqueue_<
        Renderdata_,
        RendererSortFunc_>    m_Queue;
};

template < typename DataType , typename ParamTypes >
struct Renderqueue
{
  typedef typename ParamTypes::normal_type      normal_type;
  typedef DataType                              value_type
};

template < typename DataType , typename ParamTypes >
struct Renderqueue1
{
  typedef typename ParamTypes::normal_type      normal_type;
  typedef typename ParamTypes::additional1_type additional1_type;
  typedef DataType                              value_type
};

template < typename DataType , typename ParamTypes >
struct Renderqueue2
{
  typedef typename ParamTypes::normal_type      normal_type;
  typedef typename ParamTypes::additional1_type additional1_type;
  typedef typename ParamTypes::additional2_type additional2_type;
  typedef DataType                              value_type
};

typedef Renderer<int,Normal,Renderqueue> IntRendererNormal;
typedef Renderer<int, TypeDummy1< Normal , Additional1 > , Renderqueue1 >IntRenderer1ParamExtra;
typedef Renderer<int, TypeDummy2< Normal , Additional1 , Additional2 > , Renderqueue2 >IntRenderer2ParamsExtra;

evilissimo

aber sollte man dem user so etwas zu muten können?

für den 08/15 User sollten schon ordentliche Typedefs da sein.

wie findest du das die instanzierung innerhalb der renderer klasse, dacht mir
das dieses ein vernüntiger weg den der user sollte eigentlich nicht direkt
in die queue eingreifen können.

Ich denke das ist ein wichtiger Aspekt der OOP.

vielleicht mach ich mir auch zu viel gedanken über das design.

Würde ich nicht sagen. Man lernt so einiges dabei.

MfG