AtomicCounter.h 线程安全的原子引用计数 实现
//
// AtomicCounter.h
//
// Library: Foundation
// Package: Core
// Module:AtomicCounter
//
// Definition of the AtomicCounter class.
//
// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier:BSL-1.0
//#ifndef Foundation_AtomicCounter_INCLUDED
#define Foundation_AtomicCounter_INCLUDEDnamespace Poco {class AtomicCounter
/// This class implements a simple counter, which
/// provides atomic operations that are safe to
/// use in a multithreaded environment.
///
/// Typical usage of AtomicCounter is for implementing
/// reference counting and similar things.
///
/// On some platforms, the implementation of AtomicCounter
/// is based on atomic primitives specific to the platform
/// (such as InterlockedIncrement, etc. on Windows), and
/// thus very efficient. On platforms that do not support
/// atomic primitives, operations are guarded by a FastMutex.
///
/// The following platforms currently have atomic
/// primitives:
///- Windows
///- Mac OS X
///- GCC 4.1+ (Intel platforms only)
{
public:
typedef int ValueType;
/// The underlying integer type.AtomicCounter();
/// Creates a new AtomicCounter and initializes it to zero.explicit AtomicCounter(ValueType initialValue);
/// Creates a new AtomicCounter and initializes it with
/// the given value.AtomicCounter(const AtomicCounter &counter);
/// Creates the counter by copying another one.~AtomicCounter();
/// Destroys the AtomicCounter.AtomicCounter &operator=(const AtomicCounter &counter);
/// Assigns the value of another AtomicCounter.AtomicCounter &operator=(ValueType value);
/// Assigns a value to the counter.operator ValueType() const;
/// Returns the value of the counter.ValueType value() const;
/// Returns the value of the counter.ValueType operator++();
// prefix
/// Increments the counter and returns the result.ValueType
operator++(int);
// postfix
/// Increments the counter and returns the previous value.ValueType operator--();
// prefix
/// Decrements the counter and returns the result.ValueType
operator--(int);
// postfix
/// Decrements the counter and returns the previous value.bool operator!() const;
/// Returns true if the counter is zero, false otherwise.private:
typedef int ImplType;
ImplType _counter;
};
AtomicCounter::AtomicCounter() : _counter(0) {}AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue)
: _counter(initialValue) {}AtomicCounter::AtomicCounter(const AtomicCounter &counter)
: _counter(counter.value()) {}AtomicCounter::~AtomicCounter() {}//
// GCC 4.1+ atomic builtins.
//
inline AtomicCounter::operator AtomicCounter::ValueType() const {
return _counter;
}inline AtomicCounter::ValueType AtomicCounter::value() const {
return _counter;
}inline AtomicCounter::ValueType AtomicCounter::operator++() // prefix
{
return __sync_add_and_fetch(&_counter, 1);
}inline AtomicCounter::ValueType AtomicCounter::operator++(int) // postfix
{
return __sync_fetch_and_add(&_counter, 1);
}inline AtomicCounter::ValueType AtomicCounter::operator--() // prefix
{
return __sync_sub_and_fetch(&_counter, 1);
}inline AtomicCounter::ValueType AtomicCounter::operator--(int) // postfix
{
return __sync_fetch_and_sub(&_counter, 1);
}inline bool AtomicCounter::operator!() const { return _counter == 0;
}} // namespace Poco#endif // Foundation_AtomicCounter_INCLUDED
【linux gcc 下 没有c++11 时的智能指针实现 参考POCO】SharedPtr 智能指针的实现
//
// SharedPtr.h
//
// Library: Foundation
// Package: Core
// Module:SharedPtr
//
// Definition of the SharedPtr template class.
//
// Copyright (c) 2005-2008, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier:BSL-1.0
//#ifndef Foundation_SharedPtr_INCLUDED
#define Foundation_SharedPtr_INCLUDED#include "AtomicCounter.h"
#include
#include
#include
#include namespace Poco {class ReferenceCounter
/// Simple ReferenceCounter object, does not delete itself when count reaches 0.
{
public:
ReferenceCounter() : _cnt(1) {}void duplicate() { ++_cnt;
}int release() { return --_cnt;
}int referenceCount() const { return _cnt.value();
}private:
AtomicCounter _cnt;
};
template
class ReleasePolicy
/// The default release policy for SharedPtr, which
/// simply uses the delete operator to delete an object.
{
public:
static void release(C *pObj)
/// Delete the object.
/// Note that pObj can be 0.
{
delete pObj;
}
};
template
class ReleaseArrayPolicy
/// The release policy for SharedPtr holding arrays.
{
public:
static void release(C *pObj)
/// Delete the object.
/// Note that pObj can be 0.
{
delete[] pObj;
}
};
template >
class SharedPtr
/// SharedPtr is a "smart" pointer for classes implementing
/// reference counting based garbage collection.
/// SharedPtr is thus similar to AutoPtr. Unlike the
/// AutoPtr template, which can only be used with
/// classes that support reference counting, SharedPtr
/// can be used with any class. For this to work, a
/// SharedPtr manages a reference count for the object
/// it manages.
///
/// SharedPtr works in the following way:
/// If an SharedPtr is assigned an ordinary pointer to
/// an object (via the constructor or the assignment operator),
/// it takes ownership of the object and the object's reference
/// count is initialized to one.
/// If the SharedPtr is assigned another SharedPtr, the
/// object's reference count is incremented by one.
/// The destructor of SharedPtr decrements the object's
/// reference count by one and deletes the object if the
/// reference count reaches zero.
/// SharedPtr supports dereferencing with both the ->
/// and the * operator. An attempt to dereference a null
/// SharedPtr results in a NullPointerException being thrown.
/// SharedPtr also implements all relational operators and
/// a cast operator in case dynamic casting of the encapsulated data types
/// is required.
{
public:
SharedPtr() : _pCounter(new RC), _ptr(0) {}SharedPtr(C *ptr) try : _pCounter(new RC), _ptr(ptr) {
} catch (...) {
RP::release(ptr);
}template
SharedPtr(const SharedPtr &ptr)
: _pCounter(ptr._pCounter), _ptr(const_cast(ptr.get())) {
_pCounter->duplicate();
}SharedPtr(const SharedPtr &ptr) : _pCounter(ptr._pCounter), _ptr(ptr._ptr) {
_pCounter->duplicate();
}~SharedPtr() {
try {
release();
} catch (...) {
assert(0);
}
}SharedPtr &assign(C *ptr) {
if (get() != ptr) {
SharedPtr tmp(ptr);
swap(tmp);
}
return *this;
}SharedPtr &assign(const SharedPtr &ptr) {
if (&ptr != this) {
SharedPtr tmp(ptr);
swap(tmp);
}
return *this;
}template
SharedPtr &assign(const SharedPtr &ptr) {
if (ptr.get() != _ptr) {
SharedPtr tmp(ptr);
swap(tmp);
}
return *this;
}SharedPtr &operator=(C *ptr) { return assign(ptr);
}SharedPtr &operator=(const SharedPtr &ptr) { return assign(ptr);
}template
SharedPtr &operator=(const SharedPtr &ptr) {
return assign(ptr);
}void swap(SharedPtr &ptr) {
std::swap(_ptr, ptr._ptr);
std::swap(_pCounter, ptr._pCounter);
}template
SharedPtr cast() const
/// Casts the SharedPtr via a dynamic cast to the given type.
/// Returns an SharedPtr containing NULL if the cast fails.
/// Example: (assume class Sub: public Super)
///SharedPtr super(new Sub());
///SharedPtr sub = super.cast();
///poco_assert (sub.get());
{
Other *pOther = dynamic_cast(_ptr);
if (pOther)
return SharedPtr(_pCounter, pOther);
return SharedPtr();
}template
SharedPtr unsafeCast() const
/// Casts the SharedPtr via a static cast to the given type.
/// Example: (assume class Sub: public Super)
///SharedPtr super(new Sub());
///SharedPtr sub = super.unsafeCast();
///poco_assert (sub.get());
{
Other *pOther = static_cast(_ptr);
return SharedPtr(_pCounter, pOther);
}C *operator->() { return deref();
}const C *operator->() const { return deref();
}C &operator*() { return *deref();
}const C &operator*() const { return *deref();
}C *get() { return _ptr;
}const C *get() const { return _ptr;
}operator C *() { return _ptr;
}operator const C *() const { return _ptr;
}bool operator!() const { return _ptr == 0;
}bool isNull() const { return _ptr == 0;
}bool operator==(const SharedPtr &ptr) const { return get() == ptr.get();
}bool operator==(const C *ptr) const { return get() == ptr;
}bool operator==(C *ptr) const { return get() == ptr;
}bool operator!=(const SharedPtr &ptr) const { return get() != ptr.get();
}bool operator!=(const C *ptr) const { return get() != ptr;
}bool operator!=(C *ptr) const { return get() != ptr;
}bool operator<(const SharedPtr &ptr) const { return get() < ptr.get();
}bool operator<(const C *ptr) const { return get() < ptr;
}bool operator<(C *ptr) const { return get() < ptr;
}bool operator<=(const SharedPtr &ptr) const { return get() <= ptr.get();
}bool operator<=(const C *ptr) const { return get() <= ptr;
}bool operator<=(C *ptr) const { return get() <= ptr;
}bool operator>(const SharedPtr &ptr) const { return get() > ptr.get();
}bool operator>(const C *ptr) const { return get() > ptr;
}bool operator>(C *ptr) const { return get() > ptr;
}bool operator>=(const SharedPtr &ptr) const { return get() >= ptr.get();
}bool operator>=(const C *ptr) const { return get() >= ptr;
}bool operator>=(C *ptr) const { return get() >= ptr;
}int referenceCount() const { return _pCounter->referenceCount();
}protected:
C *deref() const {
if (!_ptr)
throw std::exception();
return _ptr;
}void release() {
assert(_pCounter);
int i = _pCounter->release();
if (i == 0) {
RP::release(_ptr);
_ptr = 0;
delete _pCounter;
_pCounter = 0;
}
}SharedPtr(RC *pCounter, C *ptr)
: _pCounter(pCounter), _ptr(ptr)
/// for cast operation
{
poco_assert_dbg(_pCounter);
_pCounter->duplicate();
}protected:
RC *_pCounter;
C *_ptr;
template friend class SharedPtr;
};
template
inline void swap(SharedPtr &p1, SharedPtr &p2) {
p1.swap(p2);
}} // namespace Poco#endif // Foundation_SharedPtr_INCLUDED
