आप एक नई पद्धति के कारण के बारे में बात कर रहे हैं इससे पहले कि नाम से जाना/एक समारोह शरीर के बाद, समारोह शरीर को बदले बिना, आप इसे this है, जो एक कस्टम shared_ptr Deleter के बाद शरीर समारोह को गति प्रदान करने का उपयोग करता है पर आधार कर सकते हैं । इसका उपयोग try/catch के लिए नहीं किया जा सकता है, क्योंकि इस तकनीक का उपयोग करके पहले और बाद में अलग-अलग कार्यों की आवश्यकता होती है।
इसके अलावा, संस्करण नीचे shared_ptr का उपयोग करता है, लेकिन साथ सी ++ 11 आप unique_ptr उपयोग करने के लिए बनाने और एक साझा सूचक हर बार जब आप इसका इस्तेमाल को नष्ट करने की लागत के बिना एक ही प्रभाव प्राप्त करने के लिए सक्षम होना चाहिए।
#include <iostream>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/system_clocks.hpp>
#include <boost/shared_ptr.hpp>
template <typename T, typename Derived>
class base_wrapper
{
protected:
typedef T wrapped_type;
Derived* self() {
return static_cast<Derived*>(this);
}
wrapped_type* p;
struct suffix_wrapper
{
Derived* d;
suffix_wrapper(Derived* d): d(d) {};
void operator()(wrapped_type* p)
{
d->suffix(p);
}
};
public:
explicit base_wrapper(wrapped_type* p) : p(p) {};
void prefix(wrapped_type* p) {
// Default does nothing
};
void suffix(wrapped_type* p) {
// Default does nothing
}
boost::shared_ptr<wrapped_type> operator->()
{
self()->prefix(p);
return boost::shared_ptr<wrapped_type>(p,suffix_wrapper(self()));
}
};
template<typename T>
class timing_wrapper : public base_wrapper< T, timing_wrapper<T> >
{
typedef base_wrapper< T, timing_wrapper<T> > base;
typedef boost::chrono::time_point<boost::chrono::system_clock, boost::chrono::duration<double> > time_point;
time_point begin;
public:
timing_wrapper(T* p): base(p) {}
void prefix(T* p)
{
begin = boost::chrono::system_clock::now();
}
void suffix(T* p)
{
time_point end = boost::chrono::system_clock::now();
std::cout << "Time: " << (end-begin).count() << std::endl;
}
};
template <typename T>
class logging_wrapper : public base_wrapper< T, logging_wrapper<T> >
{
typedef base_wrapper< T, logging_wrapper<T> > base;
public:
logging_wrapper(T* p): base(p) {}
void prefix(T* p)
{
std::cout << "entering" << std::endl;
}
void suffix(T* p)
{
std::cout << "exiting" << std::endl;
}
};
template <template <typename> class wrapper, typename T>
wrapper<T> make_wrapper(T* p)
{
return wrapper<T>(p);
}
class X
{
public:
void f() const
{
sleep(1);
}
void g() const
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
}
};
int main() {
X x1;
make_wrapper<timing_wrapper>(&x1)->f();
make_wrapper<logging_wrapper>(&x1)->g();
return 0;
}
स्रोत
2011-10-12 17:54:19
हाल ही में रेमंड चेन ने लिखा [http://blogs.msdn.com/b/oldnewthing/archive/2011/09/21/10214405.aspx) विंडोज इस – Praetorian
को कैसे पूरा करता है तो आपका मतलब एओपी है? –
@ आर। मार्टिन्होफर्नैंड्स हाँ, सबसे प्रासंगिक एक का उल्लेख करना भूल गए। – StackedCrooked