ich initialisiere einen vektor mit:

vector<double>list;

und schreibe mit:

list.assign(Anzahl, 0);

Nullen hinein.

wenn ich mir den vektor dann ausgebe steht aber statt 0 eine 5.28318e-308 drin!
weis jemand woran das liegt? (evtl die Geneuigkeit von double?).
Lustigerweise ging es ne ganze weile und auf eimal nicht mehr.

Schonmal danke!

Lustigerweise ging es ne ganze weile und auf eimal nicht mehr.

Was hast du denn "auf einmal" verändert?

class vektor{
private:
	unsigned int laenge;
	vector<double>VK;
public:
        vektor(unsigned int W);
        friend ostream &operator<<(ostream &os, const vektor &name);
};

vektor::vektor(unsigned int W){
	laenge=W;
	VK.assign(W, 0);
}

ostream &operator <<(ostream &os, const vektor &name){
	os << "(";
	for(unsigned int i=0; i<name.laenge; i++){
		os << name.VK[i] << " ";
	}
	os << ")" <<  endl;
return (os);
}

hats bei mir anfangs halt auch aber irgenwann nicht mehr...is schon eigenartig...is bestimmt wieder ein voll sinnloser fehler

Dann nimm dein funktionierendes Minimalbeispiel und füge stückchenweise alles andere hinzu. Irgendwann findest du den Fehler.

...is bestimmt wieder ein voll sinnloser fehler

Mach Dir nichts draus ... ist ja auch vollkommen sinnloser Code. :p

Nur mal zum Design:
* "laenge" <-> "VK.size()" ?
* "friend" ist unnötig. Besser: (ggf. Virtuelle) const-Memberfunktion print, die von operator<<() aufgerufen wird....

Gruß,

Simon2.

aber davon abgesehen: wozu brauchst du die klasse? das kann vector doch auch so schon?!
außer die ausgabe, aber die kann man ja in einer zeile nachbilden:

std::copy( container.begin(), container.end(), std::ostream_iterator<T>(std::cout, " ") );

wobei T hier double wäre...

bb

aber davon abgesehen: wozu brauchst du die klasse? das kann vector doch auch so schon?!

das ist nur ein teil der klasse, sollte ne klasse Vektor sein für die komplette Vektorrechnung in der alle operatoren für vektoren überladen sind.

unskilled schrieb:

aber davon abgesehen: wozu brauchst du die klasse? das kann vector doch auch so schon?!

das ist nur ein teil der klasse, sollte ne klasse Vektor sein für die komplette Vektorrechnung in der alle operatoren für vektoren überladen sind.

Dan schreib doch ne Wrapperklasse, wo du intern einen vector verwendest. Wenn du nur die Funktionalität von vector erweitern willst dann ists Blödsinn das Rad neu zu erfinden. Mal abgesehen davon dass ich mich grade frage was du da für operatoren überladen willst. Das meiste wirds vermutlich schon geben, ohne dass du es vielleicht weißt.

Dan schreib doch ne Wrapperklasse, wo du intern einen vector verwendest. Wenn du nur die Funktionalität von vector erweitern willst dann ists Blödsinn das Rad neu zu erfinden. Mal abgesehen davon dass ich mich grade frage was du da für operatoren überladen willst. Das meiste wirds vermutlich schon geben, ohne dass du es vielleicht weißt.

Das ist gut möglich, dass ich es nur nicht weis!Kann mir aber nicht vorstellen, dass vektor- und skalarprodukt usw. schon bekannt sind!
und was zum teufel ist ne wrapperklasse...sorry anfänger...

Muss sich ein Vektor von der Grösse her verändern können oder ist die Grösse zur Kompilierzeit bekannt? Bei Letzterem könntest du Templates verwenden, dann müsstest du nicht mit Speicherverwaltung rumhantieren.

In der Standardbibliothek wohl eher nicht. Extra deswegen Boost zu verwenden ist vielleicht auch übertrieben, zumal eine einfache Vektorklasse schnell geschrieben ist und eine gute Übung darstellt.

