ich finde den Fehler nicht im Code.
Warum hat Zeile 38 keine Auswirkung auf den Code? Gültigkeitsbereich?
Was müsste geändert werden?

#include <vector>
#include <iostream>

class B{

private:
	std::vector<double> elements;
public:
	static const int maxdim =3;
	B(){ elements.insert(elements.begin(),maxdim,0.0); }
	double get_dim(int dim) {return elements[dim];}
	void set_dim(int dim,double val) {elements[dim] = val;}
};

class A{
	private:
		std::vector<B> sys;
	public:
		static const int maxsys=3;

		A(){
			B tmpb;
			sys.insert(sys.begin(),maxsys,tmpb);
		}

		B get_sys(int pos) const { return sys[pos];}
		void set_sys(B val) { sys.push_back(val);}
};

int main(void){

	A classa;

	for(int i=0;i<A::maxsys;i++){
		for(int j=0;j<B::maxdim;j++){
				classa.get_sys(i).set_dim(j,1.0);
		}
	}

	for(int i=0;i<A::maxsys;i++){
		std::cout << "sys=" << i << '\n';
		for(int j=0;j<B::maxdim;j++){
			std::cout << "dim-" << j << "=" << classa.get_sys(i).get_dim(j) << '\t';
		}
		std::cout << '\n';
	}
}

Zur Lösung des Problems:
Technisch: Gib eine Referenz oder einen Zeiger zurück.
Besser: Ändere das Design. Das verletzt das Konzept der Kapselung.

Besser: Ändere das Design. Das verletzt das Konzept der Kapselung.

Wieso? std::string, std::vector,... machen das doch auch so. Sie haben den []-operator überladen und geben eine referenz auf das n-te Element zurück.

Zur Lösung des Problems:
Technisch: Gib eine Referenz oder einen Zeiger zurück.

So? Klappt irgendwie nicht.

double &set_dim(int dim,double val) {return elements[dim];}
B &set_sys(int pos) {  return sys[pos];}
// Zugriff
classa.set_sys(i).set_dim(j,1.0);

drakon schrieb:

Besser: Ändere das Design. Das verletzt das Konzept der Kapselung.

In wie fern?

#include <vector>
#include <iostream>

class B{

private:
	std::vector<double> elements;
public:
	B(){ elements.insert(elements.begin(),3,0.0); }
	const double &get_dim(int dim) const {return elements[dim];}
	double &set_dim(int dim,double val) {return elements[dim];}
};

class A{

private:
	std::vector<B> sys;
public:
	A(){
		B tmpb;
		sys.insert(sys.begin(),3,tmpb);
	}

	const B &get_sys(int pos) const { return sys[pos];}
	B &set_sys(int pos) {  return sys[pos];}
};

int main(void){

	A classa;

	for(int i=0;i<3;i++){
		for(int j=0;j<3;j++){
			classa.set_sys(i).set_dim(j,1.0);
		}
	}

	for(int i=0;i<3;i++){
		std::cout << "sys=" << i << '\n';
		for(int j=0;j<3;j++){
			std::cout << "dim-" << j << "=" << classa.get_sys(i).get_dim(j) << '\t';
		}
		std::cout << '\n' << '\n';
	}
	std::cout << '\n';
}

Klappt irgendwie nicht.

Tolle Fehlerbeschreibung.

drakon schrieb:

Besser: Ändere das Design. Das verletzt das Konzept der Kapselung.

Wieso? std::string, std::vector,... machen das doch auch so. Sie haben den []-operator überladen und geben eine referenz auf das n-te Element zurück.

Das ist korrekt, aber das sind eher Sonderfälle, weil man da wirklich Zugriff auf die inneren Elemente braucht. Üblicherweise sollte man so etwas allerdings nicht machen.

@darkfate
Was sollen denn die Funktionen deiner meinung nach machen, wenn du eh nur Referenzen auf Objekte zurückgibst?

Klappt irgendwie nicht.

Tolle Fehlerbeschreibung.

Bezieht sich auf weiter oben, das es keine Auswirkung hat.

Was sollen denn die Funktionen deiner meinung nach machen, wenn du eh nur Referenzen auf Objekte zurückgibst?

Es ist hier stark vereinfacht. Wollte das Grundproblem aufzeigen.
Jetzt gebe ich Referenzen zurück und habe immer noch 0.0 in allen Elementen.

Vielleicht hast du mich einfach falsch verstanden, aber die Setter da oben (im letzten Code) sind schlichtweg unsinnig.

Zur Lösung des Problems:
Technisch: Gib eine Referenz oder einen Zeiger zurück.

