habe folgendes kleines programm als test geschrieben

#include <iostream>
#include <malloc.h>

using namespace std;

template <class T, int groesse>class buffer{
private:
	T *feld;	
public:
	buffer(){feld = (T *) malloc (groesse * sizeof(T));}
};

void main()
{
	int anzahl;
	cin>>anzahl;
	buffer<int,anzahl>test;
}

jetzt das problem bei der sache.
das programm lässt sich so nicht kompilieren, mir ist auch klar warum. weil ich die Feldgröße erst zur laufzeit mitteilen möchte. So ist es aber leider nicht möglich, hat da jemand nee andere Idee? Hinzu kommt noch das ich gerne den Datentyp des feld zur laufzeit des Programms erst festlegen möchte, ist das überhaupt möglich ?
danke euch schon mal für eure hilfe.
ich weiß das mit dem datentyp festlegen könnte ich über mehrer switch case geschichten machen, wird aber zu groß denke ich ^^

sowas?

Weitere Informationen findest du bestimmt unter Google

#include <iostream>
#include <vector>

using namespace std;

template <class T>class Buffer
{
public:
	Buffer(size_t anzahl):feld(anzahl)
	{  
	}  
	void push(T wert,int index)
	{
		feld[index]=wert;
	}
	T pop(int index)
	{
		return feld[index];
	}
private:
	vector<T> feld;
};  

int main()
{
	int anzahl;
	cout<<"Anzahl der Feldgroesse eingebe:";
	cin >> anzahl;
	Buffer<int> test(anzahl);
	for(int i=0;i<anzahl;i++)
	{
		test.push(i,i);
		cout<<i<<"\n";
	}
	for(int i=0;i<anzahl;i++)
	{
		cout<< test.pop(i)<<"\n";
	}
}

oder was sagt ihr dazu ?

Da gibt es auch container für alle Lebenslagen, lifo, fifo, einfach und doppelt verkettete Listen, maps und und und ..
Schau mal da: http://www.cplusplus.com/reference/stl/

jetzt hab ich aber noch eine frage, ist es möglich den datentyp dem programm erst mit zu teilen, wenn es läuft? sprich also das ich nicht in main int schreibe sondern dieses per eingabe zu machen ?

jetzt hab ich aber noch eine frage, ist es möglich den datentyp dem programm erst mit zu teilen, wenn es läuft? sprich also das ich nicht in main int schreibe sondern dieses per eingabe zu machen ?

Nein. Wofür würdest du das benötigen? Vielleicht lässt sich das dann auch anders lösen.

class myObjects {
...
public:
   virtual const int ObjTypes Type() =0;
..
}

Wenn du genau über die Eigenschaften eines Types bescheid weis kannst du es auch auf gut glück in den gewünschten Typ casten

class A {... };
class B : public A {...};
Typ A* a= new B;
Typ B* b=(B*)a;

Wenn du beim cast daneben liegst .. passieren wundersamme dinge ..

... die C++ Variante wäre eine abstakte Basisklassen als Oberklasse aller möglichen Objekte die deine Anwendung verwenden darf zu erstellen.

Aber nur die dreckige C++ Variante. Die saubere wäre es, zu prüfen ob es wirklich nötig ist, das alle Typen voneinander ableiten müssen. Vererbung ist ohne Frage sinnvoll, und auch abstrakte Basisklassen als Schnittstellen ebenso, nur das mit einer zentralen Basisklasse für alles ist in der Regel unnötig und zeugt eher vom schlechten Design.

mschulz schrieb:

Ich weis nicht ob es in C++ eine möglichkeit gibt den Typ eines Objektes zu ermitteln, ich verwende daher immer eine Type() Methode um den Objekttyp zuermitteln.

RTTI; und wozu eine TypId? Damit man wieder mit switches arbeitet? (Das wäre wieder der Negativfall).

mschulz schrieb:

Wenn du genau über die Eigenschaften eines Types bescheid weis kannst du es auch auf gut glück in den gewünschten Typ casten

