ATL / WTL / STL

// SecurityFunctoid.h : Declaration of the CSecurityFunctoid

#ifndef __SECURITYFUNCTOID_H_
#define __SECURITYFUNCTOID_H_

#include "resource.h"       // main symbols
#import "C:\Program Files\Microsoft BizTalk Server\XML Tools\CannedFunctoids.dll" raw_interfaces_only, raw_native_types,\
                           no_namespace, named_guids 

/////////////////////////////////////////////////////////////////////////////
// CSecurityFunctoid
class ATL_NO_VTABLE CSecurityFunctoid : 
	public CComObjectRootEx<CComSingleThreadModel>,
	public CComCoClass<CSecurityFunctoid, &CLSID_SecurityFunctoid>,
	public IDispatchImpl<ISecurityFunctoid, &IID_ISecurityFunctoid, &LIBID_SECURITYCALCULATIONLib>,
	public IDispatchImpl<IFunctoid, &IID_IFunctoid, &LIBID_BTSCannedFunctoidsLib>
{
public:
	CSecurityFunctoid()
	{
	}

DECLARE_REGISTRY_RESOURCEID(IDR_SECURITYFUNCTOID)

DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(CSecurityFunctoid)
	COM_INTERFACE_ENTRY(ISecurityFunctoid)
//DEL 	COM_INTERFACE_ENTRY(IDispatch)
	COM_INTERFACE_ENTRY2(IDispatch, ISecurityFunctoid)
	COM_INTERFACE_ENTRY(IFunctoid)
END_COM_MAP()

// ISecurityFunctoid
public:
// IFunctoid
	STDMETHOD(get_Version)(LONG * pVersion)
	{
		if (pVersion == NULL)
			return E_POINTER;
			
		return E_NOTIMPL;
	}
	STDMETHOD(get_FunctionsCount)(LONG * plCount)
	{
		if (plCount == NULL)
			return E_POINTER;
			
		return E_NOTIMPL;
	}
	STDMETHOD(GetFunctionDescripter)(LONG lIndex, FUNC_CATEGORY * pFuncCategory,
                                         SCRIPT_CATEGORY * pScriptCategory,
                                         FUNC_TYPE * pFuncType,
                                         BSTR * pbstrName,
                                         BSTR * pbstrTooltip,
                                         LONG * plBitmapID,
                                         LONG * plParmCount,
                                         LONG * pFuncId)
	{
		if (pFuncCategory == NULL)
			return E_POINTER;
			
		if (pScriptCategory == NULL)
			return E_POINTER;
			
		if (pFuncType == NULL)
			return E_POINTER;
			
		if (pbstrName == NULL)
			return E_POINTER;
			
		if (pbstrTooltip == NULL)
			return E_POINTER;
			
		if (plBitmapID == NULL)
			return E_POINTER;
			
		if (plParmCount == NULL)
			return E_POINTER;
			
		if (pFuncId == NULL)
			return E_POINTER;
			
		return E_NOTIMPL;
	}
	STDMETHOD(GetFunctionParameter)(LONG funcId,
                                        LONG lParameter,
                                        LONG * plConnectionType)
	{
		if (plConnectionType == NULL)
			return E_POINTER;
			
		return E_NOTIMPL;
	}
	STDMETHOD(GetScriptBuffer)(LONG cFuncId,
                                   LONG lInputParameters,
                                   BSTR * pbstrScriptBuffer)
	{
		if (pbstrScriptBuffer == NULL)
			return E_POINTER;
			
		return E_NOTIMPL;
	}
};

#endif //__SECURITYFUNCTOID_H_

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct MyClass
{
    MyClass(int f, int s)
        : first(f), second(s) {}
    int first;
    int second;
};

ostream& operator<<(ostream& stream, const MyClass& m)
{
	return stream << "First: " << m.first << ", Second: " << m.second;
}

typedef pair<int, int> MyClassPair;

ostream& operator<<(ostream& stream, const MyClassPair& m)
{
	return stream << "First: " << m.first << ", Second: " << m.second;
}

int main(int argc, char* argv[])
{
    // Use ostream_iterator with MyClass (works)
    {
        vector<MyClass> coll;

        for (int i = 1; i <= 10; i++)
        {
            MyClass m(i, i);
            coll.push_back(m);
        }
    
        copy(coll.begin(), coll.end(),   
             ostream_iterator<MyClass>(cout,"\n"));
    }
    
    // Use ostream_iterator with MyClassPair (does not compile)
    {
        vector<MyClassPair> coll;

        for (int i = 1; i <= 10; i++)
        {
            MyClassPair m(i, i);
            coll.push_back(m);
        }
    
        copy(coll.begin(), coll.end(),           
             ostream_iterator<MyClassPair>(cout,"\n"));
    }

    return 0;
}

<br />
struct A<br />
{<br />
     BSTR bstrA;<br />
     BSTR bstrB;<br />
};<br />
<br />
struct B<br />
{<br />
     int countA;<br />
     [size_is(countA) A *a;<br />
};<br />
<br />
__interface IService<br />
{<br />
     HRESULT AllocateSomeBs([out] int *countB, [out, retval, size_is(, countB)] B **bs);<br />
};<br />