An welche Stelle soll da die Referenz hin?

Könntest du mir jetzt bitte erklären warum die getter uns setter da unsinning sein sollten?

Die getter sind nicht das Problem. Und ein setter setzt normalerweise was, oder? Dein setter ist aber nur ein non-const-ref-getter...

darkfate schrieb:

Könntest du mir jetzt bitte erklären warum die getter uns setter da unsinning sein sollten?

Die getter sind nicht das Problem. Und ein setter setzt normalerweise was, oder? Dein setter ist aber nur ein non-const-ref-getter...

Wie macht man es besser?

Ich möchte die Variable nicht public freigeben.

Wie macht man es besser?

In dem du etwas setzt? Vor allem in B wäre eine Zuweisung nicht schlecht. Wenn du zwar eine "1.0" übergibst, die aber nirgendwo setzt, brauchst du dich nicht wundern, dass du nicht das bekommst was du gesetzt haben wolltest, aber es dann doch nicht getan hast.

In dem du etwas setzt? Vor allem in B wäre eine Zuweisung nicht schlecht. Wenn du zwar eine "1.0" übergibst, die aber nirgendwo setzt, brauchst du dich nicht wundern, dass du nicht das bekommst was du gesetzt haben wolltest, aber es dann doch nicht getan hast.

Ich kann gerade nicht nachvollziehen was du meinst, könnten wir mit Codeschnipseln arbeiten? Hier ist das aktuelle, funktionsfähige, Ergebnis.

#include <vector>
#include <iostream>

class B{

private:
	std::vector<double> elements;
public:
	static const int maxdim =3;
	B(){ elements.insert(elements.begin(),maxdim,0.0); }
	double get_dim(int dim) {return elements[dim];}
	void set_dim(int dim,double val) {elements[dim] = val;}
};

class A{
private:
	std::vector<B> sys;
public:
	static const int maxsys=3;

	A(){
		B tmpb;
		sys.insert(sys.begin(),maxsys,tmpb);
	}

	B get_sys(int pos) const { return sys[pos];}
	B &set_sys(int pos) { return sys[pos];}
	void set_sys(int pos, B val) { sys[pos] = val; }
};

int main(void){

	A classa;

	for(int i=0;i<A::maxsys;i++){
		for(int j=0;j<B::maxdim;j++){
			classa.set_sys(i).set_dim(j,1.0);
		}
	}

	for(int i=0;i<A::maxsys;i++){
		std::cout << "sys=" << i << '\n';
		for(int j=0;j<B::maxdim;j++){
			std::cout << "dim-" << j << "=" << classa.get_sys(i).get_dim(j) << '\t';
		}
		std::cout << '\n';
	}
}

Schau deinen Code einfach nochmal genau an (den zweiten den du gepostet hast).

Du hattest vorhin zwischendrin keinen setter, sondern einen weiteren getter implementiert. Warum sollte ein setter überhaupt etwas zurückgeben?

Schau deinen Code einfach nochmal genau an (den zweiten den du gepostet hast).

Ich weiß gerade nicht wie man es besser/einfacher implementieren könnte.
Bin für jeden Tipp dankbar. Am besten mit einem Stück Code weil ich mir aus den Sätzen sehr schwer tue Code zusammenzubauen.

drakon schrieb:

Du hattest vorhin zwischendrin keinen setter, sondern einen weiteren getter implementiert. Warum sollte ein setter überhaupt etwas zurückgeben?

Schau deinen Code einfach nochmal genau an (den zweiten den du gepostet hast).

Ich weiß gerade nicht wie man es besser/einfacher implementieren könnte.
Bin für jeden Tipp dankbar. Am besten mit einem Stück Code weil ich mir aus den Sätzen sehr schwer tue Code zusammenzubauen.

Man merkt, dass du ein wenig auf der Leitung stehst..

Du hast es ja bereits richtig gemacht..
Schau nochmal gaaanz genau Zeile 12 im letzten geposteten Code an und vergleich das, was du auf da im zweitletzen geposteten Code hattest.

Man merkt, dass du ein wenig auf der Leitung stehst..

Wird Zeit gleich Feierabend zu machen.
Gibt es generell etwas am Klassen-Design zu verbessern?

btw:
Deutschland spielt und du bist am arbeiten?

btw:
Deutschland spielt und du bist am arbeiten?

Die verlieren eh 3:0
* duck und weg *

Kurz:
Ich habe Koordinaten mit einer bestimmten
Dimension(im Beispiel Dimension=3) in
verschiedenen Koordinatensystemen
(im Beispiel Anzahl der Koordinatensysteme=3).

