\nThere are two ways of declaring COM interfaces, the hard way\nand the easy way.\n<\/P>\n
\nThe easy way is to use an IDL file and let the MIDL compiler\ngenerate your COM interface for you.\nIf you let MIDL do the work, then you also get\n\n__uuidof<\/A> support at no extra charge, which is a very nice bonus.\n<\/P>\n \nThe hard way is to do it all by hand. If you choose this route,\nyour interface will look something like this:\n<\/P>\n DECLARE_INTERFACE_(ISample2, ISample)\n{\n BEGIN_INTERFACE<\/p>\n \/\/ *** IUnknown methods ***\n STDMETHOD(QueryInterface)(THIS_ REFIID riid, void **ppv) PURE;\n STDMETHOD_(ULONG,AddRef)(THIS) PURE;\n STDMETHOD_(ULONG,Release)(THIS) PURE;<\/p>\n \/\/ ** ISample methods ***\n STDMETHOD(Method1)(THIS) PURE;\n STDMETHOD_(int, Method2)(THIS) PURE;<\/p>\n \/\/ *** ISample2 methods ***\n STDMETHOD(Method3)(THIS_ int iParameter) PURE;\n STDMETHOD_(int, Method4)(THIS_ int iParameter) PURE;<\/p>\n END_INTERFACE\n};\n<\/PRE>\n \nWhat are the rules?\n<\/P>\n \nThere is a reason for each of these rules. They have to do with\nbeing able to use the same header for both C and C++ declarations\nand with interoperability with different compilers and platforms.\n<\/P>\n \nAnd you wonder why I called it “the hard way”.\n<\/P>\n\n#undef INTERFACE\n#define INTERFACE ISample2<\/p>\n
\n
INTERFACE<\/CODE> macro to the name of the interface being\ndeclared.\nNote that you need to #undef<\/CODE> any previous value before you\n#define<\/CODE> the new one.\nDECLARE_INTERFACE<\/CODE>\nand DECLARE_INTERFACE_<\/CODE> macros\nto generate the preliminary bookkeeping for an interface.\nUse DECLARE_INTERFACE<\/CODE> for interfaces that have no base class\nand DECLARE_INTERFACE_<\/CODE> for interfaces that\nderive from some other interface. In our example, we\nderive the ISample2<\/CODE> interface from ISample<\/CODE>.\nNote<\/STRONG>: In practice, you will never find\nthe plain DECLARE_INTERFACE<\/CODE> macro because all interfaces\nderive from IUnknown if nothing else.\nSTDMETHOD<\/CODE> or STDMETHOD_<\/CODE>\nmacros to declare the\nmethods. Use STDMETHOD<\/CODE> if the return value is\nHRESULT<\/CODE> and\nSTDMETHOD_<\/CODE> if the return value is some other type.\n(THIS)<\/CODE>.\nOtherwise, you must insert THIS_<\/CODE> immediately after\nthe open-parenthesis of the parameter list.\nPURE<\/CODE>.\nBEGIN_INTERFACE<\/CODE> and\nEND_INTERFACE<\/CODE>.\n<\/UL>\n\n
INTERFACE<\/CODE> macro because its value is used\nby the THIS<\/CODE> and THIS_<\/CODE> macros later.\nDECLARE_INTERFACE*<\/CODE> macros to ensure that\nthe correct prologue is emitted for both C and C++.\nFor C, a vtable structure is declared, whereas for C++\nthe compiler handles the vtable automatically; on the other hand,\nsince C++ has inheritance, the macros need to specify the base\nclass so that upcasting will work.\nSTDMETHOD<\/CODE> and\nSTDMETHOD_<\/CODE> macros to ensure that\nthe correct calling conventions are declared for the function\nprototypes.\nFor C, the macro creates a function pointer in the vtable;\nfor C++, the macro creates a virtual function.\nTHIS<\/CODE> and THIS_<\/CODE> macros\nare used so that the C declaration\nexplicitly declares the “this” parameter which in C++ is implied.\nDifferent versions are needed depending on the number of parameters\nso that a spurious trailing comma\nis not generated in the zero-parameter case.\nPURE<\/CODE> ensures that the C++ virtual function is pure,\nbecause one of the defining characteristics of COM interfaces\nis that all methods are pure virtual.\nBEGIN_INTERFACE<\/CODE> and\nEND_INTERFACE<\/CODE> macros\nemit compiler-specific goo which the compiler vendor provides\nin order to ensure that the generated interface matches\n\nthe COM vtable layout rules<\/A>.\nDifferent compilers have historically required different goo,\nthough the need for goo is gradually disappearing over time.\n<\/UL>\n