Wie: Methoden eines Klassentemplates definieren und: Mehrteilige Klassentemplate-Hierarchie

HumeSikkins

Hallo,
also das:

template <class T,class U> 
class End 
:protected T<U>    //T könnte Foo sein 
{ 
    //... 
};

geht so nicht. Da müsste T schon ein Template-Template-Parameter sein.

Und das:

class AbstractBar;
{
    //...
};

ist so natürlich auch nicht richtig.
Wie sieht denn dein echter Code aus?

ness

Ja, von template-template-Parametern hab ich gehört, wie genau müsste das aussehen? Und was geht an AbstractBar net? (Außer das ich keine rein virtuelle Funktion angegeben hab? [Die es aber gibt]) Und was den echten code angeht: Ich glaube nicht das ihr begeistert währt, seitenweise Anfängercode zu lesen...

HumeSikkins

ness schrieb:

Ja, von template-template-Parametern hab ich gehört, wie genau müsste das aussehen?

template <template <class> class T, class U>
class End : public T<U>
{};

Und was geht an AbstractBar net?

Da ist ein Semikolon zuviel.

ness

Oops! Und wenn die Vererbungshierarchie noch weiter geht? Muss ich dann template-template-template-Parameter benutzen?(Das fogende beispiel beschreibt ungefähr meine Hierarchie):

class AbstractBar
{
    //...
};

class Bar1
:public AbstractBar
{
    //...
};

class Bar2
:public AbstractBar
{
    //...
};
//...
template<template<class>classT>    //so richtig?
class AbstractFoo
:public T
{
    //...
};

template<class T>                  //Was muss nun hier hin?
Foo1
:public AbstractFoo<T>
:public T
{
    //...
};
//...
//...
//...
template<
    template<class>class T,template<class>class U,template<class>class V    //...
        >
class End
:public T<U,V>
{
    //...
};

ness

Weil es noch keine Antwort gab, hab ich mal ein bischen rumprobiert! Was ist hier falsch? (Direkt aus dem Test übernommen)

class AbFoo
{
};

class Foo1
:public AbFoo
{
};

class Foo2
:public AbFoo
{
};

template<template<class>class T>
class AbBar
:public T
{                    //Fehler 1
};                   //Fehler 2

template<class T>
class Bar1
:public AbBar<T>
{
};

Fehler:

error C3205: Argumentenliste für Vorlagenparameter 'T' fehlt
Siehe Verweis auf Instanziierung der kompilierten Klassenvorlage 'AbBar<T>'

Ableiten kannst du nur von vollständigen Typen. Ich nehme an, du willst was in der Art:

template<template<typename> class T>, typename U>
class Foo : T<U> {
  //...
};

ness

Hä? Ein bisschen genauer bitte! Wie würde das in meinem konkretem Fall aussehen?

ness

Och menno, es kann doch nicht sein das ich seitenweise Quelltext schreibe und dann scheitert es an sowas! Ich poste jetzt einfach alles was mit Vererbung zutun hat und bin jedem auf ewig dankbar der mir sagt was falsch ist!

class AbstractOutMethod
	{
            //...
            };

class OutMethod_TextOut
	{
            //...
            };
template
	<
		class OutMethod=OutMethod_TextOut
	>
	class AbstractBuffering
	:public OutMethod
            {
            //...
            };

template
	<
		class OutMethod=OutMethod_TextOut
	>
	class Buffering_Lazy
	:public AbstractBuffering
	{
            //...
            };

template
	<
		class Buffering=Buffering_Lazy,
		class OutMethod=OutMethod_TextOut
	>
	class AbstractControls
	:public Buffering <OutMethod>
            {
            //...
            };

template
	<
		class Buffering=Buffering_Lazy,
		class OutMethod=OutMethod_TextOut
	>
	class Controls_Default
	:public AbstractControls<Buffering,OutMethod>
	{
            //...
            };

template
	<
		class Controls=Controls_Default,
		class Buffering=Buffering_Lazy,
		class OutMethod=OutMethod_TextOut
	>
	class AbstractEfficiency
	:public Controls <Buffering,OutMethod>
	{
            //...
            };

template
	<
		class Controls=Controls_Default,
		class Buffering=Buffering_Lazy,
		class OutMethod=OutMethod_TextOut
	>
	class Efficiency_Safe
	:public AbstractEfficiency<Controls,Buffering,OutMethod>
	{
            //...
            };

template
	<
		class Efficiency=Efficiency_Safe,
		class Controls=Controls_Default,
		class Buffering=Buffering_Lazy,
		class OutMethod=OutMethod_TextOut
	>
	class Ostream
	:protected Efficiency <Controls,Buffering,OutMethod>
            {
                //...
            }

Is nur copy'n'paste, hoffe hab alles erwischt...

Whoa. Da haste dir ja ein ganz schönes Monster zugelegt.

Das sieht dann im Endeffekt so aus:

class AbstractOutMethod {
  //...
};

class OutMethod_TextOut {
  //...
};

template <class OutMethod = OutMethod_TextOut>
class AbstractBuffering : public OutMethod {
  //...
};

template <class OutMethod = OutMethod_TextOut>
class Buffering_Lazy : public AbstractBuffering<OutMethod> {
  //...
};

template <template<class> class Buffering = Buffering_Lazy,
	  class OutMethod = OutMethod_TextOut>
class AbstractControls : public Buffering<OutMethod> {
  //...
};

template <template<class> class Buffering = Buffering_Lazy,
	  class OutMethod = OutMethod_TextOut>
class Controls_Default : public AbstractControls<Buffering, OutMethod> {
  //...
};

template <template<template<class> class, class> class Controls = Controls_Default,
	  template<class> class Buffering = Buffering_Lazy,
	  class OutMethod = OutMethod_TextOut>
class AbstractEfficiency : public Controls<Buffering, OutMethod> {
  //...
};

template <template<template<class> class, class> class Controls = Controls_Default,
	  template<class> class Buffering = Buffering_Lazy,
	  class OutMethod = OutMethod_TextOut>
class Efficiency_Safe : public AbstractEfficiency<Controls, Buffering, OutMethod> {
  //...
};

template <template<template<template<class> class, class> class, 
		   template<class> class, class> class Efficiency = Efficiency_Safe,
	  template<template<class> class, class> class Controls   = Controls_Default,
	  template<class> class Buffering  = Buffering_Lazy,
	  class OutMethod  = OutMethod_TextOut>
class Ostream : protected Efficiency <Controls, Buffering, OutMethod> {
  //...
};

otze

//edit stimmt doch alles Oo

Übrigens mal designtechnisch - in dem Fall macht es vermutlich deutlich mehr Sinn, sowas zu machen:

template<class _t_base = Efficiency_Safe<Controls_Default<Buffering_Lazy> > > Ostream : public t_base {
  //...
};

Das sieht dann nachher bei der Instanziierung nicht mehr ganz so schön aus, aber dafür lässt sich der Code wenigstens sinnvoll warten - durch den template<template<template<template<...-Kram blickt ja keiner mehr durch.

ness

@Oxdeadbeef: Danke, du bist mein Retter! Würdest du mir bitte noch erklären wie genau man die template-template-template...-Parameter verwendet? (Link oder so reicht auch)

virtuell Realisticer

Ihr seid ja verrueckt :D.

Musste mal gesagt werden :p

mfg
v R

ness

virtuell Realisticer schrieb:

Ihr seid ja verrueckt :D.

Musste mal gesagt werden :p

Na dann sei auch mal verrückt und erklär mir wie man template-template-Parameter benutzt...

otze

wenn du eine klasse willst, der du innerhalb des templates einen template parameter andrehen willst, dann geht das so:

template<template<class> class T>
class X{
    typedef T<int> irgendwas;
};

für ein template mit 2 template template parametern:

template<template<class,class> class T>
class X2{
    typedef T<int,float> irgendwas;
};