Diese sollen möglichst bequem abgerufen und gespeichert werden können.

Lang:
Ich habe ein Panoramabild welches auf eine Kugel
projeziert wird und klicke darin mit der Maus.

Bekomme XY Bild-Koordinaten der Maus -> Transformiere sie
in Kugelkoordinaten und speichere sie ab.

Das Zusammengeklickte (Punkte/Knoten/Maschen) soll
eine Topologie darstellen.

Die Klasse Topoobject speichert die gemeinsamen
Eigenschaften wie die Objekte gezeichnet werden sollen.

Coord ist die klassische Koordinate. Sie gehört immer
irgend einem Koordinatensystem an.

Knot ist die Knotenklasse die eine beliebige
Anzahl von Koordinaten speichert.

Zwei Knoten sind eine Ecke usw..

Die ganze Klassenhierarchie sieht so aus:

#include <vector>
#include <cstdarg>

#include "assert.h"
#include "panoconstants.h"
#include "geotopology.h"

#ifndef TOPOOBJECT_H
#define TOPOOBJECT_H

typedef unsigned int puint;

// Limits
typedef struct{puint max_color,max_size,max_code,max_comment;} topolimits;
topolimits const defaultlimits = {16777216,100,1000,10000};

// Formats
typedef struct{puint HVD,XYZ;} pcoordformats;
pcoordformats const coordformats = {0,1};

// Colors
typedef struct {puint color,size,code;std::string comment;} topoproperty;

class Topoobject{

	private:

		puint color;
		puint size;
		puint code;
		std::string  comment;

	public:

		static const topoproperty propdefault;
		static const topoproperty propcoord;
		static const topoproperty propknot;
		static const topoproperty propedge;
		static const topoproperty propface;

		Topoobject();
		Topoobject(topoproperty new_property);
		Topoobject(puint color, puint size, puint code,const std::string &comment);

		void set_size(puint new_size);
		void set_color(puint new_color);
		void set_code(puint new_code);
		void set_comment(const std::string &new_comment);

		puint get_code() const;
		puint get_size() const;
		puint get_color() const;
		std::string const &get_comment() const;

};

class Coord : public Topoobject{

	private:

		std::vector<double> elements;
		puint format;

	public:
		Coord();
		Coord(puint format, puint maxdim, ... );
		Coord(puint format,puint color,puint size,puint code,const std::string &comment, puint maxdim, ... );

		void set_dim(puint dim, double new_element);
		void set_xyz(double x,double y, double z);
		void set_hvd(double h, double v, double d);
		void set_format(puint new_format) const;

		puint get_format() const;
		double get_dim(puint dim) const;

};

class Knot : public Topoobject{

private:

	std::vector<Coord> coordinatesystem;

public:

	Knot();
	Knot(puint maxsys ... );

	double get_distance(puint sys, Knot &new_knot) const;
	Coord get_sys(puint format) const;
	Coord &set_sys(puint sys);
	void set_sys(Coord new_coord,puint format);

};

class Edge : public Topoobject{

	private:

		puint startknot_id,endknot_id,left_area,right_area;

	public:
		Edge(puint startknot_id, puint endknot_id);
		void set_startknot_id(puint new_startknot_id);
		void set_endknot_id(puint new_endknot_id);

		puint get_startknot_id() const;
		puint get_endknot_id() const;

};

class Face : public Topoobject{ };

#endif

l'abra d'or schrieb:

darkfate schrieb:

Könntest du mir jetzt bitte erklären warum die getter uns setter da unsinning sein sollten?

Die getter sind nicht das Problem. Und ein setter setzt normalerweise was, oder? Dein setter ist aber nur ein non-const-ref-getter...

Wie macht man es besser?

Ich möchte die Variable nicht public freigeben.

Bin nicht der Profi, aber statt einer Methoden-Verkettung und den direkten Zugriff auf eine Methode von Klasse B, würde ich vorschlagen zusätzliche Methoden
in Klasse A einfügen:

void set_dimval(int pos,int dim, double val) {sys[pos].set_dim(dim,val);}
double get_dimval(int pos, int dim)const {return sys[pos].get_dim(dim);}

//Nutzung, finde ich intuitiver
classa.set_dimval(i,j,1.0);
classa.get_dimval(i,j);

Hat aus meiner Sicht auch den Vorteil, dass der Benutzer von A sich nur mit dem Interface von A auseinandersetzen muss.

...

Guter Einwand. Dann hätte ich aber vier statt zwei Funktionen..