18

How can one convert a shared_ptr that points to a const object to a shared_ptr that points to a non-const object. I am trying to do the following :

boost::shared_ptr<const A> Ckk(new A(4));

boost::shared_ptr<A> kk=const_cast< boost::shared_ptr<A> > Ckk;

But it does not work.

SCFrench
  • 8,244
  • 2
  • 31
  • 61
user152508
  • 3,053
  • 8
  • 38
  • 58

4 Answers4

31

'boost::const_pointer_cast' will do what you're asking for, but the obligatory second half of the answer is that you probably shouldn't use it. 99% of the time when it seems like you need to cast away the const property of a variable, it means that you have a design flaw. Const is sometimes more than just window dressing and casting it away may lead to unexpected bugs.

Without knowing more details of your situation one can't say for certain. But no discussion of const-cast is complete without mentioning this fact.

Alan
  • 4,897
  • 2
  • 24
  • 17
  • 1
    Using `const_pointer_cast` is not a design flaw far more often than you estimate. For example, standard containers can operate only with types that are convertible to the type of the contained elements. So the following is not possible even though it is logically correct: `vector> cont; shared_ptr a; cont.push_back(a);` –  Jun 02 '11 at 16:12
  • 11
    @jons34yp: There is nothing logically correct about that. You were given a _const_ pointer; that means you are not allowed to use it in a non-const fashion. If you have a list of non-const pointers and you want to put a const pointer in it, tough. By const-casting it, you are violating a contract with the person who gave you that pointer (that contract being that you weren't to change it). This is just as true for regular pointers as shared_ptr's. – Nicol Bolas Jul 15 '11 at 06:01
  • const_pointer_cast can be useful if you're extending the behavior of a shared pointer. But you should probably only be doing that if you're the type of person that might actually make contributions to boost. – Brent Oct 15 '12 at 19:15
  • @Brent "_extending the behavior of a shared pointer_" what do you mean? – curiousguy Apr 05 '17 at 19:26
10

use boost::const_pointer_cast, documentation.

Nikola Smiljanić
  • 26,745
  • 6
  • 48
  • 60
2

the proper way should be this 

boost::shared_ptr<A> kk (boost::const_pointer_cast<A>(Ckk));
YeenFei
  • 3,180
  • 18
  • 26
2

std::const_cast_pointer makes a second managed pointer. After the cast you have a writable pointer and the original const-pointer. The pointee remains the same. The reference count has been increased by 1.

Note that const_cast is a builtin keyword, but const_pointer_cast is a template function in namespace std.

The writable pointer can then be used to change the value from under the shared_ptr<const T>. IMHO the writable pointer should only persist temporarily on the stack; otherwise there must be a design flaw.

I once wrote a small test program to make this clear to myself which I adapted for this thread:

#include <memory>
#include <iostream>
#include <cassert>

using namespace std;

typedef shared_ptr<int> int_ptr;
typedef shared_ptr<const int> const_int_ptr;

int main(void)
{
    const_int_ptr Ckk(new int(1));

    assert(Ckk.use_count() == 1);
    cout << "Ckk = " << *Ckk << endl;

    int_ptr kk = const_pointer_cast<int>(Ckk); // obtain a 2nd reference
    *kk = 2;                   // change value under the const pointer

    assert(Ckk.use_count() == 2);
    cout << "Ckk = " << *Ckk << endl;      // prints 3
}

Under UNIX or Windows/Cygwin, compile with

g++ -std=c++0x -lm const_pointer_cast.cpp
Andreas Spindler
  • 7,568
  • 4
  • 43
  • 34