Essential COM

Product Information

ppv = (IPug*)this; as the stati c_cast version will cause a compile-time error if the attempted cast does not correspond to an actual base class. Note that in the Querylnterface implementation shown here, when a request is made for an interface that is supported by more than one base interface (e.g., IUnknown, IAni rna 1), the type-cast must explicitly select a more precise base class. For the class PugCat, the following innocent-looking code will not compile: Sub TryToSnoreAndlgnore(obj as Object) On Error Resume Next ' ignore errors Di m pug as lPug Set pug = obj • VM calls QueryInterface If Not (pug is Nothing) Then pug.Snore End if Dim cat as lCat Set cat = obj • VM calls QueryInterface If Not (cat is Nothing) Then cat.lgnoreMaster End if End Sub A client that wants to treat an object as a CatlDog simply uses Que rylnte rface to bind both types of pointers to the object. If one of the Querylnterface calls fails, then the object in question is not a Cat/Dog and the client can cope with this as it chooses. Because implementations can expose multiple interfaces, there is little loss of semantic or type information in prohibiting interfaces from having more than one base inheritance. COM supports a notation technique that expresses which interfaces are available from an object. This technique adheres to the COM philosophy of separation of interface from implementation and does not betray any implementation details of the object other than the list of interfaces it exposes. COM as a Better C++ temp7ate c7ass 7ist_t : virtua7 protected CPrivateA770c { 7ist m_7ist; mutab7e ~nd m_wnd; virtua7 -7ist_t(void); protected: exp7icit 7ist_t(int nE7ems, ... ); in7ine operator unsigned int *(void) canst { return reinterpret_cast (this); } temp7ate void c7ear(X& rx) const throw(Ex); }; public void TryToSnoreAndlgnore(Object obj) { lPug pug; try { pug = (IPug)obj; II VM calls Querylnterface pug.Snore(); } catch (Throwable ex) { II ignore method or QI failures }

Essential Education Student Login Essential Education Student Login

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: class PugCat : public lPug, public lCat { LONG m_cRef; protected: virtual -PugCat(void); public: PugCat(void); II lUnknown methods STDMETHODIMP Query1nterface(REFI1D riid, void **ppv); STDMETHODlMP_(ULONG) AddRef(void); STDMETHODlMP_(ULONG) Release(void); II lAnimal methods STDMETHODlMP Eat(void); II 1Dog methods STDMETHOD1MP Bark(void);Simplicity Leads to Malleability mal·le·a·ble (mal'e-e-bel) adjective 1. Capable of being shaped or formed, as by hammering or pressure: a malleable metal. 2. Easily controlled or influenced; tractable. 3. Able to adjust to changing circumstances; adaptable: the malleable mind of the pragmatist. 3 return static_cast (this); is ambiguous because IFastStri ng and IPersi stentObject both derive from IExtensibleObject. If IExtensibleObject was a virtual base class of both IFastString and IPers;stentObject, then this cast would not be ambiguous and the statement would compile. However, introducing virtual base classes adds needless runtime complexity to the resultant object and also introduces compiler dependences. This is because virtual bases are yet another C++ language feature that has several proprietary implementations. Smart pointers seem very attractive at first glance but can be very dangerous as they lull the programmer into a dream-like state in which nothing COM-related seems to matter. Smart pointers do solve real problems, especially in the face of exceptions; however, when used carelessly, smart pointers can introduce as many defects as they prevent. For example, many smart pointers allow any interface method to be accessed via the smart pointer's operator ->. Unfortunately, this allows clients to call Release via the arrow operator without notifying the underlying smart pointer that its automatic Release call in its destructor is now redundant and not allowed. adjustor thunks and place the leftmost base at the top of the object layout. The Microsoft C++ compiler fits this description. void DestroyPointer(void) { II destroy object when last pointer destroyed if (--m_cPtrs == 0) delete this; }

Home - Edsential

faststring.cpp /////////////////////////////////// #include #include "faststring.h" IFastString* (reateFastString (const char *psz) { return new FastString(psz); } Given this cached length, the Length method now becomes trivial: int FastString::Length(void) canst { return m_cch; II return cached length }

When programming against the physical name of an interface in C or C++, the lID of a given interface is simply the interface's logical name prepended with the IID_ suffix. For example, the interface ICal cul ator would have an lID that could be manipulated programmatically using the IDL-generated constant IID_ICalculator. C++ namespaces can be used to deal with symbolic name collisions between interfaces. Because few C++ compilers can support 128-bit integers, COM defines a C structure to represent the 128-bit value of a GUID and provides aliases for the types lID and CLSID using typedefs: