Discussion :

[smiles75]

Bonjour,

J'ai récupéré du code dont les variables sont suivies soit d'un &, soit d'un #, soit d'un $.
Par exemple :

Code :

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

1
2
Dim r#(), q&, v#()
Function GetValueInstm(inst$, mat#, ten#, p#, stk#, ts, dr#, iv#)

Ensuite les variables utilisées dans le code ne sont plus suivies de ses caractères.
A quoi donc servent ces caractères dans la déclaration ?

Merci.
Emmanuel

[tirex28]

Bonjour,

Ce sont des caracteres de declaration de type;

Code :

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

Dim x#

est equivalent à:

Code :

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

Dim x As Double

Cordialement,

Tirex28/

[Gorfael]

Salut smiles75 et le forum

J'ai récupéré du code dont les variables sont suivies soit d'un &, soit d'un #, soit d'un $.

C'est une manière de déclarer des variables
Dim Col$ revient à écrire
Dim Col as string
Mais comme je ne me souviens jamais à quoi correspond tel caractère, je ne les emploie jamais.
A+

[wilfried_42]

bonjour à tous

voici quelques signes avec leur correspondance

% : Integer
& : Single (simple precision)
# : Double (Double precision)
$ : String (Alphanumerique)

dur dur la memoire

[zazaraignée]

J'ai une autre source (Visual Basic 6, editions CampusPress) qui dit ceci

& Long
! Single
# Double
@ Currency

mais passe sous silence les suffixes de Integer et String...

Ce genre de déclaration est issue du Basic, mais alors là du très vieux Basic de l'époque des lignes numérotées.

Ceci dit, je n'ai pas testé, mais il semble y avoir une embrouille entre ce que wilfried_42 propose sur le suffixe des variables Single et la source que j'ai chez moi.

[fring]

http://gilmir.developpez.com/tutoriels-vb6/tutoriel26/

[AlainTech]

Il suffit d'aller dans l'aide en ligne pour avoir l'information.
Voici ce qu'on obtient pour Single (par exemple):

Single, type de données

Les variables de type Single (à virgule flottante en simple précision) sont stockées sous la forme de nombres à virgule flottante de 32 bits (4 octets) IEEE dont la valeur est comprise entre -3,402823E38 et -1,401298E-45 pour les nombres négatifs et entre 1,401298E-45 et 3,402823E38 pour les positifs. Le caractère de déclaration de type Single est le point d'exclamation (!).

[wilfried_42]

re:

zazaraigné tu as raison avec le ! c'est bien single, j'avais hesité, mais ne connaissant pas le type long (n'zxistait pas à l'epoque et j'ai quitter le basic conventionnel en 1988

neanmoins ces siçgne datent d'avant microsoft j'ai travailler sur Kbasic sur system CPM en 1983 (K pour Key, deja des fichier indexes) en ensuite sur Mbasic86 (M pour Microsoft et 86 pour 1986)

cela fait 25 ans deja

[smiles75]

Merci pour vos réponses, je me coucherai moins bête ce soir !

[ouskel'n'or]

Dans Visual Basic, le signe @ est le caractère de déclaration du type Currency.
Dans Visual Basic, le signe dièse (#) est le caractère de déclaration du type Double.
Dans Visual Basic, le signe % est le caractère de déclaration du type Integer.
Dans Visual Basic, le signe et commercial (&) est le caractère de déclaration du type Long.
Dans Visual Basic, le point d'exclamation (!) est le caractère de déclaration du type Single.
Dans Visual Basic, le signe dollar ($) est le caractère de déclaration du type String.
Toutes les variables sont converties en type Variant si aucun autre type de données n'est explicitement déclaré.

[ucfoutu]

Bonjour,

archaique ? faut voir... un suffixe peut permettre d'économiser une variable ...

Test, donc :

Code :

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

1
2
3
4
5
6
Private Sub Command1_Click()
  Dim x As Single, y As Single
   x = 1.23! / 2.35!
  y = 1.23 / 2.35
  MsgBox x & vbCrLf & y & vbCrLf & "différence = " & x - y
End Sub

[zazaraignée]

ucfoutu nous a fait la brillante démonstration que les symboles suffixes de type de données ne sont pas complètement archaïques.

Je dirais cependant que leur utilisation devient plus rare parce qu'on ne les connait pas assez bien. De plus, les programmeurs ayant adopté la déclaration explicite (Dim maVariable As nomDuType) ont de ce fait relégué aux oubliettes cette façon de déclarer les variables.

Je me souviens d'un temps désormais révolu où je m'amusais à programmer des petits quiz en Basic à numéros sur l'ordi de mon père (un TRS 80 branché sur une télé, c'est vous dire) où le simple fait de déclarer une variable sans le suffixe $ créait automatiquement une variable numérique (peu importe le type, je me demande s'il y avait une quelconque différence alors...) et avec le $ on obtenait un String (évidemment). Mais aussi, et ce qui est impossible aujourd'hui, les variables a et a$ étaient considérées comme deux variables distinctes. Essayez donc de déclarer de telles variables dans une même procédure aujourd'hui en VB... Résultat : message d'erreur!

Pour illustrer les différents types de variables suffixées, je me suis amusée à faire ceci (à copier dans un module) :

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
Sub Suffixes()
    Dim a$, b%, c&, d!, e#, f@
    a$ = "un virgule zéro un"
    b% = 1.01
    c& = 1.01
    d! = 1.01
    e# = 1.01
    f@ = 1.01
    Range("A1").Value = a$
    Range("B1").Value = "La cellule A1 contient un " & QuelType(VarType(a$))
    Range("A2").Value = b%
    Range("B2").Value = "La cellule A2 contient un " & QuelType(VarType(b%))
    Range("A3").Value = c&
    Range("B3").Value = "La cellule A3 contient un " & QuelType(VarType(c&))
    Range("A4").Value = d!
    Range("B4").Value = "La cellule A4 contient un " & QuelType(VarType(d!))
    Range("A5").Value = e#
    Range("B5").Value = "La cellule A5 contient un " & QuelType(VarType(e#))
    Range("A6").Value = f@
    Range("B6").Value = "La cellule A6 contient un " & QuelType(VarType(f@))
End Sub
 
Function QuelType(t As Integer) As String
    Select Case t
      Case vbEmpty          '  0
        QuelType = "Empty"
      Case vbNull           '  1
        QuelType = "Null"
      Case vbInteger        '  2
        QuelType = "Integer"
      Case vbLong           '  3
        QuelType = "Long"
      Case vbSingle         '  4
        QuelType = "Single"
      Case vbDouble         '  5
        QuelType = "Double"
      Case vbCurrency       '  6
        QuelType = "Currency"
      Case vbDate           '  7
        QuelType = "Date"
      Case vbString         '  8
        QuelType = "String"
      Case vbObject         '  9
        QuelType = "Object"
      Case vbError          ' 10
        QuelType = "Error"
      Case vbBoolean        ' 11
        QuelType = "Boolean"
      Case vbVariant         ' 12
        QuelType = "Variant"
      Case vbDataObject     ' 13
        QuelType = "DataObject"
      Case vbDecimal        ' 14
        QuelType = "Decimal"
      Case vbByte           ' 17
        QuelType = "Byte"
      Case vbUserDefinedType ' 36
        QuelType = "UserDefinedType"
      Case vbArray          ' 8192
        QuelType = "Array"
    End Select
End Function

Comme vous voyez, la fonction VarType permet d'identifier de nombreux types de variables, à condition que ceux-ci soit contenus dans un Variant... Voir l'aide de VB (ou VBA) pour la suite...