Como posso manter a referência no boost :: shared_ptr usando o boost :: bind sem definição de função explícita?

Question

Quero manter a referência ao objeto para que ele não seja excluído na função Bind, mas sem usar a função auxiliar.

struct Int
{
   int *_int;
   ~Int(){ delete _int; }
};

void holdReference(boost::shared_ptr<Int>, int*) {} // helper

boost::shared_ptr<int> fun()
{
   boost::shared_ptr<Int> a ( new Int ); 
   // I get 'a' from some please else, and want to convert it
   a->_int = new int;

   return boost::shared<int>( a->_int, boost::bind(&holdReference, a, _1) );

}

Existe uma maneira de declarar a função de referência de retenção? Como nas expressões lambda ou sth? (sem usar essa função desagradável de referência, que precisam ser declarados fora do escopo da função divertida) Tive poucas tentativas, mas não deles compilados :)

Ok, aqui está um exemplo mais detalhado:

#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>

// the case looks more or less like this
// this class is in some dll an I don't want to use this class all over my project
// and also avoid coppying the buffer
class String_that_I_dont_have 
{
    char * _data; // this is initialized in 3rd party, and released by their shared pointer

public:
    char * data() { return _data; }
};


// this function I created just to hold reference to String_that_I_dont_have class 
// so it doesn't get deleted, I want to get rid of this
void holdReferenceTo3rdPartyStringSharedPtr( boost::shared_ptr<String_that_I_dont_have>, char *) {}


// so I want to use shared pointer to char which I use quite often 
boost::shared_ptr<char> convert_function( boost::shared_ptr<String_that_I_dont_have> other) 
// 3rd party is using their own shared pointers, 
// not the boost's ones, but for the sake of the example ...
{
    return boost::shared_ptr<char>( 
        other->data(), 
        boost::bind(
            /* some in place here instead of holdReference... */
            &holdReferenceTo3rdPartyStringSharedPtr   , 
            other, 
            _1
        )
    );
}

int main(int, char*[]) { /* it compiles now */ }

// I'm just looking for more elegant solution, for declaring the function in place

Answer 1

Você pode estar procurando o construtor "Propriedade compartilhada", isso permite a contagem de um ponteiro interior.

struct Int
{
   int *_int;
   ~Int(){ delete _int; }
};

boost::shared_ptr<int> fun()
{
   boost::shared_ptr<Int> a (new Int);
   a->_int = new int;

   // refcount on the 'a' instance but expose the interior _int pointer
   return boost::shared_ptr<int>(a, a->_int);
}

Answer 2

Estou um pouco confuso com o que você está tentando fazer aqui.

É divertido () para retornar boost::shared_ptr<int> ou boost::shared_ptr<Int>???

Eu não acho que você queira criar um shared_ptr<int> Esse é um ponteiro compartilhado em torno de um ponteiro bruto que pertence diretamente ao objeto INT, pois o objeto int excluirá o _int sempre que sair do escopo (mesmo que no exemplo não fosse 'novo'!).

Você precisa criar um modelo claro de propriedade/responsabilidade.

Talvez você possa fornecer um exemplo diferente, mais realista, do que está tentando alcançar?