Varios problemas cuando se utiliza el C ++ shared_ptr

shared_ptr. punteros inteligentes c ++ puntero con el fin de mejorar la seguridad y la gestión de memoria mayor comodidad. Potente, sino también prestar atención a las siguientes preguntas:

1, no puede utilizar el puntero ordinario asignado a él

	int* pIntValue = new int;
	shared_ptr<int> shPtr= pIntValue;  // 语法错误
	shPtr = pIntValue;  // 语法错误

2, shared_ptr múltiples referencias a los mismos datos, dará lugar a la liberación de la misma memoria dos veces.

int* pIntArr = new int[10];
shared_ptr<int> sp1(pIntArr );
shared_ptr<int> sp2(pIntArr );// 析构时两次释放同一内存

3, usando el puntero shared_ptr para llevar este paquete.

la práctica de error:

class Test
{
public:
	Test() {};
	~Test() {};
public:
  shared_ptr<Test> sget()
  {
    return shared_ptr<Test>(this);
  }
};
Test one;
shared_ptr<Test> two=  one.sget();// 两次释放t对象破坏堆栈
// 两次释放one对象破坏堆栈!!!!!
// 两次释放one对象破坏堆栈!!!!!
// 两次释放one对象破坏堆栈!!!!!

Buena práctica:

class Test: public enable_shared_from_this<Test>
{
public:
	Test() {};
	~Test() {};
public:
  shared_ptr<Test> sget()
  {
    return shared_from_this();
  }
};
Test one;
shared_ptr<Test> two=  one.sget();// 正确了。

4, shared_ptr referencias circulares una pérdida de memoria.

class father;
class son; 

typedef shared_ptr<father> father_ptr;
typedef shared_ptr<son> son_ptr; 

class father
{
public:
   ~father() {}
   son_ptr m_son;
};
class son
{
public:
   ~son() {}
   father_ptr m_father;
};

  father_ptr f(new father());
  son_ptr s(new son);
  f->m_father= s;
  s->m_son= f;

f El recuento de referencia es 2, el conteo es también 2, la salida, la shared_ptr hizo la operación es simplemente el recuento por 1, si 0 es liberado, es evidente este caso, el recuento de referencia no es 0, haciendo después que f y por puntos a la memoria no se libera, lo que lleva a pérdidas de memoria.

5, el uso de shared_ptr en un programa de multiproceso.

class Test
{
public:
  Test() {}
  ~Test() {}
  // 更多的函数定义…
};
void thread_fun(shared_ptr<Test> sp)
{
  // !!!在这大量使用sp指针.
  shared_ptr<Test> tmp = sp;
}
shared_ptr<Test> sp1(new Test);

thread t1(bind(&fun, sp1));
thread t2(bind(&fun, sp1));
t1.join();
t2.join();

Dado que el multi-hilo de acceder a los punteros inteligentes, y asignados a otros punteros inteligentes similares, dos hilos podrían ocurrir mientras el contador de referencia de funcionamiento, que en el caso de avería o recuento no válida y similares.
Uso weak_ptr clase puede resolver el problema de múltiples hilos.

void fun(weak_ptr<Test> wp)
{
  shared_ptr<Test> sp = wp.lock;
  if (sp)
  {
    // 在这里可以安全的使用sp指针.
  }
  else
  {
    // 指针无效
  }
}