Discussion :

[pijaku]

Bonjour,

La fonction objet de ce sujet étant cachée par Microsoft, il n'existe pas de documentation à ce sujet.

Après m'être un peu penché sur la question (doc unofficial), il s'agit d'une fonction créée pour réaliser des appels à la fonction Unicode (MyUnicodeCall de la librairie "MyUnicodeDll.Dll" par exemple).
Ne possédant pas cette dll sur mon pc, je ne me suis pas encore documentée à son propos.

Néanmoins, sans connaitre ses origines, la fonction StrPtr possède certaines "qualités" que je souhaite découvrir avec vous (mes tests n'étant pas toujours bien orientés...).

A titre d’élargissement, il sera peut-être intéressant, en fin de topic, de se pencher sur ces consœurs VarPtr et ObjPtr.

Je vais donc poser ma première question :
Comment StrPtr fonctionne (en gros) ?
[cette notion de pointeurs est encore hyper floue pour moi]

[Pierre Fauconnier]

Salut.

Bonne idée, on pourra alimenter la faq...

La fonction MyUnicodeCall.dll est prise en exemple dans le lien que tu cites, mais elle n'existe pas. Le nom utilisé est simplement là pour illustrer le code, on aurait pu tout aussi bien utiliser toto.dll...

[pijaku]

Notion de pointeurs...
Pas si simple.
Cette image trouvée sur wikipédia :
Pièce jointe 270758
Nous indique que a est un pointeur vers la variable b.

Si j'ai bien saisi, un pointeur est donc une variable contenant l'adresse d'une autre variable.
C'est donc l'équivalant d'une variable passée ByRef dans une fonction?

Si j'ai bien compris, donc, StrPtr renvoie le pointeur de la variable qu'on lui a passé, et, par conséquent, l'adresse de cette variable.
Est ce cela?

Si oui, cela expliquerait les résultats (curieux) de ce petit test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
Sub AvecVbUnicode()
Dim S As String, S1 As String, i As Integer
For i = 1 To 10
    S = "": S1 = ""
    S = StrConv(S, vbFromUnicode)
    Debug.Print StrPtr(S) & " -- " & StrPtr(S1)
Next
End Sub

résultats :

202728940 -- 202827308
202826908 -- 202728940
202827308 -- 202826908
202728940 -- 202827308
202826908 -- 202728940
202827308 -- 202826908
202728940 -- 202827308
202826908 -- 202728940
202827308 -- 202826908
202728940 -- 202827308

On voit que les retours se "croisent"

[Pierre Fauconnier]

Si les pointeurs t'intéressent, tu peux aller faire un tour sur http://chgi.developpez.com/pointeur/ (C'est du C/C++, mais les notions sont là).

[unparia]

Salut
Le mot "MyUnicodeCall.dll" n'est là que pour dire : toute fonction dont un ou plusieurs paramètres sont à être reçus sous forme de pointeur vers une chaîne unicode

StrPtr permet l'obtention d'un pointeur vers une chaîne Unicode
StrPtr est très utile pour passer par exemple et entre autres ses deux premiers paramètres à la fonction NetShareGetInfo de la librairie Netapi32.dll ****

**** précisions que ces fonctions se contentaient jusqu'à NT de'un pointeur vers une chaîne ANSI.

[pijaku]

@Pierre : merci!
Lu et compris.
Assimilé, on verra ça par la suite

@dysorthographie :
Bonjour Robert,
Oui, en effet. Tout cela est d'ailleurs "aperçu" dans le lien de Pierre au chapitre 6.

@Unparia :
Bonjour Jacques,

StrPtr permet l'obtention d'un pointeur vers une chaîne Unicode

Cela signifie que StrPtr créé un pointeur vers la chaîne Unicode passée en paramètre et retourne un LngPtr.
Ce LngPtr représente quoi? L'adresse du pointeur?
C'est THE BIG question pour moi...
Une fois cette question résolue (pour moi), on pourra voir ensemble des utilisations pratiques de cette fonction.

StrPtr est très utile pour passer par exemple et entre autres ses deux premiers paramètres à la fonction NetShareGetInfo de la librairie Netapi32.dll

Connais pas cette fonction. Vais me renseigner de suite...

