Managed обертка для std::Vector

// Vector.h
#pragma once
#include <vector>
#include "stdafx.h"
#include <objbase.h>

using namespace System;
using namespace std;

#define PVOID void*
#define INVI inline virtual
#define IN   inline

namespace VC {
    /* Создание интерфейса с функциями, которые будем использовать*/
    public interface IVECTOR{
        INVI void push_back     ( PVOID var)            =0;
        INVI void pop_back      ()                      =0;
        INVI void erase         (int &index)            =0;
        INVI void inrease       (int &index, PVOID var) =0;
        INVI PVOID back         ()                      =0;
        INVI PVOID front        ()                      =0;
        INVI int size           ()                      =0;
        INVI PVOID operator[]   (int &t)                =0;

    };
    /* Наследуем template Vector от интерфейса, описываем функции интерфейса*/
    template<typename type>
    public class TempVECTOR: public IVECTOR
    {
    public:
        vector<type> Vec;   //Создаем вектор плавающего типа, для последующей работы с ним
        INVI void push_back(PVOID var)              {   Vec.push_back(*(type*)var);                 }
        INVI void pop_back()                        {   Vec.pop_back();                             }
        INVI void erase(int &index)                 {   Vec.erase(Vec.begin()+index);               }
        INVI void inrease(int &index, PVOID var)    {   Vec.insert(Vec.begin()+index,*(type*)var);  }
        INVI PVOID back()                           {   return (PVOID)&Vec.back();                  }
        INVI PVOID front()                          {   return (PVOID)&Vec.front();                 }
        INVI int size()                             {   return Vec.size();                          }
        INVI PVOID operator[](int &t)               {   return (PVOID)&Vec[t];                      }
    };
}
using namespace VC;
//Создаем Вектор и возвращаем его как интерфейс
IVECTOR* Release(TypeCode ctype){
    switch(ctype)
    {
        case TypeCode::Int32:       {return new TempVECTOR<Int32>();break;}
        case TypeCode::Double:      {return new TempVECTOR<Double>();break;}
        case TypeCode::Char:        {return new TempVECTOR<Char>();break;}
        case TypeCode::Boolean:     {return new TempVECTOR<Boolean>();break;}
        case TypeCode::Int64:       {return new TempVECTOR<Int64>();break;}
        case TypeCode::UInt32:      {return new TempVECTOR<UInt32>();break;}
        case TypeCode::SByte:       {return new TempVECTOR<SByte>();break;}
        case TypeCode::Byte:        {return new TempVECTOR<Byte>();break;}
        case TypeCode::Int16:       {return new TempVECTOR<Int16>();break;}
        case TypeCode::UInt16:      {return new TempVECTOR<UInt16>();break;}
        case TypeCode::UInt64:      {return new TempVECTOR<UInt64>();break;}
        case TypeCode::Single:      {return new TempVECTOR<Single>();break;}
    }
    return NULL;
}


////////
namespace VC {
    //Описываем сам переносимый класс
    public ref class Vector
    {
    protected:
        IVECTOR *IV;    //Указатель на интерефейс вектора типа(TypeCode ctype)
    public:
        //Конструктор вектора базового типа
        Vector(TypeCode ctype)              {IV=Release(ctype);}
        inline void push_back(PVOID var)    {IV->push_back(var);}
        inline void pop_back()              {IV->pop_back();}      
        inline void erase(int index)        {IV->erase(index);}
        inline void increase(int index,PVOID var)                                              
                                            {IV->inrease(index,var);}      
        inline PVOID back()                 {return IV->back();}
        inline PVOID front()                {return IV->front();}
        inline int size()                   {return IV->size();}
        inline PVOID top(int t)             {return (*IV)[t];}
    };
}