UTILISATION D'UN TABLEAU DE VARIANT POUR PASSER UNE LISTE (PRATIQUE POUR LES OBJETS COM ET ACTIVEX)

// SafeArray.cpp : Defines the entry point for the console application.
//
#include <comutil.h>
#include "stdafx.h"
#include "SafeArray.h"
#include <stdio.h>
#include <icrsint.h>
#include <COMDEF.H>

#define LENGTH(x) (sizeof(x)/sizeof(x[0]))

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// The one and only application object

CWinApp theApp;

using namespace std;
/***************************************************************************
//Exemple d'utilisation d'un des types de variant comme liste.
//On pourra accèder à notre liste via un pointeur sur un variant que l'on a crée comme 
//étant un tableau de variant... 
//
//TheTableau (notre tableau alias pseudo liste)
//                            Objet 1   Objet 2   Objet3  (...)  Objet m-1   Objet m
//Element 1 de notre liste   [       ] [       ] [       ] ...  [         ] [       ] 
//Element 2 de notre liste   [       ] [       ] [       ] ...  [         ] [       ] 
//Element 3 de notre liste   [       ] [       ] [       ] ...  [         ] [       ] 
// ...
//Element n-1 de notre liste [       ] [       ] [       ] ...  [         ] [       ] 
//Element n de notre liste    [       ] [       ] [       ] ...  [         ] [       ]
//
//the rgsabound = caractéristique de notre tableau (pseudo liste)
// lbound   cElement   
//[   0  ] [    n    ]
//[   0  ] [    m   ]
//
//lcount = le curseur sur l'Objet sur lequel on travail
//[ Numero d'element ]
//[ Numero d'Objet     ]
*************************************************************************/

void TheProg(void);
void RemplirVariant(VARIANT* TheTableau);


int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
	int nRetCode = 0;

	// initialize MFC and print and error on failure
	if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
	{
		// TODO: change error code to suit your needs
		cerr << _T("Fatal Error: MFC initialization failed") << endl;
		nRetCode = 1;
	}
	else
	{
      TheProg();
	}

	return nRetCode;
}


void TheProg(void)
{
   VARIANT TheTableau;
   RemplirVariant(&TheTableau);

   //c'est ce dont on va avoir besoin de récupérer
   SAFEARRAYBOUND rgsabound[2];
   long lCount[2];
   _variant_t  vntparam;
   float Valeur_lut;
   int i=0,j=0;

   /***********************************************************************/
   //on a terminé de remplir notre tableau on va maintenant l'afficher
   CString MyStr;
   MyStr = "";


   //   ::SafeArrayGetDim   renvoie le nombre de dimension... on devrait le faire
   //                       avant ce qui suit...
   //voici pour lire le rgsabound
   SafeArrayGetLBound(TheTableau.parray, 1, (long*)&rgsabound[0].lLbound); 
   SafeArrayGetUBound(TheTableau.parray, 1, (long*)&rgsabound[0].cElements); 
   SafeArrayGetLBound(TheTableau.parray, 2, (long*)&rgsabound[1].lLbound); 
   SafeArrayGetUBound(TheTableau.parray, 2, (long*)&rgsabound[1].cElements); 
   
   
   
   //on va parcourir tout les éléments du tableau... de la liste je veux dire, de la liste
   //notez le plus petit ou égal... puisque c'est l'index qui nous est renvoyé par les fonction
   //précédente... c'est à dire l'index du dernier élément
   for(i = rgsabound[0].lLbound; i <= rgsabound[0].cElements; i++)
   {
      lCount[0] = i;
      for(j = rgsabound[1].lLbound; j<= rgsabound[1].cElements; j++)
      {
         lCount[1] = j;
         ::SafeArrayGetElement(TheTableau.parray,lCount,&vntparam);
         Valeur_lut = vntparam;
         printf("%5.0f  ",Valeur_lut);
         
      }
      printf("\n");
   }
   //*/
}
void RemplirVariant(VARIANT* TheTableau)
{
   SAFEARRAYBOUND rgsabound[2];
   long lCount[2];
   _variant_t  vntparam;
   int i = 0;
   int j = 0;

   try
   {
      ::VariantClear(TheTableau);
      //la première dimension de notre variant va représenter la liste
      rgsabound[0].lLbound   = 0; //index du premier élément si je ne m'abuse
      rgsabound[0].cElements = 20; //index du dernier élément si je ne m'abuse
      //la deuxième dimension va représenter la structure d'élément (bref le tout est stoqué
      // sous forme de tableau dynamique)
      rgsabound[1].lLbound   = 0;  
      rgsabound[1].cElements = 5;  //on veut stocqué 5 élément dans notre cas 
      
      //on ajuste le type de variant que l'on veut
      TheTableau->vt = VT_ARRAY | VT_VARIANT; //dans ce cas ci je viens de lui dire un 
                                                                        //tableau de variant

      //on assigne le "array"
      TheTableau->parray = ::SafeArrayCreate(VT_VARIANT,
                                          LENGTH(rgsabound),
                                          rgsabound);
      //on vérifie si tout s'est déroullé correctement...
      if(TheTableau->parray == NULL)
      {
         throw false;
      }
      
      //on va parcourir tout les éléments du tableau... de la liste je veux dire, de la liste
      for(i = rgsabound[0].lLbound; i < rgsabound[0].cElements; i++)
      {
         lCount[0] = i;
         for(j = rgsabound[1].lLbound; j< rgsabound[1].cElements; j++)
         {
            lCount[1] = j;
            vntparam =(float) (i*100) + j; //ça pourrait être des string, des enum etc.
            ::SafeArrayPutElement(TheTableau->parray,lCount,&vntparam);
         }
      }
   }
   catch(bool)
   {
      printf("une erreur est survenue à quelque part...");
   }

}