Konvertierung zu Pointer auf Konstante

muffmolch

hätte ich jetzt auch gesagt:

const std::vector<const partition_node*> get_part_nodes() 
{ 
   std::vector<const partition*> tmp;
   std::copy(nodes.begin(),nodes.end(), back_inserter(tmp));
   return tmp;
}

aber Braunsteins ist etwas schlanker...

ach ja und da dann eh ein unveränderliches Objekt zugewiesen wird, kannst du die Methode gleich auch const deklarieren:

const std::vector<const partition_node*> get_part_nodes() const
{...}

drakon

Also man kann mit dem zurückgegebenen nichts in der Klasse verändern.
Ist ja kein Zeiger, oder Referenz, sondern wird ja kopiert.

Wenn dann mach das Objekt const, dass du nacher brauchst.

partition_tree a;

const vector<const partition_node*> obj = a.get_part_nodes ();

Da kannst du auch nichts mehr dran ändenr.

muffmolch

also wenn ich das richtig sehe, so möchte ingobulla sich eben ne liste mit allen knoten zurück geben lassen und sicher gehen, dass die knoten-objekte NICHT vereändert werden können.

Da macht

const std::vector<const partition_node*> get_part_nodes() const 
{...}

das durchaus Sinn udn ist sogar die einzige Alternative!

Und die Rückgabe in ein konstantes Objekt reicht da nicht aus...

Nimm Braunsteinslösung und alles wird gut. Eine atumatische Konvertierung macht der compiler eben nicht!

ingobulla

Danke, das hat mir auf jeden Fall weitergeholfen. Hier noch eine darauf aufbauende Frage:

Angenommen ich möchte nicht eine Kopie von part_nodes, sondern einen Zeiger auf part_nodes zurückgeben, der dem Benutzer von get_part_nodes() erlaubt, part_nodes zu lesen, aber nicht zu verändern. Wie macht man das am besten?

Die folgende Lösung wird ja wohl nicht gehen, da ich eine Referenz auf ein lokales Objekt zurückgebe, dessen Destruktor nach verlassen des Gültigkeitsbereichs von get_part_nodes() aufgerufen wird.

class partition_tree
{
private:
    vector<partition_node*> part_nodes;
public:
    const vector<const partition_node*>* get_part_nodes() 
    { 
        return &(vector<const partition_node*>(part_nodes.begin(), part_nodes.end())); 
    }
};

Wenn ich stattdessen new benutze, wäre der Benutzer von get_part_nodes() doch gezwungen die Rückgabe von get_part_nodes() mittels delete zu löschen?

Und allgemeiner gefragt: Wenn man eine Variable wie part_nodes in einer Klasse hat und diese Variable mit einer Methode get_part_nodes() zum Nur-Lesen herausgeben will, wie macht man das am besten? Insbesondere: Geht das auch irgendwie ohne Kopieraktionen?

camper

Warum muss es denn unbedingt ein vector sein? Wenn man nur Lesen will, dürfte eine einfache Sequenz ausreichen, und man spart so unnötiges Kopieren. Wenn der Aufrufer unbedingt einen vector haben will, kann er den ja immer noch initialisieren.

class partition_tree
{
private:
    vector<partition_node*> part_nodes;
public:
    std::pair<vector<partition_node*>::const_iterator, vector<partition_node*>::const_iterator> get_part_nodes() const { return make_pair(part_nodes.begin(),part_nodes.end()); }
};

nebenbei: vergiss const-Rückgaben. Die sind fast immer großer Blödsinn.

Badestrand

camper schrieb:

nebenbei: vergiss const-Rückgaben. Die sind fast immer großer Blödsinn.

Was würden denn dagegen sprechen:

class partition_tree
{
private:
    vector<partition_node*> part_nodes;
public:
    const vector<const partition_node*>& get_part_nodes() const
    {
        return part_nodes;
    }
};

?

queer_boy

nichts, aber der OP macht eine rückgabe per value, hat also eine konstante kopie.

und sowas verwendet man idR auch nur bei überladung gewisser operatoren - selbst da ist die verwendung umstritten und dient nur dem zweck, user-defined typen den builtins ein bisschen ähnlicher zu machen. (und ich weiß zufällig, das camper auch auf diesen einsatz von const-rückgaben gar nicht steht).

camper

Badestrand schrieb:

camper schrieb:

nebenbei: vergiss const-Rückgaben. Die sind fast immer großer Blödsinn.

Was würden denn dagegen sprechen:
class partition_tree
{
private:
    vector<partition_node*> part_nodes;
public:
    const vector<const partition_node*>& get_part_nodes() const
    {
        return part_nodes;
    }
};
?

Dass es nicht möglich ist?

Simon2

queer_boy schrieb:

nichts, aber der OP macht eine rückgabe per value, ...

Badestrand schrieb:

const vector<const partition_node*>& // <- Hier steht allerdings ein &

Aber wenn camper schreibt, dass das verboten sei, glaube ich ihm das....

Gruß,

Simon2.

queer_boy

er bezieht sich in seinem letzten posting ja nur darauf, dass vector<X*> und vector<const X*> zwei verschiedene typen sind...

camper

ah sorry, es ging ja eigentlich darum, dass auch die Zeiger konstant sein sollen, ein const_iterator genügt da nat. noch nicht:

class partition_tree
{
private:
    vector<partition_node*> part_nodes;
public:
    std::pair<const partition_node* const*, const partition_node* const*> get_part_nodes() const { return make_pair(&*part_nodes.begin(),&*part_nodes.end()); }
};

Braunstein

Ich denke hier wäre vielleicht ein typedef angebracht.

Badestrand

camper schrieb:

Badestrand schrieb:
Was würden denn dagegen sprechen:
class partition_tree
{
private:
    vector<partition_node*> part_nodes;
public:
    const vector<const partition_node*>& get_part_nodes() const
    {
        return part_nodes;
    }
};
?
Dass es nicht möglich ist?

Ich meinte eigentlich ohne das "const" im Template-Parameter... Aber ok, dann wär's Unfug, weil man die Objekte verändern könnte.