Ich hab mir so nen Vector definiert:

std::vector< T1 > Element_List;

Für diesen hab ich einige Methoden geschrieben...

Jetzt möchte ich den Typ des vectors ändern...

Beispielsweise soll er dann so aussehen:

std::vector< T2 > Element_List;

Wichtig ist, das der Name des Vectors der gleiche ist. Also Element_List...
Der Vektor Element_List mit den Datentypen T1 benötige ich nicht mehr, er kann also gelöscht werden da ich den Inhalt schon wo anders zwischengespeichert habe...

Meine Frage ist jetzt ob das überhaupt geht?

mfg Ishi

Ursprünglich hab ich also meine Berechnungen alle mit dem Datentyp T1 geschrieben...

vector::<T1>Element_List wird ganz am Anfang meines Programms initialisiert...Das muss auch so bleiben da ich aus einem anderen Programm so die Daten in mein Programm reinlade...
Bei meinen weiteren Berechnungen erstell ich mir ein T2 durch irgendwelche Kombinationen aus T1.
Dann hab ich ne Element_List_2 vom Typ T2...

Um das ganze zu visualliesieren gibt es eine output-methode der ich allerdings einen vector vom Datentyp T1 übergeben muss.

Ich hab jetzt aber einen vector vom Datentyp T2.... Diesen vector möchte ich in einen vector umschreiben der Element_List heißt was ich ja schon am anfang definiert habe.

Ich hab eine Methode die mir den T2 vector in einen T1 vector umkopiert allerdings kann ich von dem T1 vector den Datentyp
nicht ändern.
Wäre schön wenn das möglich wäre ohne viel Aufwand....
Ich hab mir halt überlegt ob man einfach den vector Element_List vom Datentyp T1 komplett löschen kann und dann einfach einen
neuen erzeugen kann der halt genauso heißt und einen anderen Datentyp hat....

Also wenns da ne einfache Möglichkeit gibt wärs cool wenn ihr mir helfen könntet.
Ansonsten muss ich mir was anderes einfallen lassen....

danke soweit IShi

struct A{};
struct B : A{};
struct C : A{};

#include <vector>

int main()
{
    std::vector<A*> vec;

    B b;
    C c;

    vec.push_back(&b);
    vec.push_back(&c);
}

~~Ich bin mir aber ziemlich sicher, dass du das nicht brauchst. (Jedenfalls nicht um dein "Problem" zu lösen).
~~

Versuchs mal in die Richtung.

Edit:
Zeig erstmal deinen (gekürzten) Code.

mfg Ishi

@ Hacker
Das ist nicht das, wonach er gefragt hat.

Ich weiß. Wonach der gefragt hat, ist aber Schwachsinn. Man kann nicht einen Bezeichner resetten, oder den Typ eines Vectors ändern.

Also geht das was ich vorhatte nicht...

Danke!

icarus2 schrieb:

@ Hacker
Das ist nicht das, wonach er gefragt hat.

Wonach der gefragt hat, ist aber Schwachsinn. Man kann nicht einen Bezeichner resetten, oder den Typ eines Vectors ändern.

Da gebe ich dir recht

Hacker schrieb:

icarus2 schrieb:

@ Hacker
Das ist nicht das, wonach er gefragt hat.

Wonach der gefragt hat, ist aber Schwachsinn. Man kann nicht einen Bezeichner resetten, oder den Typ eines Vectors ändern.

Da gebe ich dir recht

Wonach er fragt ist denke ich kein Schwachsinn. Es ist wahrscheinlich 'nur' ziemlich unglücklich formuliert.

Er möchte (vermute ich) den gleichen Algorithmus für verschiedene Datentypen aufrufen.

Dazu machst du aus deiner Funktion eine Template-Funktion und du kannst es für zwei Datentypen ausführen.

Vielleicht hilft dir folgendes weiter:

#include <iostream>
#include <vector>

struct Foo{
	Foo(int i) : i(i) {}

	void foo() const{
		std::cout << "foo() " << i << std::endl;
	}

	void say() const{
		std::cout << "say foo() " << i << std::endl;
	}

	int i;
};

struct Bar{
	Bar(int i) : i(i) {}

	void bar() const{
		std::cout << "bar()" << i << std::endl;
	}

	void say() const{
		std::cout << "say bar() " << i << std::endl;
	}

	int i;
};

void call_function(const Foo& f){
	f.foo();
}

void call_function(const Bar& b){
	b.bar();
}

template<class T>
void foobar(const std::vector<T> vec){
	for(typename std::vector<T>::const_iterator it=vec.begin(); it!=vec.end(); ++it){
		it->say();
		call_function(*it); // Ein zusätzlicher Funktionsaufruf, falls 'es nicht genau passt'
	}
}

int main(){
	std::vector<Foo> vec1;
	vec1.push_back(Foo(1));
	vec1.push_back(Foo(2));

	std::vector<Bar> vec2;
	vec2.push_back(Bar(1));
	vec2.push_back(Bar(2));

	foobar(vec1);
	foobar(vec2);
}

Gruß,
XSpille

Ich gehe davon aus dass das Programm ca. so aussieht.

std::vector<float> Daten;

void DatenEinlesen()
{
    ...
    Daten.push_back(...);
    Daten.push_back(...);
    ...
}

void IrgendwasRechnen()
{
    ...
    Daten[i] =  ... Daten[j] ...
    ...
}

void IrgendwasAusgeben();

int main()
{
    DatenEinlesen();
    IrgendwasRechnen();
    IrgendwasAusgeben();
}

Und jetzt will er in IrgendwasRechnen mit double rechnen.
Und daher den Vektor "Daten" ("Element_List") transmutieren.

Und daher den Vektor "Daten" ("Element_List") transmutieren.

Hä? </tuaufdumm>

Also, da gibt es doch eine Fülle von Möglichkeiten. Z.B. Zwei Vectoren machen, und eine Template-Methode.

Ich nehme oft das schlimmste an, und wenn ich damit falsch liege, dann bitte um Verzeihung im Voraus.

Ich gehe halt davon aus dass der OP a) nicht wirklich programmieren kann und b) unwillens ist den Bezeichner "Element_List" an allen Stellen in seinem Programm zu ändern (ist ja sooo viel Arbeit).

Und daher den Typ der "Element_List" zur Laufzeit ändern will - was in dynamisch typisierten Sprachen ja durchaus möglich wäre.

Ich nehme oft das schlimmste an, und wenn ich damit falsch liege, dann bitte um Verzeihung im Voraus.

Ich gehe halt davon aus dass der OP a) nicht wirklich programmieren kann und b) unwillens ist den Bezeichner ...

Ja, so denk ich auch. Es ist mir nur peinlich das zuzugeben