class IPersistentObject : public IExtensibleObject { public: virtual bool Load(const char *pszFileName) 0; virtual bool Save(const char *pszFileName) 0; } ;

Essential Jewellery

Note that all but one of the entry points into the FastSt ri ng DLL are virtual functions. The virtual functions of the interface class are always called indirectly via a function pointer stored in a vtbl, without requiring the client to link against their symbolic names at development time. This means that the interface methods are immune to symbolic mangling differences between compilers. The only entry point that is explicitly linked against by name is CreateFastStri ng, the global function that bootstraps the client into the world of FastStri ng. Note, however, that this function was exported using extern "C", which suppresses symbolic mangling. This implies that all C++ compilers expect the import library and DLL to export the same symbol. The net result of using this technique is that one can safely expose a class from a DLL using one C++ environment and access the class from any other C++ development environment. This capability is critical for building a vendorneutral substrate for reusable components. set pUnk2 to point to first object if (pUnk2) pUnk2->Release(); if (pUnk2 = pUnkl) pUnk2->AddRef(); Software Distribution and C++ To understand the problems related to using C++ as a component substrate, it helps to examine how C++ libraries were distributed in the late 1980s. Consider a library vendor who has developed an algorithm that can perform substring searches on 0(1) time (i.e., the search time will be constant and notextern "C" const lID IID_IUnknown; interface IUnknown { virtual HRESULT STDMETHODCALLTYPE Querylnterface(REFIID riid, void **ppv) = 0; virtual ULONG STDMETHODCALLTYPE AddRef(void) = 0; virtual ULONG STDMETHODCALLTYPE Release(void) = 0; } ; Recent issues of C++ Report are available at http://www.develop.comJdbox/cxx/lnterfacePtr.htm and http://www.develop.comJdbox/cxx/SmartPtr.htm.

Essential Education Student Login Essential Education Student Login

void GetObject([out] IUnknown **ppUnk); and that there is another global function that performs some useful work on an object: The first parameter (ri i d) is the physical name of the interface being requested. The second parameter (ppv) points to an interface pointer variable that on successful completion will contain the requested interface pointer. In response to a Querylnterface request, if the object does not support the requested interface type, it must return E_NOINTERFACE after setting *ppv to null. If the object does support the requested interface, it must overwrite *ppv with a pointer of the requested type and return the HRESULT S_OK. Because ppv is an [out] parameter, the implementation of Querylnterface must AddRef the resultant pointer prior to returning control to the caller (see guideline A2 from earlier in this chapter). This AddRef call must be matched by a Re1ease call from the client. The following shows runtime type discovery using C++'s dynami c_cast operator based on the Dog/Cat type hierarchy described earlier in this chapter: class IFastString { public: II faux version 1.0 virtual void Delete(void) = 0; virtual int Length(void) = 0; virtual int Find(const char *psz) = 0; II faux version 2.0 virtual int FindN(const char *psz, int The Dynami c_Cast method was used for runtime type discovery and was analogous to C++'s dynami c_cast operator. The Dupl i catePoi nter method was used to notify the object that an interface pointer had been duplicated. The DestroyPoi nter method was used to notify the object that an interface pointer had been destroyed and any resources it held could be released. The following is the C++ definition of IUnknown: if (riid == IID_IUnknown) *ppv = static_cast (this); As was shown in the case of FastSt ri ng and IExtensi b1eObj ect from the previous chapter, this code will not compile because the cast is ambiguous and could be satisfied by using more than one base class. Instead, the implementation needs to select a more precise type to use in the cast:When the client calls the function with no second parameter pfs = CallCreateFastString("Hi Bob!"); n = pfs->Find("ob"); the original FastStri ng DLL is loaded and the search is performed from left to right. If the client indicates that the string is in a spoken language that parses from right to left pfs = CallCreateFastString("Hi Bob!", false); n = pfs->Find("ob"); the alternative version of the DLL (FastStri ngRL. DLL) is loaded and the search will be performed starting at the rightmost position of the string. The key observation is that callers of Call CreateFastStri ng do not care which DLL is used to implement the object's methods. All that matters is that a pointer to an IFastStri ng-compatible vptr is returned by the function and that the vptr provides useful and semantically correct functionality. This form of runtime polymorphism is extremely useful for building a dynamically composed system from binary components.

Essential Mod | Home - The Mod You Need For Minecraft Java Essential Mod | Home - The Mod You Need For Minecraft Java

faststring.h /////////////////////////////////// #include "ifaststring.h" class FastString : public IFastString { const int m_cch; // count of characters char ''''m_psz; public: FastString(const char *psz); ~FastString(void); ADDISON-WESLEY An imprint of Addison Wesley Longman, Inc. Reading, Massachusetts . Harlow, England · Menlo Park, California Berkeley, California · Don Mills, Ontario · Sydney Bonn . Amsterdam . Tokyo . Mexico City Interfaces and IDL Method definitions in IDL are simply annotated C function prototypes. Interface definitions in IDL require an extension to C, as C has no intrinsic support for the concept. The IDL interface keyword is used to begin the definition of an interface. The interface definition has four components: the interface name, the base interface name, the interface body, and the interface attributes. The interface body is simply a collection of method definitions and supporting type definition statements: if we reach this point, *ppv is non-null and must be AddRef'ed (guideline A2) reinterpret_cast (*ppv)->AddRef(); return S_OK; lCat cat; try { cat = (ICat)obj; II VM calls Querylnterface cat.lgnoreMaster(); } catch (Throwable ex) { II ignore method or QI failures } }Type Coercion and IUnknown The previous chapter described the motivations for needing runtime type discovery in a dynamically composed system. The C++ language provides a reasonable mechanism for dynamic type discovery through its dynami c_cast operator. Although this language feature has a proprietary implementation for each compiler, the previous chapter was able to leverage the concept by adding an explicit method to each interface that performs the semantic equivalent of dynami c_cast. COM's IUnknown interface also has such a method and it is called Querylnterface. The following is the IDL description of Que rylnte rface: HRESULT Querylnterface([in] REFIID riid, [out] void **ppv); Because the object derives from the type used in the cast, the compiled versions of the cast statements simply add a fixed offset to the object's thi s pointer to find the beginning of the base class's layout. Note that when asked for the common base interface IExtensi bl eObject, the implementation statically casts itself to IFastStri ng. This is because the intuitive version of the statement Assuming the client usage just shown, the required semantics and mechanism for type discovery are in place, but each implementation class must implement this functionality by hand: faststring.cpp (part of DLL) IIIIIIIIIII IFastString *CreateFastString (canst char *psz) { return new FastString(psz);