Handle has type cast operator to const reference to handle to the base types, which allows it to be passed by reference in functions accepting reference to handle to base class, without copying.īy default, the type cast operator is provided also for non-const reference. The same object can be referenced by handles of different types (as soon as they are compatible with the object type). It is safe to create a new handle from plain C pointer to the object already pointed by another handle. All handles to the same object share the common counter object is deleted when the last handle pointing on it is destroyed.
The reference counter is part of the base class ( Standard_Transient), thus creation of a handle does not require allocation of additional memory for the counter. And what advantages does downcasting have Could you describe upcast and downcast in more detail include using namespace std class. This class is similar to boost::intrusive_ptr. More.ĭownCast (const T2 *thePtr, typename opencascade::std::enable_if:: value, void * >:: type=0) More.ĭownCast (const handle &theObject, typename opencascade::std::enable_if:: value, void * >:: type=0)įor compatibility, define down casting operator from non-base type, as deprecated. More.ĭown casting operator from pointer to base type. Static opencascade::std::enable_if:: value, handle >:: typeĭown casting operator from handle to base type.
#DOWNCAST TO C CODE#
NB: this cast can be dangerous, but required for legacy code see #26377. From: John Love-Jensen To: , Upcast to non-const reference to base type. In C++, you can convert a pointer to a base class object into a pointer to a derived class object (i.e., downcast the pointer) without an explicit type cast. dynamiccast is the preferred approach for a downcast or even better redesign to avoid needing them. Ensure any C style downcasts are replaced with at least a staticcast before refactoring further. NB: this implementation will cause ambiguity errors on calls to overloaded functions accepting handles to different types, since compatibility is checked in the cast code rather than ensured by SFINAE (possible with C++11) More. In conclusion NEVER use C style casts for downcasts. Operator Standard_Transient *handle::* () constĬonversion to bool-compatible type for use in conditional expressions. Operator!= (const handle &theHandle) constĬompare operator for possible use in std::map etc. Operator= (const handle &theHandle) const Member access operator (note non-const) More.ĭereferencing operator (note non-const) More. STL-like cast to pointer to referred object (note non-const). Operator= ( handle &theHandle) Standard_Noexcept Handle ( handle &theHandle) Standard_Noexcept More.Ĭonstructor from pointer to new object. Looking at how ugly that is, I wouldn't be surprised if I definitely had a few design problems.Intrusive smart pointer for use with Standard_Transient class and its descendants. The rootsystem type may not be the same for every point so I decided to look into alternative methods. The reason downcasting came into question was because I wanted each point to hold a reference to its root system. I wanted to extend theses classes so that I could include additional system information or additional point information. PathPoint hold one point and information about the next point as well as information about that one point. Upcasting is legal in C as the process there is to convert an object of a derived class type into an object of its base class type. PathSystem holds the first pathpoint and holds information about the entire path. This article describes a simple approach to downcasting in C downcasting merely refers to the process of casting an object of a base class type to a derived class type. The goal was to create a PathSystem, and PathPoint class. Public class PathPoint : BasePoint where TSys: PathSystem where TPoint : PathPoint
0 kommentar(er)
