Utilisation d'un tableau de variant pour passer une liste (pratique pour les objets com et activex)

Commenter

Contenu du snippet

Pour que les objets com et les ActiveX puissent parler au VB avec des structures de données volumineuse et complexe on doit souvent utiliser des variants. Ils sont plutôt moche mais efficace. Alors faute de mieux il faut apprendre à travailler avec. Alors voici un petit exemple d'utilisation d'un variant comme d'une liste. Bon il contient un interface dos, il ne fait en vérité rien mais ça montre l'utilisation de base d'un variant. ALors voilà

Source / Exemple : 


// 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...");
   }

}

Conclusion :


Votre projet doit supporter les MFC, du moins j'ai pas essayé sans mais je présume que oui. J'ai utilisé l'interface dos pcq c'est plus rapide.

have fun

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (MeltedMind)