faststring.cpp (part of DLL) IIIIIIIIIII IFastString *CreateFastString (canst char *psz) { return new FastString(psz); The unexpected behavior stems from the fact that the destructor for the interface class is not virtual. This means that the call to the delete operator will not dynamically find the mDst derived destructor and recursively destroy the object from the outermost type to the base type. Because the FastStri ng destructor is never called, the preceding example leaks the buffer memory used to hold the string "Deface me". One obvious solution to this problem is to make the destructor virtual in the interface class. Unfortunately, this pollutes the compiler independence of A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

The Essentials of COM | Pluralsight The Essentials of COM | Pluralsight

int m_cch; II count of characters char ";"'m_psz; public: FastString(const char *psz); ~FastString(void); The term execution context is used by the COM specification to describe what has since been renamed an apartment. An apartment is neither a thread nor a process; however, it shares common attributes with both. Apartments are fully described in Chapter 5. Note that the only modification is the addition of a private data member. To initialize this member properly, the constructor would need to be modified as follows:

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. II calculator.idl [object, uuid(BDA4A270-AIBA-lldO-BC2C-OOBOC73925BA)] interface ICalculator : IUnknown { import "unknwn.idl"; II bring in def. of IUnknown HRESULT Clear(void); HRESULT Add([in] long n); HRESULT Sum([out, retval] long *pn); } 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. 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:

Essentials for Men FW23 Collection | SSENSE UK Fear Of God Essentials for Men FW23 Collection | SSENSE UK

II ifaststring.h IIIIIIIIIII class IFastString { public: virtual int Length(void) canst = 0; virtual int Find(const char *psz) canst the type hierarchy for the FastStri ng class just shown. Because the implementation class derives from each interface that it exposes, FastStri ng's implementation of Dynami c_Cast can simply use explicit static casts to limit the scope of the thi s pointer based on the subtype requested by the client:

against the precise signature of the interface class, and any changes to the interface definition require that the client recompile to take advantage of the change. Worse yet, changing the interface definition completely violates the encapsulation of the object (its public interface has changed) and would break all existing clients. Even the most innocuous change, such as changing the semantics of a method while holding its signature constant, renders the installed client base useless. This implies that interfaces are immutable binary and semantic contracts that must never change. This immutability is required to have a stable, predictable runtime environment. Despite the immutability of interfaces, it is often necessary to expose additional functionality that may not have been anticipated when an interface was initially designed. It is tempting to take advantage of the knowledge of vtbllayout and simply append new methods to the end of an existing interface definition. Consider the initial version of IFastStri ng: 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); };

ESSENTIALS - New Releases | Fear of God

long arg2 = 20, arg3 = 30; p->Methodl(lO, &arg2, &arg3); the object cannot count on receiving the actual value of20 via parg2. If the object is running in the same execution context as the caller and both parties are implemented in C++, then ,o:parg2 will in fact contain the value of 20 on method entry. However, if the object is accessed from a different execution context or one party is implemented in a language that optimizes away the initialization of the out-only parameter, then the caller's initialization will be lost. Optimizing Querylnterface The de facto implementation of Querylnterface shown earlier in this chapter is fairly straightforward and easily maintained by anyone who has a basic understanding of COM and C++. However, many production environments and frameworks favor a data-driven implementation to achieve greater extensibility and better performance due to code size reduction. Such implementations assume that each COM-compliant class provides a table that maps each supported lID onto some aspect of the object using fixed offsets or some other technique. In essence, the implementation of Querylnterface shown earlier in this chapter builds a table based on the compiled machine code for each sequential if statement and the fixed offsets are calculated using the stati c_cast operator (stat; c_cast simply adds the offset of the base class to find the typecompatible vptr). To implement a table-driven Querylnterface, one first needs to define what the table will contain. At a minimum, each table entry will need to contain a pointer to an lID and some additional state that allows the implementation to find the object's vptr for the requested inte The exact pronunciation of GUID is a subject of heated debate among COM developers. Although the COM Specification states that GUID rhymes with fluid, not squid, the author believes that the COM Specification is simply incorrect, citing the word languid as setting the precedent. i nt f(voi d) { IFastStri ng ''rpfs = CreateFastStri ng("Deface me"); int n = pfs->Find("ace me delete pfs; return n; llshaped much of the mindset of the C++ community at large. One of the principal goals for C++ was to allow programmers to build user-defined types (UDTs) that could be reused outside their original implementation context. This principle underpins the idea of class libraries or frameworks as we know them today. Since the introduction of C++, a marketplace for C++ class libraries emerged, albeit rather slowly. One reason that this marketplace has not grown as fast as one might expect is related to the if (riid == IID_IUnknown) *ppv = static_cast (this); Either of these two code fragments is legal for the implementation of PugCat. The former version is preferred, as many compilers produce slightly more efficient code when the leftmost base class is used. 4 IFastString* CreateFastString(const char *psz) { IFastString *pfsResult = new FastString(psz); if (pfsResul t) pfsResult->DuplicatePointer(); return pfsResult; } PugCat:: Bark PugCat: :Snore PugCat:: Queryl nterface PugCat::AddRef PugCat::Release PugCat: :Eat PugCat:: IgnoreMaster

Essential Education Student Login Essential Education Student Login

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 not class IPersistentObject { public: virtual void *Dynamic_Cast(const char *pszType) =0; virtual void Delete(void) = 0; virtual bool Load(const char *pszFileName) 0; virtual bool Save(const char *pszFileName) 0; } ; Interface and Implementation 95 Class Objects 97 Activation 100 Using the SCM 103 Classes and Servers 107 Generalizations 115 Optimizations 118 Interface and Implementation Again Monikers and Composition 131 Monikers and Persistence 134 Server Lifetime 138 Classes and IDL 141 Class Emulation 145 Competent Categories 147 Where Are We? 153 With these methods in place, all users of IExtensi bl eObject must now adhere to the following two mandates: (1) When an interface pointer is duplicated, a call to Dupl i catePoi nter is required. (2) When an interface pointer is no longer in use, a call to DestroyPoi nter is required. These methods could be implemented in each object simply by noting the number of live pointers and destroying the object when no outstanding pointers remain: severity>_ For example, the HRESULT STG_S_CONVERTED indicates that the facility code is FACILITY_STORAGE (which means that this result is related to Structured Storage or Persistence); the severity bit is SEVERITY_SUCCESS (which means that the call was able to perform the operation successfully) and that, in this case, the operation converted the underlying file to support structured storage. HRESULTs that are universal and are not tied to a particular technology use FACILITY_NULL and their symbolic name does not contain the facility code prefix. Some common FACILITY_NULL HRESULTs areobject, uuid(DF12E156-A29A-lldO-8C2D-0080C73925BA)] interface ICatDog : ICat, IDog { II illegal, multiple bases HRESULT Meowbark(void); } 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 object, uuid(DF12E152-A29A-l1dO-8C2D-0080C73925BA)] interface ICat : IAnimal { HRESULT 19noreHumans(void); }