lückentext

namespace _
{
	class __ : public ___< __ >
	{
	public :
		__();
		~__();

		static void ____( const char *_____, int ______ );
		static void ____( const _::_______& _____, int ______ );
	protected :
		_::________ _________;

		bool __________( int& ______ );
		bool ___________( bool& ______ );
		static bool ____________( int ______ );
		static void _____________( std::ofstream& _________________ );
	private :
		static int ______________;
		static bool _______________;
		static _________________ ________________;
	};
}

bitte ausfüllen.

vlad_tepesch

wiso? sieht doch aus, wie eine valide klassendeklaration.
nur am Programmierstil haperts noch ein wenig

Nexus

class __ : public ___< __ >

Du hast Recht, vlad_tepesch, nur das macht mir ein wenig Sorgen

drakon

Nexus schrieb:

class __ : public ___< __ >
Du hast Recht, vlad_tepesch, nur das macht mir ein wenig Sorgen

Gibt noch ein paar andere Probleme.. Z.B. fehlt im namespace _ der Typ _______ und ________ . Dann fehlt noch ein Objekt _________________ und ein Klassentemplate ___ .

Jetzt läufts auch schon besser:

namespace _
{
	struct ______________ {};
	typedef ______________ _______;

	typedef  ______________ ________;

	struct _________________{};

	template<class __________>
	class ___
	{
	};

    class __ : public ___< __ >
    {
    public :
        __();
        ~__();

        static void ____( const char *_____, int ______ );
        static void ____( const _::_______& _____, int ______ );
    protected :
        _::________ _________;

        bool __________( int& ______ );
        bool ___________( bool& ______ );
        static bool ____________( int ______ );
        static void _____________( std::ofstream& _________________ );
    private :
        static int ______________;
        static bool _______________;
        static _________________ ________________;
    };
}

vlad_tepesch

hmm, stimmt das hab ich übersehen.
siht so aus als ert es von einer klasse mit sich selbst als Tamplateargument.

Also doch keine gültige Klassendeklaration

rät jemand, was es ist? sollte rauszukriegen sein.

Nexus schrieb:

class __ : public ___< __ >
Du hast Recht, vlad_tepesch, nur das macht mir ein wenig Sorgen

wieso?

Nexus

@ drakon:
Hm, die Typen könnten ja vorher irgendwo deklariert sein... Wenn man bedenkt, dass eh noch anderes fehlt (Includes, main() , ...)

@ cloze:
vlad_tepesch hat ja bereits geschrieben, dass die Klasse von einem Template mit sich selber als Argument erbt.

Ihr seid doch krank

Nexus schrieb:

@ cloze:
vlad_tepesch hat ja bereits geschrieben, dass die Klasse von einem Template mit sich selber als Argument erbt.

und das ist ausdrücklich verboten? viele singletons funktionieren so.

Nexus

cloze schrieb:

und das ist ausdrücklich verboten? viele singletons funktionieren so.

So? Wie soll denn ein Template erstellt werden mit einem noch nicht definierten Typ (okay, Forward Declaration, wenn nur Zeiger oder Referenzen benötigt werden, aber in dem Fall ist ja nicht mal eine Deklaration vorhanden)?

template < typename T > struct foo 
{ 
    T* bar;
    foo() : bar( new T() ) { }
};

struct impossible : public foo< impossible > { };

int main()
{
    impossible geht_doch;
}

Nexus

Das kompiliert tatsächlich, hätte ich nicht gedacht. Wieso ist das so?

Aber es gibt einen Stackoverflow (wieso eigentlich Stack, wenn mit new allokiert wurde?).

YASC

weil die Konstruktoren sich gegenseitig aufrufen?

weil das objekt bei dir kleiner oder gleich groß ist wie eine rücksprungadresse und der stack kleiner als der heap.

Nexus

YASC schrieb:

weil die Konstruktoren sich gegenseitig aufrufen?

Ja, aber ich dachte, ein Templateargument (als Typ) müsse zuerst deklariert worden sein und wusste nicht, dass es das bereits nach class impossible : sei.

cloze schrieb:

weil das objekt bei dir kleiner oder gleich groß ist wie eine rücksprungadresse und der stack kleiner als der heap.

Das versteh ich jetzt nicht ganz; wieso Rücksprungadresse?
Wenn ich keinen Speicher mit new allokiere, gibt es auch keinen Stack-Overflow...

Nexus schrieb:

cloze schrieb:

weil das objekt bei dir kleiner oder gleich groß ist wie eine rücksprungadresse und der stack kleiner als der heap.

Das versteh ich jetzt nicht ganz; wieso Rücksprungadresse?

ich meinte, dass die konstruktoren sich gegenseitig aufrufen, weil ständig neue objekte erzeugt werden. für diese rekursiven aufrufe muss eine rücksprungadresse auf den stack geschoben werden.
wäre das objekt größer, würde vielleicht das millionste new mangels speicher fehlschlagen. aber bei diesem leeren objekt ist der stack mit den rücksprungadressen schneller gefüllt als der heap mit den objekten, deshalb stack overflow.

Badestrand

Nexus schrieb:

ich dachte, ein Templateargument (als Typ) müsse zuerst deklariert worden sein und wusste nicht, dass es das bereits nach class impossible : sei.

Soweit ich weiß muss der Typ auch (vollständig!) deklariert sein, deshalb ist das hier imho nicht standardkonform:

struct foo
{
    std::vector<foo> lots_of_foos;
};

Nexus

Ok, danke für die Erklärung. Wieder was gelernt

Badestrand

Bei genau so einer Struktur hatte mich camper mal belehrt

Nexus

Badestrand schrieb:

Soweit ich weiß muss der Typ auch (vollständig!) deklariert sein, deshalb ist das hier imho nicht standardkonform

Dachte ich eben zuerst auch. Es geht jedoch, wenn das Template nur Zeiger auf den Typen verwendet (was bei std::vector nicht der Fall ist). Nur dachte ich, dass die Klasse nach dem Vererbungsdoppelpunkt noch nicht einmal deklariert sei, was sich als Irrtum herausstellte.

Hallo,

um ein Beispiel mit einzubringen:

WTL und ATL basieren auf solchen Klassentemplates, um virtuelle Funktionen zu "simulieren", diese werden schon während des Kompilierens "aufgelöst". Wen es interessiert, der kann sich nur den Abschnitt "ATL-style templates" durchlesen, zu finden hier:

http://www.codeproject.com/KB/wtl/wtl4mfc1.aspx#atltemplates

MfG,

Probe-Nutzer