nachdem ich viel gesucht und gelesen habe, bin ich leider nur noch verwirrter geworden, da dies ein ziemlich unschönes Thema in C++ zu sein scheint.

Meine Frage ist:

Weiß jemand ob es möglich ist unter C++11 einen vector von konstanten Pointern auf Objekte anzulegen, ohne die Objekte selbst konstant machen zu müssen?

Also z.B.:

vector<Node* const> nodes;

BOOST_FOREACH(Node* const n, nodes)
{
n->number = 5;
}

Soweit ich das verstehe geht das ja so für einzelne pointer;

int* const pY;              // constant pointer to changeable int
*pY = 4;                    // legal - can use pY to modify an int
pY = &someOtherIntVar;      // illegal - can't make pY point anywhere else

Benutze ich allerdings einen vector, gibt es die unten beschriebenen Fehlermeldungen in new_allocator.h

Grüße
Perhalo

Und macht "er" das kommentarlos?

Guter Kommentar! Ich schreib das gleich nochmal schöner.

/usr/include/c++/4.4.7/ext/new_allocator.h:79: error: 'const _Tp* __gnu_cxx::new_allocator<_Tp>::address(const _Tp&) const [with _Tp = SGENode* const]' cannot be overloaded

/usr/include/c++/4.4.7/ext/new_allocator.h:76: error: with '_Tp* __gnu_cxx::new_allocator<_Tp>::address(_Tp&) const [with _Tp = SGENode* const]'

int main()
{
  int a = 9;
  int* const ptr;// = &a;
  *ptr = 17;
}

g++ schrieb:

y.cpp:4:14: error: uninitialized const ‘ptr’ [-fpermissive]
int* const ptr;// = &a;

Welchen Sinn soll dieses merkwürdige Vectorkonstrukt haben?

Darauf ihn zu ändern habe ich keinen Zugriff. Leider muss ich jetzt an einer späteren Stelle im Code die Member aller Objekte in diesem container ändern.

Wenn du den Kommentar wieder löschst und deinen pointer zuweist, lässt sich dein Code übrigens auch compilieren.

Der Vektor ist im Projekt vorhanden.

Das bezweifle ich stark. Übersetze mal

#include <vector>

int main()
{
        std::vector<int* const> v;
}

Perhalo schrieb:

Wenn du den Kommentar wieder löschst und deinen pointer zuweist, lässt sich dein Code übrigens auch compilieren.

Ach

template <class T>
class const_ptr_wrapper {
public:
  // construct/copy/destroy
  const_ptr_wrapper(T* const ptr) noexcept : _ptr{ptr} {}
  const_ptr_wrapper(T&&) = delete;
  const_ptr_wrapper(const const_ptr_wrapper&) noexcept = default; 
  const_ptr_wrapper() : _ptr{nullptr} {} //wozuuu??
  // assignment = default deleted (assignment für ein *const geht nicht)

  operator T* () const noexcept { return _ptr; } //kopie eines *const ist nicht const.
  T* get() const noexcept { return _ptr; } 

private:
  T* const _ptr;
};

//...
std::vector<const_ptr_wrapper<int>> vector;
int i = 42;
vector.push_back(&i);

//fülle einen vector mit 42 nie mehr änderbaren nullptr...
vector.resize(42);

bloß wozu?

z.B. kann (VS2010)VS2015

const std::vector<const int> blub = {10,20,30};

libstdc++ 6.1 kann es nicht

mal unabhängig von dem Sinn

es gibt Lücken in der Anpassung für Move-Semantik