System::SmartPtr class

SmartPtr class

Pointer class to wrap types being allocated on heap. Use it to manage memory for classes inheriting Object. This pointer type follows intrusive pointer semantics. Reference counter is stored either in Object itself or in counter structure which is tied to Object instance tightly. In any case, all SmartPtr instances form single ownership group regardless how they were created which is unlike how std::shared_ptr class behaves. Converting raw pointer to SmartPtr is safe given there are other SmartPtr instances holding shared references to the same object. SmartPtr class instance can be in one of two states: shared pointer and weak pointer. To keep object alive, one should have count of shared references to it positive. Both weak and shared pointers can be used to access pointed object (to call methods, read or write fields, etc.), but weak pointers do not participate to shared pointer reference counting. Object is being deleted when the last ‘shared’ SmartPtr pointer to it is being destroyed. So, make sure that this doesn’t happen when no other shared SmartPtr pointers to object exist, e. g. during object construction or destruction. Use System::Object::ThisProtector sentry objects (in C++ code) or CppCTORSelfReference or CppSelfReference attribute (in C# code being translated) to fix this issue. Similarily, make sure to break loop references by using System::WeakPtr pointer class or System::SmartPtrMode::Weak pointer mode (in C++ code) or CppWeakPtr attribute (in C# code being translated). If two or more objects reference each other using ‘shared’ pointers, they will never be deleted. If pointer type (weak or shared) should be switched in runtime, use System::SmartPtr::set_Mode() method or System::DynamicWeakPtr class. SmartPtr class doesn’t contain any virtual methods. You should only inherit it if you’re creating a memory management strategy of your own. This type is a pointer to manage other object’s deletion. It should be allocated on stack and passed to functions either by value or by const reference.

template<class T>class SmartPtr
ParameterDescription
TType of the pointed object. Must be either System::Object or subclass of it.

Methods

MethodDescription
begin()Accessor for begin() method of an underling collection. Only compiles if SmartPtr_ is specialization type with begin() method.
begin() constAccessor for begin() method of an underling collection. Only compiles if SmartPtr_ is specialization type with begin() method.
Cast() constCasts pointer to its type itself.
Cast() constCasts pointer to base type using static_cast.
Cast() constCasts pointer to derived type dynamic_cast.
Cast() constCasts pointer to derived type dynamic_cast.
cbegin() constAccessor for cbegin() method of an underling collection. Only compiles if SmartPtr_ is specialization type with cbegin() method.
cend() constAccessor for cend() method of an underling collection. Only compiles if SmartPtr_ is specialization type with cend() method.
const_pointer_cast() constCasts pointer to different type using const_cast on pointed object.
dynamic_pointer_cast() constCasts pointer to different type using dynamic_cast on pointed object.
end()Accessor for end() method of an underling collection. Only compiles if SmartPtr_ is specialization type with end() method.
end() constAccessor for end() method of an underling collection. Only compiles if SmartPtr_ is specialization type with end() method.
get() constGets pointed object.
get_Mode() constGets pointer mode.
get_shared() constGets pointed object, but asserts that pointer is in shared mode.
get_shared_count() constGets number of shared pointers existing to referenced object, including current one. Asserts current pointer being in shared mode.
GetHashCode() constCalls GetHashCode() on pointed object.
GetObjectNotNull() constGets currently referenced object (if any) or throws.
GetObjectOrNull() constGets pointed object (if any) or nullptr. Same as get().
GetObjectOwner() constGets referenced object.
GetPointer() constGets pointed object (if any) or nullptr. Same as get().
Is(const System::TypeInfo&) constChecks if pointed object is of specific type or its child type. Follows C# ‘is’ semantics.
IsAliasingPtr() constChecks if pointer is pointed to another object than owned (created by an aliasing constructor).
IsShared() constChecks if pointer is in shared mode.
IsWeak() constChecks if pointer is in weak mode.
explicit operator bool() constChecks if pointer is not null.
operator!() constChecks if pointer is null.
operator*() constGets reference to pointed object. Asserts that pointer is not null.
operator->() constAllows to access members of referenced object.
operator<(Y *) constProvides less-compare semantics for SmartPtr class.
operator<(SmartPtr<Y> const&) constProvides less-compare semantics for SmartPtr class.
operator=(SmartPtr_&&)Move-assigns SmartPtr object. x becomes unusable.
operator=(const SmartPtr_&)Copy-assigns SmartPtr object.
operator=(const SmartPtr<Q>&)Copy-assigns SmartPtr object. Does required type conversions.
operator=(Pointee_ *)Assigns raw pointer to SmartPtr object.
operator=(std::nullptr_t)Sets pointer value to nullptr.
operator==(std::nullptr_t) constChecks if pointer points to nullptr.
operator[](IdxType) constAccessor for array elements. Only compiles if SmartPtr_ is specialization of System::Array.
RemoveAliasing() constRemoves aliasing (created by an aliasing constructor) from pointer, makes sure it manages (if shared) or tracks (if weak) the same object it points to.
reset(Pointee_ *)Sets pointed object.
reset()Makes pointer pointing to nullptr.
set_Mode(SmartPtrMode)Sets pointer mode. May alter referenced object’s reference counts.
SetContainedTemplateWeakPtr(uint32_t) constCalls SetTemplateWeakPtr() method on pointed object (if any).
SmartPtr(SmartPtrMode)Creates SmartPtr object of required mode.
SmartPtr(std::nullptr_t, SmartPtrMode)Creates null-pointer SmartPtr object of required mode.
SmartPtr(Pointee_ *, SmartPtrMode)Creates SmartPtr pointing to specified object, or converts raw pointer to SmartPtr.
SmartPtr(const SmartPtr_&, SmartPtrMode)Copy constructs SmartPtr object. Both pointers point to the same object afterwards.
SmartPtr(const SmartPtr<Q>&, SmartPtrMode)Copy constructs SmartPtr object. Both pointers point to the same object afterwards. Performs type conversion if allowed.
SmartPtr(SmartPtr_&&, SmartPtrMode)Move constructs SmartPtr object. Effectively, swaps two pointers, if they are both of same mode. x may be unusable after call.
explicit SmartPtr(const SmartPtr<Array<Y>>&, SmartPtrMode)Converts type of referenced array by creating a new array of different type. Useful if in C# there is an array type cast which is unsupported in C++.
explicit SmartPtr(const Y&)Initializes empty array. Used to translate some C# code constructs.
SmartPtr(const SmartPtr<P>&, Pointee_ *, SmartPtrMode)Constructs a SmartPtr which shares ownership information with the initial value of ptr, but holds an unrelated and unmanaged pointer p.
static_pointer_cast() constCasts pointer to different type using static_cast on pointed object.
ToObjectPtr() constConverts any pointer type to pointer to Object. Doesn’t require Pointee_ type to be complete.
static Type()Shortcut to get System::TypeInfo object for the Pointee_ type.
~SmartPtr()Destroys SmartPtr object. If required, decreases pointed object’s reference counter and deletes object.

Typedefs

TypedefDescription
Pointee_Pointed type.
SmartPtr_Specialized smart pointer type.
ArrayTypeSame as Pointee_, if it is a specialization of System::Array, and void otherwise.
ValueTypeStorage type of pointed array. Only meaningful if T is a specialization of System::Array.

See Also

System::ScopedCulture class System::SmartPtrInfo class