[pijaku]

Bonjour,

J'ai commencé les tests proposés par Jacques.
N'hésitez surtout pas à critiquer vertement les tests si ceux-ci vous paraissent farfelus/stupides/inutiles.
Merci d'avance.

Tout d'abord le test sur des String "vides" :
Soit a = vbNulString, b = "", et c variable String déclarée mais non alimentée.
Peut-on faire la différence entre les 3?
Et bien on peut différencier a et b, b et c, mais a et c sont identiques en tout point.
Ce dernier test, entre a et c, nous permet tout de même de savoir/confirmer/établir (rayer les mentions inutiles) que, lors du dimensionnement d'une variable String, elle vaut vbNullString.

Ce test, le voici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Sub StrPtr_vbNullString()
Dim a As String, b As String, c As String
 
  a = vbNullString
  b = ""
  MsgBox ("la chaîne a est-elle """"égale"""" à la chaîne b ? ---> ") & (a = b) & vbCrLf & _
  "car a = " & """" & a & """" & " et que b = également " & """" & b & """"
  MsgBox ("la chaîne a est-elle """"égale"""" à la chaîne c ? ---> ") & (a = c) & vbCrLf & _
  "car a = " & """" & a & """" & " et que c = également " & """" & c & """"
  MsgBox ("strptr(a) est-il égal à strptr(b) ? ----> ") & (StrPtr(a) = StrPtr(b)) & vbCrLf & _
  "car strptr(a) retourne " & StrPtr(a) & " tandis que strptr(b) retourne " & StrPtr(b)
  MsgBox ("strptr(a) est-il égal à strptr(c) ? ----> ") & (StrPtr(a) = StrPtr(c)) & vbCrLf & _
  "car strptr(a) retourne " & StrPtr(a) & " et que strptr(c) retourne " & StrPtr(c)
  MsgBox ("... ET Logiquement... strptr(b) est-il égal à strptr(c) ? ----> ") & (StrPtr(b) = StrPtr(c)) & vbCrLf & _
  "car strptr(b) retourne " & StrPtr(b) & " tandis que strptr(c) retourne " & StrPtr(c)
End Sub

Je vais poursuivre avec les tests sur variable tableau.

[pijaku]

Bonjour Jacques,

Ton second test proposé concerne les variables tableaux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
Sub Test_Tablo()
    ReDim toto(1) As String
    Debug.Print StrPtr(toto(0))
    toto(0) = ""
    Debug.Print StrPtr(toto(0))
    ReDim Preserve toto(1)
    Debug.Print StrPtr(toto(0))
    ReDim toto(1)
    Debug.Print StrPtr(toto(0))
    toto(0) = ""
    Debug.Print StrPtr(toto(0))
End Sub

Ce test confirme pour moi le comportement de ReDim et du mot clé Preserve.
On peut donc, si j'ai bien compris ce test, savoir, à tout moment d'un code dynamique, si le tableau est alimenté.
Est ce bien cela l'objet du test?

Lorsque toto(0) n'est pas alimenté (lignes 3 et 9), StrPtr(toto(0)) vaut toujours 0. Peut-on en conclure quelque chose?

Une fois sur deux, les lignes 5, 7 et 11 donnent la même valeur pour StrPtr, la seconde fois les valeurs sont identiques pour les lignes 5 et 7 mais la 11 est différente?
Comportement normal?

J'ai donc voulu tester sur "plus grande échelle", comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
Sub Coll_String_Simple()
Dim Coll As Collection
Dim S As String
Dim Msg As String
Dim N As Long
Dim I As Long
Dim T As Single
 
N = 100000
Msg = "Nombre de tours de boucle : " & Format(N, "# ###")
 
On Error Resume Next 'permet de zapper l'erreur de Coll.Add si la clé existe déjà
'1er test :
    'Nombre de pointeurs pour la chaîne "a"
Set Coll = New Collection
T = Timer
For I = 1 To N
    Coll.Add StrPtr("a"), CStr(StrPtr("a"))
Next I
Msg = Msg & vbCrLf & vbCrLf & "1er test : " & vbCrLf & _
    "Nombre de pointeurs pour la chaîne ""a"", sans passer par une variable" & vbCrLf & _
    "==> " & Coll.Count & " en " & Timer - T & " sec."
 
