ich habe folgende Klasse partition_tree (nur das wesentliche):

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

Dabei ist partition_node irgendeine Klasse.

Nun hätte ich gerne, dass get_part_nodes() einen Vektor aus Pointern auf Konstanten zurückgibt (Schließlich ist diese Methode öffentlich und man soll damit keine Veränderungen an part_nodes vornehmen dürfen). Die Veränderung

const vector<const partition_node*> get_part_nodes() { return part_nodes; }

führt allerdings zur Fehlermeldung

conversion from ‘std::vector<partition_node*, std::allocator<partition_node*> >’ to non-scalar type ‘std::vector<const partition_node*, std::allocator<const partition_node*> >’ requested

Wie behebt man das am besten?

const vector<const partition_node*> get_part_nodes() 
{ 
  return vector<const partition_node*>(part_nodes.begin(), part_nodes.end()); 
}

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
{...}

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.

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!

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?

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.

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;
    }
};

?

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 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?

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.

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()); }
};

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.