就业培训     下载中心     Wiki     联络 登录   注册

---

maxon::AutoMem is an alias for maxon::UniqueRef handling raw memory maxon::RawMem . See also Memory Allocation .

// data is filled for ( maxon::Int i = 0; i < count; ++i) data[i]._data = i;

// when the scope is left, AutoMem will delete the allocated memory }

StrongRef, StrongCOWRef and WeakRef

One or many maxon::StrongRef objects can reference a given object in memory. When all strong references to that object are destroyed, the object will be deleted.

// allocate object SimpleElement* const obj = NewObj (SimpleElement) iferr_return ; // set data obj->_data = 123; MAXON_SCOPE { // strong reference takes ownership const maxon::StrongRef<SimpleElement> ref(obj);

// print data DiagnosticOutput ( "Data: @" , ref->_data);

// when the scope is left, the StrongRef is destroyed // and with it the referenced object }

// now "obj" has been freed

// This example defines an alias for a StrongRef managing a SimpleElement. // This alias can be used to create a new instance of that SimpleElement that // is owned by a StrongRef. A copy of the original StrongRef is then created. // The copy is pointing to the same data as the original.

// defining an alias using SimpleRef = maxon::StrongRef<SimpleElement> ; MAXON_SCOPE { // allocate the object const SimpleRef original = SimpleRef::Create() iferr_return ; original->_data = 123; MAXON_SCOPE { // create a copy of the StrongRef const SimpleRef copy = original; // edit original data original->_data = 456; // "original" and "copy" are pointing to the same data DiagnosticOutput ( "@ : @" , original->_data, copy->_data);

// when the scope is left, SimpleRef "copy" is destroyed }

// when the scope is left, SimpleRef "original" is destroyed // and the allocated object with it }

A maxon::StrongRef can also manage raw memory:

// data is filled for ( maxon::Int i = 0; i < count; ++i) data[i]._data = i;

// when the scope is left, the allocated memory is deleted }

A maxon::StrongCOWRef is the same as maxon::StrongRef but it supports copy-on-write techniques. As long as no reference is trying to modify the referenced object, all references point to the same object. When a reference wants to modify the object, the object is copied and the reference used for modification has ownership of that new object.

// defining an alias using SimpleCOWRef = maxon::StrongCOWRef<SimpleElement> ; MAXON_SCOPE { // allocates the object SimpleElement* const data = NewObj (SimpleElement) iferr_return ; // set data data->_data = 100;

// StrongCOWRef takes ownership const SimpleCOWRef original(data); MAXON_SCOPE { // create a copy of the StrongCOWRef SimpleCOWRef copy = original;

// edit original data data->_data = 200;

// "original" and "copy" are pointing to the same data DiagnosticOutput ( "@ : @" , original->_data, copy->_data);

// make copy writeable; a new instance will be allocated, owned by "copy" SimpleElement& copyData = copy.MakeWritable() iferr_return ; copyData._data = 300;

// original and copy will now store different data DiagnosticOutput ( "@ : @" , original->_data, copy->_data);

// when the scope is left, StrongCOWRef "copy" is destroyed }

// when the scope is left, StrongCOWRef "original" is destroyed // and the allocated object with it }

A maxon::WeakRef points to an object owned by a maxon::StrongRef . When there are no more strong references, the object is deleted and the maxon::WeakRef returns a null reference.

// define alias using SimpleRef = maxon::StrongRef<SimpleElement> ;

// allocate an element SimpleElement* const element = NewObj (SimpleElement) iferr_return ; element->_data = 123;

// prepare WeakRef maxon::WeakRef<SimpleRef> weakRef; MAXON_SCOPE { // StrongRef takes ownership const SimpleRef strongRef(element);

// set WeakRef weakRef = strongRef;

// WeakRef is valid if (weakRef) { // use WeakRef to access data const SimpleRef data = weakRef; DiagnosticOutput ( "Data: @" , data->_data); }

// when the scope is left, SimpleRef gets destroyed // and the allocated element will be freed }

// now WeakRef points to nothing if (!weakRef) DiagnosticOutput ( "WeakRef invalid" );

Classes

Instances of custom classes can be managed with maxon::BaseRef based reference types. If it is needed to modify the reference-counting behaviour one can implement the following functions in the custom class:

• AddReference() : Is called when a reference to the object is added.
• RemoveReference() : Is called when a reference to the object is removed.
• CreateStrongReference() : Is called when a strong reference is added.
• AddWeakReference() : Is called when a weak reference to the object is added.
• InitialReference() : Sets the initial reference to a newly allocated object.

This is typically used for:

• debugging reference handling
• reference counting with alien memory management
• synchronization of a reference with a background object

//---------------------------------------------------------------------------------------- // A simple, reference counted object. //---------------------------------------------------------------------------------------- class ReferencedElement { public : //---------------------------------------------------------------------------------------- // Constructor. //---------------------------------------------------------------------------------------- MAXON_IMPLICIT ReferencedElement() { _data = 0; }

//---------------------------------------------------------------------------------------- // Destructor. //---------------------------------------------------------------------------------------- ~ReferencedElement() { _data = 0; }

//---------------------------------------------------------------------------------------- // Adds a reference to this instance. //---------------------------------------------------------------------------------------- void AddReference() const { DiagnosticOutput ( "Add reference" ); // increase reference count maxon::System::GetReferenceCounter ( this ). Inc (); }

//---------------------------------------------------------------------------------------- // Removes a reference pointing to this instance. // The object will be deleted if this was the last reference. //---------------------------------------------------------------------------------------- void RemoveReference() const { DiagnosticOutput ( "Remove reference" ); // decrease reference count if ( maxon::System::GetReferenceCounter ( this ).Dec()) { // if the last strong reference was released, // delete the object maxon::DeleteConstPtrObj ( this ); } } maxon::Int _data; };

// This example uses the class ReferencedElement that manages its own reference counting. ReferencedElement* const element = NewObj (ReferencedElement) iferr_return ; element->_data = 123; MAXON_SCOPE { // store in StrongRef, AddReference() will be called const maxon::StrongRef<ReferencedElement> firstRef(element); MAXON_SCOPE { // store in second StrongRef, AddReference() will be called const maxon::StrongRef<ReferencedElement> secondRef = firstRef;

// when the scope is left, "secondRef" is deleted and // RemoveReference() is called } // when the scope is left, "firstRef" is deleted, // RemoveReference() is called and the element freed }

延伸阅读

• Entity Creation
• Memory Allocation