Sto lavorando a un progetto in cui vengono conteggiati determinati oggetti conteggiati: è un'impostazione molto simile a COM. Ad ogni modo, il nostro progetto ha degli indicatori intelligenti che alleggeriscono la necessità di chiamare esplicitamente Add() e Release() per questi oggetti. Il problema è che a volte gli sviluppatori chiamano ancora Release() con il puntatore intelligente.I puntatori intelligenti possono nascondere o reindirizzare selettivamente le chiamate di funzione agli oggetti che stanno avvolgendo?
Quello che sto cercando è un modo per chiamare Release() dal puntatore intelligente per creare un errore in fase di compilazione o in fase di esecuzione. Il tempo di compilazione non mi sembra possibile. Pensavo di avere una soluzione run-time (vedi il codice sotto), ma non è abbastanza compilativa neanche. Apparentemente, la conversione implicita non è consentita dopo aver usato l'operatore ->().
In ogni caso, qualcuno può pensare a un modo per realizzare ciò che sto cercando di realizzare?
Mille grazie per il vostro aiuto!
Kevin
#include <iostream>
#include <cassert>
using namespace std;
class A
{
public:
void Add()
{
cout << "A::Add" << endl;
}
void Release()
{
cout << "A::Release" << endl;
}
void Foo()
{
cout << "A::Foo" << endl;
}
};
template <class T>
class MySmartPtrHelper
{
T* m_t;
public:
MySmartPtrHelper(T* _t)
: m_t(_t)
{
m_t->Add();
}
~MySmartPtrHelper()
{
m_t->Release();
}
operator T&()
{
return *m_t;
}
void Add()
{
cout << "MySmartPtrHelper::Add()" << endl;
assert(false);
}
void Release()
{
cout << "MySmartPtrHelper::Release()" << endl;
assert(false);
}
};
template <class T>
class MySmartPtr
{
MySmartPtrHelper<T> m_helper;
public:
MySmartPtr(T* _pT)
: m_helper(_pT)
{
}
MySmartPtrHelper<T>* operator->()
{
return &m_helper;
}
};
int main()
{
A a;
MySmartPtr<A> pA(&a);
pA->Foo(); // this currently fails to compile. The compiler
// complains that MySmartPtrHelper::Foo() doesn't exist.
//pA->Release(); // this will correctly assert if uncommented.
return 0;
}
Si prega di sostituire l'allocazione di stack "A a" con una nuova allocazione operatore? Questo non cambierà il problema originale, ma rimuoverà uno dei tipici errori brutti con l'utilizzo di puntatori intelligenti di conteggio dei riferimenti. – sharptooth