static boost::shared_ptr<std::vector<boost::shared_ptr<CategoryInfo> > > GetCategories(int min)
{
    return DBManager<CategoryInfo>(
                "Server=.;Database=Northwind;Integrated Security=SSPI"
            ,
                "SELECT"
                "    p.CategoryID,"
                "    c.CategoryName,"
                "    Count(p.CategoryID) Count"
                "FROM Products p"
                "    INNER JOIN Categories c ON c.CategoryID = p.CategoryID"
                "GROUP BY p.CategoryID, c.CategoryName"
                "HAVING Count(p.CategoryID) >= @min"
                "ORDER BY c.CategoryName"
            ,    
                DBFields<CategoryInfo>()
                    (&CategoryInfo::CategoryID,        "CategoryID")
                    (&CategoryInfo::CategoryName,    "CategoryName")
                    (&CategoryInfo::Count,            "Count")
            ,
                DBParams()
                    ("@min", min)
        );
}

struct Variant
{
    operator int()const
    {
        return 123456;
    }
    operator std::string()const
    {
        return "Hello";
    }
};

template<class T>
struct SetFieldBase
{
    virtual void Set(T&, const Variant&)const=0;
};
template<class T, class U>
struct SetField
    :SetFieldBase<T>
{
    SetField(U T::* ptr)
        :ptr_(ptr)
    {}
    void Set(T& val, const Variant& var)const
    {
        val.*ptr_=var;
    }
private:
    U T::* ptr_;
};
template<class T, class U>
SetField<T, U> MakeSetField(U T::* ptr)
{
    return ptr;
}
struct CategoryInfo
{
    int            CategoryID;
    std::string CategoryName;
    int            Count;
};
int main()
{
    CategoryInfo info;
    const SetFieldBase<CategoryInfo>& setField1=MakeSetField(&CategoryInfo::CategoryID);
    const SetFieldBase<CategoryInfo>& setField2=MakeSetField(&CategoryInfo::CategoryName);
    const SetFieldBase<CategoryInfo>& setField3=MakeSetField(&CategoryInfo::Count);
    setField1.Set(info, Variant());
    setField2.Set(info, Variant());
    setField3.Set(info, Variant());
    return 0;
}

AVK>Activator.CreateInstance(Type.GetType("ClassName, assembly_name"));
AVK>

    Ref<I_Sensor> sensor=CreateObject<I_Sensor>(sensorClassName);

    I_Sensor sensor=(I_Sensor)Activator.CreateInstance(Type.GetType("ClassName, assembly_name"));

VD> Я плякаль...

struct DocElement
    :BaseVisitable<>
{
    DEFINE_VISITABLE()
}
struct Paragraph
    :DocElement
{
    DEFINE_VISITABLE()
}
struct MyVisitor
    :BaseVisitor
    ,Visitor<DocElement>
    ,Visitor<Paragraph>
{
    void Visit(DocElement&)
    {
    }
    void Visit(Paragraph&)
    {
    }
}
int main()
{
    MyVisitor visitor;
    Paragraph par;
    DocElement* d=&par;
    d->Accept(visitor);
}

WH>Первый да второй нет(вернее догадаться по контексту могу, а повторить...даже на С#... ).

public ArrayList ExecuteList(Type type, string commandText, params IDbDataParameter[] commandParameters)
{
    // ...

    object o = Activator.CreateInstance(type);

    // ...

    FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
    foreach (FieldInfo fld in fields)
    {
        string name = fld.Name;
        object dbValue = // читаем данные из рекордсета по name
        fld.SetValue(o, dbValue);
    }

    // ..
}