L_as

Standard documentation for SharedObject:

 [INTERNAL] 

::

SharedObject implements a reference counting framework similar 

for efficient and.

easily-maintained memory management.

To use the class, both the SharedObject class (the public class), and the SharedObjectInternal class (the internal class) must be inherited from. It can be done in two different files and together with memory management, this approach provides a clear distinction of which methods of the class are to be considered "public", i.e. methods for public use that can be

considered to remain over time with small changes, and the internal memory.

When interfacing a software, which typically includes including some header file, this is best done only in the file where the internal class is defined, to avoid polluting the global namespace and other side effects.

The default constructor always means creating a null pointer to an internal class only. To allocate an internal class (this works only when the internal class isn't abstract), use the constructor with arguments.

The copy constructor and the assignment operator perform shallow copies only, to make a deep copy you must use the clone method explicitly. This will give a shared pointer instance.

In an inheritance hierarchy, you can cast down automatically, e.g.

(SXFunction is a child class of Function): SXFunction derived(...);
Function base = derived;

To cast up, use the shared_cast template function, which works analogously to dynamic_cast, static_cast, const_cast etc, e.g.: SXFunction derived(...); Function base = derived; SXFunction derived_from_base =

shared_cast(base);

A failed shared_cast will result in a null pointer (cf. dynamic_cast)

Joel Andersson

Extra doc: https://github.com/casadi/casadi/wiki/L_as

C++ includes: shared_object.hpp

Extra documentation

To edit, see writing tips.