Classe de conversion inter-bases (base 2-36 vers base 2-36)

Soyez le premier à donner votre avis sur cette source.

Vue 6 580 fois - Téléchargée 396 fois

Description

Salut, voilà une classe de conversion inter-bases. Certes, encore une source dans ce genre, mais l'intérêt de la mienne est triple :

-permet de convertir des grands nombres (bien au délà des fonctions Hex et Oct de VB) ==> par exemple permet de convertir jusqu'à plus de 250000000000000 de décimal vers hexadécimal

-pas d'erreur générée quel que soit les bases/string à convertir, même si çà dépasse la capacité, mais un évênement est lancé

-c'est une classe (à réutiliser telle qu'elle est ==> très simple d'utilisation)

Utilisation : (c'est une classe, donc à instancier et libérer...)

Pour une conversion de hexa à binaire par exemple:

cConv.CurrentBase = 16
cConv.CurrentString = "F500A0"
RESULTAT = cConv.Convert(2)

Source / Exemple :


' =======================================================
'
' Hex Editor VB
' Coded by violent_ken (Alain Descotes)
'
' =======================================================
'
' A complete hexadecimal editor for Windows ©
' (Editeur hexadécimal complet pour Windows ©)
'
' Copyright © 2006-2007 by Alain Descotes.
'
' This file is part of Hex Editor VB.
'
' Hex Editor VB is free software; you can redistribute it and/or modify
' it under the terms of the GNU General Public License as published by
' the Free Software Foundation; either version 2 of the License, or
' (at your option) any later version.
'
' Hex Editor VB is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
' GNU General Public License for more details.
'
' You should have received a copy of the GNU General Public License
' along with Hex Editor VB; if not, write to the Free Software
' Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
'
' =======================================================

Option Explicit

'=======================================================
'//CLASSE DE CONVERSION INTER BASES
'=======================================================

'=======================================================
'ENUM
'=======================================================
Public Enum TYPEOFERROR
    [Valeur a convertir trop grande]
    [Base d'arrivee interdite]
    [Base de depart interdite]
    [Base de depart et string a convertir incompatibles]
End Enum

'=======================================================
'VARIABLES PRIVEES
'=======================================================
Private strString As String 'string actuelle
Private bytBase As Byte 'base actuelle
Private bConversionPossible As Long  'conversion possible ou pas

'=======================================================
'EVENT
'=======================================================
Public Event ErrorOccured(Error As TYPEOFERROR)

'=======================================================
'PROPERTIES
'=======================================================
Public Property Get CurrentString() As String: CurrentString = strString: End Property
Public Property Let CurrentString(ByVal NewString As String): strString = UCase$(NewString): End Property
Public Property Get CurrentBase() As Byte: CurrentBase = bytBase: End Property
Public Property Let CurrentBase(ByVal NewBase As Byte)
    If NewBase >= 2 And NewBase <= 36 Then
        bytBase = NewBase
    Else
        RaiseEvent ErrorOccured([Base de depart interdite])
    End If
End Property
Public Property Get StringLen() As Long: StringLen = Len(Me.CurrentString): End Property
Public Property Get ConversionFailed() As Boolean: ConversionFailed = Not (bConversionPossible = 1): End Property

'=======================================================
'PUBLIC PROCEDURE & FUNCTIONS
'=======================================================

'=======================================================
'lance la conversion
'=======================================================
Public Function Convert(ByVal NewBase As Byte, Optional ActualBase As Byte) As String
Dim lBase As Long

    bConversionPossible = 0
    If Not (NewBase >= 2 And NewBase <= 36) Then
        Convert = "-1"
        RaiseEvent ErrorOccured([Base d'arrivee interdite])
        Exit Function
    End If
    
    'récupère la base de départ
    If (ActualBase < 2 Or ActualBase > 36) Then
        lBase = Me.CurrentBase
    Else
        lBase = ActualBase
    End If
    
    If IsBaseOk(lBase, Me.CurrentString) = False Then
        Convert = "-1"
        RaiseEvent ErrorOccured([Base de depart et string a convertir incompatibles])
        Exit Function
    End If

    'lance la conversion
    Convert = ConvertBASES(lBase, NewBase, Me.CurrentString)
End Function

'=======================================================
'PRIVATE PROCEDURE & FUNCTIONS
'=======================================================

'=======================================================
'initialisation de la classe
'=======================================================
Private Sub Class_Initialize()
    Me.CurrentBase = 10
    Me.CurrentString = vbNullString
    bConversionPossible = 1
End Sub

'=======================================================
'convertion inter bases
'récupère la base de départ, celle d'arrivée et la string à convertir
'renvoie la string convertie
'=======================================================
Private Function ConvertBASES(ByVal BaseDep As Long, ByVal BaseArriv As Long, _
    ByVal sWord As String) As String
Dim x As Long
Dim lLen As Long
Dim s As String
Dim nb As Currency
Dim sRes As String
Dim valD As Currency
Dim val3 As Long
Dim val2 As Currency

    On Error GoTo ErrGestion
    
    'taille de la string
    lLen = Len(sWord)
    
    sRes = vbNullString
    nb = 0
    
    '//on récupère la valeur du nombre en décimal
    'pour chaque caractère de la string
    For x = lLen To 1 Step -1
        s = Mid$(sWord, x, 1)
        
        'récupère la valeur de ce caractère dans la base de départ
        valD = AexpB(BaseDep, lLen - x)
        
        If bConversionPossible = 2 Then GoTo ErrGestion
                
        valD = GetAssociatedVal(s) * valD
        
        nb = nb + valD
    Next x
    
    '//détermine la taille de la future string
    val2 = 0: x = 0
    While nb >= val2
    
        If bConversionPossible = 2 Then GoTo ErrGestion
    
        val2 = AexpB(BaseArriv, x)
        x = x + 1
    Wend
    
    sRes = String$(x - 1, "0")

    '//maintenant on créé la string dans la nouvelle base
    While Not (nb = 0)
        
        'recherche la plus grande puissance possible
        val2 = 0: x = 0
        While nb >= val2
            val2 = AexpB(BaseArriv, x)
            
            If bConversionPossible = 2 Then GoTo ErrGestion
            
            x = x + 1
        Wend
        
        'alors on a récupère le nombre de fois que cette puissance rentre dans le nombre
        val2 = AexpB(BaseArriv, x - 2)
        val3 = Int(nb / val2)
        
        'créé la string
        If Len(sRes) > (x - 1) Then
            sRes = Left$(sRes, Len(sRes) - x + 1) & GetAssociatedCar(val3) & Right$(sRes, Len(sRes) - Len(Left$(sRes, Len(sRes) - x + 1)) - 1)
        Else
            sRes = GetAssociatedCar(val3) & Right$(sRes, Len(sRes) - 1)
        End If
        
        'on retranche le nombre
        val2 = val2 * val3
        nb = nb - val2
    Wend
            
    ConvertBASES = sRes
    
    bConversionPossible = 1
    Exit Function
    
ErrGestion:
    ConvertBASES = "-1"
    RaiseEvent ErrorOccured([Valeur a convertir trop grande])
End Function

'=======================================================
'renvoie le caractère associé à l'élémént bytChar (de 0 à 35)
'ex : bytChar=10 ==> GetAssociatedCar=A
'=======================================================
Private Function GetAssociatedCar(ByVal bytChar As Long) As String
    
    If bytChar < 10 Then
        GetAssociatedCar = Trim$(Str$(bytChar))
    Else
        GetAssociatedCar = Chr$(55 + bytChar)
    End If
  
End Function

'=======================================================
'renvoie la valeur associée à l'élémént strChar (de 0 à 35)
'ex : strChar="A" ==> GetAssociatedVal=10
'=======================================================
Private Function GetAssociatedVal(ByVal strChar As String) As Long
Dim byt As Long
    
    byt = Asc(strChar)
    
    If byt <= 57 Then
        'alors c'est un chiffre
        GetAssociatedVal = byt - 48
    Else
        'alors c'est une lettre
        GetAssociatedVal = byt - 55
    End If
        
End Function

'=======================================================
'renvoie a^b (plus rapide que a^b et pas d'erreur)
'=======================================================
Private Function AexpB(ByVal a As Currency, ByVal b As Long) As Currency
Dim x As Long
Dim l As Currency

    On Error GoTo ErrGestion

    If b = 0 Then
        AexpB = 1
        Exit Function
    End If
    
    l = 1
    For x = 1 To b
        l = l * a
    Next x
    AexpB = l
    
    Exit Function
ErrGestion:
    bConversionPossible = 2
End Function

'=======================================================
'vérifie que la base est compatible avec la string
'=======================================================
Private Function IsBaseOk(ByVal lngBase As Long, ByVal strS As String) As Boolean
Dim x As Long
Dim l As Byte
Dim lmax As Byte
Dim lmin As Byte

    IsBaseOk = False
    
    lmax = 0: lmin = 255
    'il faut vérifier que la string ne comporte pas de valeur hors base
    For x = 1 To Len(strS)
        l = Asc(Mid$(strS, x, 1))
        If l > lmax Then lmax = l   'récupère le plus grand char
        If l < lmin Then lmin = l 'récupère le plus petit char
    Next x
    
    If lngBase <= 10 Then
        'alors il faut que des chiffres
        
        If Not (lmin >= 48 And lmin < (48 + lngBase) And lmax >= 48 And lmax < (48 + lngBase)) Then
            'alors c'est pas bon
            Exit Function
        End If
    Else
        'chiffres et lettres A-Z
        If lmin < 48 Or (lmin > 57 And lmin < 65) Or lmin >= (55 + lngBase) Or lmax < 48 Or lmax >= (55 + lngBase) Or _
            (lmax > 57 And lmax < 65) Then
            'pas bon
            Exit Function
        End If
    End If
    
    IsBaseOk = True
    
End Function

Conclusion :


Bon, un petit code tout simple et sans prétention !

Néanmoins, si vous trouvez des bugs, n'hésitez pas à les pointer...

Commentez et notez SVP !!

PS : je ne pense pas que ce code mérite d'être supprimé, puisqu'il apporte des choses par rapport aux autres sources qui traitent du même sujet

@+

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

violent_ken
Messages postés
1822
Date d'inscription
mardi 31 mai 2005
Statut
Membre
Dernière intervention
26 octobre 2010
-
Merci !
Hex Editor VB commence à prendre forme, çà avance (prealpha 1.5) ;)

@+ et merci
cs_Galain
Messages postés
1270
Date d'inscription
mardi 11 novembre 2003
Statut
Membre
Dernière intervention
24 juillet 2013
6 -
C'est du beau boulot
Bravo !

Hex Editor VB : on l'attend avec beaucoup d'impatience
Cela va être un Winhex freeware de qualité
violent_ken
Messages postés
1822
Date d'inscription
mardi 31 mai 2005
Statut
Membre
Dernière intervention
26 octobre 2010
-
Salut et merci ;)

Comme j'évite le copier/coller, j'ai pas vraiment cherché si l'équivalent (grands nombres et gestion d'erreur) existait sur vbfrance.

Si oui, bah çà fera 2 mais effectivement je commente beaucoup, si non, bah le voilà ;)

@+



Au passage pour les admins : la coloration syntaxique de vbfrance bug pour les enums avec des []

(voir plus haut ces lignes de code :)
Public Enum TYPEOFERROR
[Valeur a convertir trop grande]
[Base d'arrivee interdite]
[Base de depart interdite]
[Base de depart et string a convertir incompatibles]
End Enum

@+
MadM@tt
Messages postés
2215
Date d'inscription
mardi 11 novembre 2003
Statut
Membre
Dernière intervention
16 juillet 2009
-
C'est sur il en existe plein des codes dans ce genre, mais propres et commentés comme ça ! doit pas y'en avoir des masses ^^, bravo

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.