'2nd test :
    'Nombre de pointeurs pour une chaîne vide (S non remplit)
Set Coll = New Collection
T = Timer
For I = 1 To N
    Coll.Add StrPtr(S), CStr(StrPtr(S))
Next I
Msg = Msg & vbCrLf & vbCrLf & "2eme test : " & vbCrLf & _
    "Nombre de pointeurs pour une chaîne vide (variable S sans affectation de valeur)" & vbCrLf & _
    "==> " & Coll.Count & " en " & Timer - T & " sec."
 
'3eme test :
    'Nombre de pointeurs pour la chaîne ""
    'la variable S est affectée de sa valeur une fois, avant la boucle
Set Coll = New Collection
T = Timer
S = ""
For I = 1 To N
    Coll.Add StrPtr(S), CStr(StrPtr(S))
Next I
Msg = Msg & vbCrLf & vbCrLf & "3eme test : " & vbCrLf & _
    "Nombre de pointeurs pour la chaîne """"" & vbCrLf & _
    "La variable S est affectée de sa valeur une fois, avant la boucle" & vbCrLf & _
    "==> " & Coll.Count & " en " & Timer - T & " sec."
 
'4eme test :
    'Nombre de pointeurs pour la chaîne "a"
    'la variable S est affectée de sa valeur à chaque tour de boucle
Set Coll = New Collection
T = Timer
For I = 1 To N
    S = "a"
    Coll.Add StrPtr(S), CStr(StrPtr(S))
Next I
Msg = Msg & vbCrLf & vbCrLf & "4eme test : " & vbCrLf & _
    "Nombre de pointeurs pour la chaîne ""a""" & vbCrLf & _
    "La variable S est affectée de sa valeur à chaque tour de boucle" & vbCrLf & _
    "==> " & Coll.Count & " en " & Timer - T & " sec."
 
'5eme test :
    'Nombre de pointeurs pour la valeur 0
    'la variable S est affectée de sa valeur à chaque tour de boucle
Set Coll = New Collection
T = Timer
For I = 1 To N
    S = 0
    Coll.Add StrPtr(S), CStr(StrPtr(S))
Next I
Msg = Msg & vbCrLf & vbCrLf & "5eme test : " & vbCrLf & _
    "Nombre de pointeurs pour la valeur 0" & vbCrLf & _
    "La variable S est affectée de sa valeur à chaque tour de boucle" & vbCrLf & _
    "==> " & Coll.Count & " en " & Timer - T & " sec."
 
'6eme test :
    'Nombre de pointeurs pour la valeur 0
    'la variable S est affectée de sa valeur une fois, avant la boucle
Set Coll = New Collection
T = Timer
S = 0
For I = 1 To N
    Coll.Add StrPtr(S), CStr(StrPtr(S))
Next I
Msg = Msg & vbCrLf & vbCrLf & "6eme test : " & vbCrLf & _
    "Nombre de pointeurs pour la valeur 0" & vbCrLf & _
    "la variable S est affectée de sa valeur une fois, avant la boucle" & vbCrLf & _
    "==> " & Coll.Count & " en " & Timer - T & " sec."
 
MsgBox Msg
End Sub

Est ce probant? Ce test nous apprend quelque chose?
Cela semble confirmer le "une fois sur deux"...

[Invité]

bonjour,
les pointeur étaient la tasse de thé du langage C, le références elles sont apparues avec le C++!
la différence est de taille.

les référence pointe sur l'adresse de base d'un objet? disons que j'ai une un onglet Excel à l'adresse FFA625. set gonglet=FFA625 me donne accès à toutes le méthodes et propriété de l'onglet!

si j'utilise un pointeur Onglet -> [FFA625: AA123456789] je me retrouve avec un tableau d'adresse mémoire équivalente à l'occupation mémoire de l'onglet en question!

disons qu'un Integer fait 4 octet dim A as integer me retourne une référence la l'adresse base de [A] alors qu'un pointeur me retourne un table de 4 octets [Octets3],[Octets2],[Octets1],[Octets0]

quand tu utilise mid(txt,10,1) tu utilise d'une certaine manière un pointeur sur un string a->txt[10]