1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
| // 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...");
}
} |
Déclarer un char**
Répondre avec citation
Partager