ATL / WTL / STL

CComPtr<IHTMLDocument2Ptr> spHTMLDocPtr;
CComPtr<IDispatchPtr> spIDispatchPtr;

CComPtr<IHTMLDocument2> spHTMLDocPtr;
CComPtr<IDispatch> spIDispatchPtr;

CComQIPtr<IHTMLDocument2> spHTMLDocument = this->m_HTMLCtrl.GetHtmlDocument();
if(spHTMLDocument)
{
    CComQIPtr<IHTMLElement> spHTML;

    spHTMLDocument->get_body(&spHTML);

    if (spHTML)
    {
        bstr = csCodiHTML.AllocSysString();

        spHTML->put_innerHTML(bstr);

        spHTML.Release();
    }
    else
    {
        //spHTMLDocument->write(); <code>what I'm trying now...</code>
        //bstr = csCodiHTML.AllocSysString();
        //spHTMLDocument->createElement(bstr,&spHTML); <code>THIS DON'T MAKES ANYTHING...</code>
    }

// variant.cpp : Definiert den Einsprungpunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include <atlbase.h>
#include <list>

typedef std::list<VARIANT> VARIANTLIST;
VARIANTLIST varList;

int main(int argc, char* argv[])
{
    for (int n = 0; n < 100; n++)
    {
        VARIANT var;
        var.vt = VT_I2;
        var.iVal = 1;

        varList.push_back(var);
    }

    printf("size = %d \n", (int) varList.size());

    return 0;
}

typedef struct tagVARIANT  {
   VARTYPE vt;
   unsigned short wReserved1;
   unsigned short wReserved2;
   unsigned short wReserved3;
   union {
      Byte                    bVal;                 // VT_UI1.
      Short                   iVal;                 // VT_I2. <===== LOOK HERE !!!
      long                    lVal;                 // VT_I4.
      float                   fltVal;               // VT_R4.
      double                  dblVal;               // VT_R8.

      ...
      ...
      ...
   };
};

tree<int> m_tree;
m_tree.AddNode(1);
m_tree.AddNode(2);
m_tree.AddNode(3);

Not everything that can be counted counts, and not everything that counts can be counted. - Albert Einstein

template <typename T>
struct Node {
    T data;
    Node* parent; // Optional member, can make navigation easier
    std::list<Node*> children;
};
 
// Then you can write simple functions like: 
template <typename T>
Tree_AppendChild(Node<T>* node, const T& value) {
   ...
}
 
template <typename T>
Tree_InsertChild(Node<T>* node, const T& value, int pos) {
   ...
}
// etc...