Muss sich ein Vektor von der Grösse her verändern können oder ist die Grösse zur Kompilierzeit bekannt? Bei Letzterem könntest du Templates verwenden, dann müsstest du nicht mit Speicherverwaltung rumhantieren.

ja eigentlich ist die länge schon bekannt!Leider fehlt mir bei templates noch der durchblick, weil wollte den vektor dann noch mit verschiedenen datentypen verwenden - was ja wohl mit templates gemacht wird.

In diesem Artikel findest du eine gute Einführung in die Programmierung mit Templates. Sobald du das Grundprinzip einmal verstanden hast, hast du bereits recht viele Möglichkeiten offen. Wobei das Gebiet der Templates dann noch ins Unendliche weitergeht, zum Beispiel Richtung Metaprogrammierung. Aber das hat dich momentan noch nicht zu kümmern...

//nicht gepostet, aber ist da:
//using namespace std; --- sollte man nicht in headern verwenden - denn so hebelst du den kompletten sinn von namespaces aus!

class vektor{ 
private: 
//    unsigned int laenge;  --- brauchst du nicht, weil vector die ohnehin mit speichert!
    std::vector <double> VK; 
public: 
    std::vektor(unsigned int W); 
    friend std::ostream& operator<<(std::ostream &os, const vektor &name);
//operator[] implementieren
//size() const implementieren
//-> dann brauchst du das friend dort auch so nicht mehr und kannst beim <<operator einfach diese funktionalität nutzen
}; 

vektor::vektor(unsigned int W)
:  VK(W, 0)
{}

std::ostream& operator<< (std::ostream &os, const vektor &name)
{ 
    os << "("; 
    for(unsigned int i=0; i < name.VK.size(); i++){ 
        os << name.VK[i] << " "; 
    } 
    os << ")"; // << endl; das endl hier hinzuschreiben wäre bissl blöd, weil es eigtl nicht zu ausgabe dazugehört, sondern nur was mit design - auch, wenn design als wort ein wenig übertrieben ist ^^
    return os; //die klammern hier waren sinnlos...
}

bb

Das ist gut möglich, dass ich es nur nicht weis!Kann mir aber nicht vorstellen, dass vektor- und skalarprodukt usw. schon bekannt sind!

vektor-Produkt gibts meines Wissens nur für dreidimensionale mathematische Vektoren. std::vector ist aber eher ein Container und hat daher eine andere Semantik. Für mathematische 3D-Vektoren gibts aber in verschiedenen Frameworks bereits fertige Klassen.

Wenn du nicht weißt was eine Wrapperklasse ist, dann solltest du dich mal ein wenig mit Design-Patterns beschäftigen bzw. einfach mal nach "wrapper class" googlen. Ist auf jeden Fall deutlich einfacher als eine ordentliche vector-Klasse von Grund auf neu zu erfinden

Was das Sakalaprodukt angeht ist das mit der Standardbibliothek schnell erledigt, die Mittel dazu sind vorhanden:

#include <algorithm>  //fuer transform
#include <functional> //fuer multiplies
#include <iterator>   //fuer back_inserter
#include <numeric>    //fuer accumulate
#includue <vector>

template <class T>
T skalaprodukt(std::vector<T> const& lhs, std::vector<T> const& rhs)
{
  assert(lhs.size() <= rhs.size());
  std::vector tmp;
  std::transform(lhs.begin(), lhs.end(), rhs.begin(), std::back_inserter(tmp), std::multiplies<T>());
  return std::accumulate(tmp.begin(), tmp.end(), T());
}

Dazu brauchs also nicht extra ne neue Klasse...

bb

assert(lhs.size() <= rhs.size());
das assert ist aber mathematisch nicht richtig und soll nur speicherzugriffsfehler verhindern, oder irre ich mich da? Oo

bb

Jup. Mathematisch müsste es == sein.

Eine Schleife würde von HoCiEp3 vielleicht auch verstanden und bräuchte 4 Header weniger...

pumuckl, hast du grundsätzlich was gegen prozedurale Programmierung, oder bist du gerade im STL-Wahn?

Wieso gegen prozedurale Programmierung? Die STL-Algorithmen sind doch prozedural auf höchstem Niveau...