Czy inteligentne wskaźniki mogą selektywnie ukrywać lub przekierowywać wywołania funkcji do obiektów, które owijają?

Question

Pracuję nad projektem, do którego odwoływano się z określonymi obiektami - to bardzo podobne ustawienie do COM. W każdym razie nasz projekt ma inteligentne wskaźniki, które zmniejszają potrzebę jawnego wywoływania funkcji Add() i Release() dla tych obiektów. Problem polega na tym, że czasami deweloperzy wciąż wywołują funkcję Release() za pomocą inteligentnego wskaźnika.

To, czego szukam, to metoda wywoływania funkcji Release() z inteligentnego wskaźnika, powodująca błąd kompilacji lub wykonywania. Czas kompilacji nie wydaje mi się możliwy. Myślałem, że mam rozwiązanie czasu pracy (zobacz kod poniżej), ale nie całkiem się kompiluje. Najwyraźniej niejawna konwersja nie jest dozwolona po użyciu operatora ->().

W każdym razie, czy ktoś może pomyśleć o sposobie osiągnięcia tego, co próbuję osiągnąć?

Dziękujemy za pomoc!

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; 
} 

Answer 1

Nie możesz tego zrobić - po przeciążeniu operator -> utkniesz - przeciążony operator będzie zachowywał się w ten sam sposób, bez względu na to, co znajduje się w jego prawej części.

Możesz zadeklarować metody Add() i Release() jako prywatne i uczynić inteligentny wskaźnik przyjacielem klasy zliczającej referencje.

Answer 2

operator-> musi powrócić wskaźnik lub obiektu, który sam wspiera operator->. Może być rekurencyjny. To, czego nie możesz zrobić, to mieć różne zachowanie w zależności od tego, co pojawia się po prawej stronie ->.

Nie mogę wymyślić żadnego podejścia, które nie wymaga w jakiś sposób replikowania interfejsów wskazanych obiektów, ani nie wymaga tworzenia obiektów publicznie wyprowadzonych z wskazanych obiektów z ukrytymi i ukrytymi dodatkami i prywatnymi. klasa pochodna i za pomocą sztuczki Base* pBase = pDerived; pBase->Add(); wywoływać dodawanie i zwalnianie z inteligentnego wskaźnika.

Answer 3

mam go do pracy przez zmianę przeciążony operator w MySmartPtr i dodanie operatora przeciążenia w MySmartPtrHelper:

#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; 
    } 

    T* operator->() 
    { 
     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) 
    { 
    } 

    T* operator->() 
    { 
     return m_helper.operator->(); 
    } 
}; 

int main() 
{ 
    A a; 

    MySmartPtr<A> pA(&a); 

    pA->Foo(); 
    //pA->Release(); // this will correctly assert if uncommented. 

    return 0; 
} 

wyjściowa:

macbook-2:~ $ ./a.out 
A::Add 
A::Foo 
A::Release 

Answer 4

Proponuję użyć coś podobnego do następującego kodu. Czego chcesz, nie jest możliwe chyba że jesteś skłonny dodać małe ograniczenie: obiekty muszą być możliwe do skopiowania (i nie masz nic przeciwko użyciu tej możliwości). W takim przypadku dziedziczenie to dobry sposób na odejście.

#include <iostream> 
#include <cassert> 

using namespace std; 

template <class T> 
class MySmartPtrHelper : public T 
{ 

public: 

    MySmartPtrHelper(T* _t) 
     : m_t(*_t) 
    { 
     delete _t; 
     ((T*) this)->Add(); 
    } 

    ~MySmartPtrHelper() 
    { 
     ((T*) this)->Release(); 
    } 

    void Add() 
    { 
     cout << "MySmartPtrHelper::Add()" << endl; 
     //will yield a compile-time error 
     BOOST_STATIC_ASSERT(false) 
    } 

    void Release() 
    { 
     cout << "MySmartPtrHelper::Release()" << endl; 
     //will yield a compile-time error 
     BOOST_STATIC_ASSERT(false) 
    } 
}; 

template <class T> 
class MySmartPtr 
{ 
    MySmartPtrHelper<T>* m_helper; 
    // Uncomment if you want to use boost to manage memory 
    // boost::shared_ptr<MySmartPtrHelper<T> > m_helper; 

public: 

    MySmartPtr(T* _pT) 
     : m_helper(new MySmartPtrHelper<T>(_pT)) 
    { 
    } 

    MySmartPtrHelper<T>* operator->() 
    { 
     return m_helper; 
    } 
}; 

int main() 
{ 
    MySmartPtr<A> pA(new A()); 

    pA->Foo(); 

    //pA->Release(); // this will correctly assert if uncommented. 

    return 0; 
}