Bitte KEINE C-Casts unter C++, und sicher bekommt man dies auch (Thema dynamic_cast). Zudem niemals Objekte in C++ per Cast zuweisen nur über Zeiger oder Referenzen hantieren (Stichwort Slicing).

class A {... };
class B : public A {...};

A* a = new B();
B* b = dynamic_cast<B*>(a);
if(b) // <-- b liest sich konvertieren
//...

cu André

Mit Zeigern kannst du fast alles machen, ist aber nicht schön.

Zeiger mögen einigen nicht gefallen, aber mit Objekten läßt sich keine Polymorphie betreiben (nur mit Referenzen und Zeiger). In anderen Sprachen wird dies dadurch verborgen das man zwar mit einer Referenzsyntax arbeitet, tatsächlich aber intern Zeiger verwendet.

mschulz schrieb:

Du kannst immer behaupten das der Zeiger auf irgendein Object ein Zeiger auf ein bestimmtes ist, nur der Typ muss zur Compilezeit bekannt sein.
In C++ gehen nach dem Übersetzen alle Informationen über Namen von Klassen und Typen verloren.

Dies ist schlicht und ergreifend falsch. Runtime Type Information (RTTI) ist das stichwort, und ja - mit C-Casts kannst du Kühe in Äpfel verwandeln, mit C++ Mitteln (dynamic_cast, static_cast,...) ist dies deutlich schwerer. Und dynamic_cast PRÜFT den Typ, also sag nicht das es keinerlei Typinformationen gibt.

cu André

Toll hab dein RTTI .. erst nicht verstanden, schön.
Typinfos schon aber keine Namen.

Darf ich mal fragen zuwas du den Klassennamen brauchst? (Es gibt zwar einen namen den man per RTTI ermitteln kann, leider ist die Darstellung nicht normiert und Compilerabhängig; Für Tracing reicht es aber). Und ein Typvergleich geht auch.

cu André

was ich eigentlich nur wollte wäre z.b.

int i; -> das "int" will ich aber erst zur laufzeit bestimmen indem ich es eingebe oder ihm etwas über cin einlesen lasse und er dann automatisch den datentyp ermittelt. ist aber wahrscheinlich unmöglich oder?

int i; -> das "int" will ich aber erst zur laufzeit bestimmen indem ich es eingebe oder ihm etwas über cin einlesen lasse und er dann automatisch den datentyp ermittelt. ist aber wahrscheinlich unmöglich oder?

nein ist es nicht. es macht nur keinen sinn. du solltest lieber lernen wie man in c++ c++ programmiert.

ein dynamisches typsystem zu implementieren kannst du dir fuer spaeter aufheben (dann wirst du es vermutlich eh nicht mehr machen wollen).

du solltest versuchen in c++ zu denken und nicht c++ dein denken aufzuzwingen

ist aber wahrscheinlich unmöglich oder?

Wie Shade Of Mine bereits sagte, stellst du dir wahrscheinlich mehr darunter vor, als du damit überhaupt anfangen kannst.

Sagen wir, du könntest etwas in die Konsole eingeben. Wenn die Syntax einem Elementartyp entspricht, wird dieser angenommen, sonst ein std::string (könnte z.B. bei short und char schwierig werden, aber lassen wir das mal). Toll, du hast jetzt einen "angepassten" Typen. Was nun? Willst du damit rechnen? Ginge auch nur, wenn es kein String wäre. Ausserdem verhalten sich z.B. Fliesskommazahlen und Integer anders. Tja, man kann zwar alle Typen haben, weiss aber keinen Einsatzbereich, da sich die einzelnen unterscheiden. Dann lieber gleich nach bestimmtem Typ abfragen (das andere ist sowieso nicht möglich).

Mal ehrlich: Falls du eine genaue Vorstellung hast, schildere uns diese mal. Es ist ziemlich sicher möglich, dies anders zu lösen (notfalls halt mit If-Abfragen und Casts).