begin process at 2012 05 27 21:12:33
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Tutoriaux

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

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


 Information sur la source

Note :
10 / 10 - par 1 personne
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :Tutoriaux Niveau :Débutant Date de création :10/01/2002 Date de mise à jour :10/01/2002 22:33:14 Vu :7 295

Auteur : MeltedMind

Ecrire un message privé
Commentaire sur cette source (1)
Ajouter un commentaire et/ou une note

 Description

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

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


 Sources du même auteur

Source avec Zip FORMATEUR / DÉBUGGER DE CODE HTML [VISUAL C++ 6.0]
Source avec Zip Source avec une capture INTERFACE DE JEUX 2D½ SANS TRANSPARENCE [VISUAL C++, MFC]
RÉCURSIVITÉ + ARBRE BINAIRE [VISUAL C++, APPLICATION CONSOLE...
TABLEAUX DYNAMIQUES, COMMENT FAIRE PROPREMENT ET EFFICACEMEN...
Source avec Zip INTERFACE 2D½ (STYLE DIABLO) L'ABC (EN COURS) [VISUAL C++, M...

 Sources de la même categorie

LISTER FICHIERS ET RÉPERTOIRES (MULTIPLATEFORME) par christophedlr
UTILISATION DES TYPELIST EN C++ par wyden
Source avec Zip Source avec une capture QCSSCOMPRESSOR par alphaone
AFFICHAGE D'UN TRIANGLE ISOCELE par nabche
Source avec Zip GESTION D'UNE BIBLOTHEQUE par leclerro19

Commentaires et avis

Commentaire de Jbs106 le 21/10/2009 12:54:33 10/10

Excellent merci pour ta source, j'ai pu faire ma fonction split en dll. Bon je te met 9/10 parce que tu dis que code est à utiliser avec les MFCs et que c'est faux, mais vu que tu as très bien décrits ta procédure, je te mets 11/10!

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,437 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales