classe adresse IP ?

Version imprimable

24/07/2010, 14h56
marvelousnight

classe adresse IP ?
Bonjour, j'ai besoin d'une classe pour pouvoir déclarer des adresses IP

exemple:
Code:

1 2 3 4 5 6 main() ... adresseIP a1(192.168.1.2); adresseIP a2(192.168.1.3); ...
Une adresse IP est sous la forme a.b.c.d
Alors j'ai créer adresseIP.h:
Code:

1 2 3 4 5 6 7 8 9 10 class adresseIP { int a,b,c,d; public: adresseIP(); adresseIP(int, int, int, int); void setIP(int, int, int, int); void getIP() { return ??; }
Est se que je peux le faire avec un tableau de 4 entiers (tab[4]) ?
Pour la methode getIP(), il faut retourner une adresse IP sous forme de a.b.c.d alors comment faire ?

Merci d'avance pour vos conseils et votre aide :ccool:

Salut,

En fait, bien qu'elle n'utilise que des chiffres et le point, une adresse ip ne devrait pas (du moins lorsqu'il s'agit de l'afficher) être considéreé comme une succession de quatre valeurs numérique, mais bel et bien comme... une chaine de caractères.

Le mieux à faire est donc sans doute de tout simplement gérer une adresse ip comme ce qu'elle est: une chaine de caractères respectant certaines règles.

Les règles sont simple:

il y a quatre valeurs numériques comprises entre 0 et 255
chaque valeur numérique est séprée par un point ".".

Tu pourrais donc envisager de créer ta classe Ip sous une forme proche de

Code:

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
class Ip
{
    public:
        struct BadFormat{}; // une exception pour si le format n'est pas bon
        /* pas de constructeur ne prenant pas d'argument
         * il n'y a aucun sens à permettre la création d'une adresse IP sans...
         * avoir l'adresse correspondante
         */
        Ip(std::string const & a):adr_(a)
        {
            int count=0;
            std::stringstream ss(adr_);
            unsigned int value;
            char c;
            while(ss>>value) //tant que l'on peut récupérer une valeur
            {
                // la valeur doit être comprise entre 0 et 255
                if(value>255)
                    throw BadFormat(); // autrement, on refuse la création
                                       // de l'objet
                if(count!=3) // tant que l'on a pas atteint la quatrième valeur
                {
                    ss>>c: // un caractère doit séparer deux valeurs
                    if(c!='.') // et ce doit être un point
                        throw BadFormat(); // autrement, on refuse la création de
                                           // l'objet
                }
                count++; 
            }
            if(count!=4) // si on n'a pas récupéré quatre valeurs exactement
                throw BadFormat(); // on refuse la création de l'objet
        }
        /* pas de "mutateur" : il n'y a aucun sens à permettre la modification
         * d'une adresse IP une fois qu'elle a été définie
         */
        std::string const & value() const{return adr_;}
    private:
        std::string adr_;
};

25/07/2010, 10h43
Laurent Gomila

Pour tout ce qui est traitement interne, la meilleure représentation pour une adresse IP sera un entier 32 bits. Ensuite, pour rendre ça "human friendly", fournir des conversions depuis/vers 4 entiers 8 bits et une chaîne de caractères sera nécessaire.

Si ton code utilise les sockets, il y a déjà tout ce qu'il faut pour réaliser ces conversions.
25/07/2010, 15h22
marvelousnight

Merci

Citation:

Envoyé par koala01

Le mieux à faire est donc sans doute de tout simplement gérer une adresse ip comme ce qu'elle est: une chaine de caractères respectant certaines règles.

Merci pour vos réponses.
Si on traite une IP comme une chaine de caractères alors comment faire pour l'incrémenter ?!

Si tu veux effectivement pouvoir envisager de manipuler une adresse IP sous la forme de ce qu'elle est réellement (une valeur numérique codée sur 32 bits), il faut alors aller un peu plus loin dans la réflexion:

Il s'agirait, selon moi:

D'ajouter un constructeur prenant un uint32_t comme argument (même s'il risque de ne pas être utilisé)
De modifier la classe pour qu'elle maintienne effectivement l'adresse sous la forme d'un uint_32
Modifier le constructeur prenant une std::string pour qu'il convertisse l'adresse.
D'ajouter une fonction permettant de converir la valeur en std::string (ce sera plus pratique pour l'affichage)
D'ajouter un accesseur sur uint32_t (au cas où)
D'ajouter un opérateur d'incréementation.

Cela donnerait quelque chose proche de

Code:

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
class IP
{
    public:
        class BadFormat{};
        IP(std::string const & n):adr(0)
        {
            int count=0;
            std::stringstream ss(n);
            unsigned int value;
            char c;
            while(ss>>value) //tant que l'on peut récupérer une valeur
            {
                // la valeur doit être comprise entre 0 et 255
                if(value>255)
                    throw BadFormat(); // autrement, on refuse la création
                                       // de l'objet
                /* valide pour système big endian */
                adr+=(value << (24-(count*8)));
                /* pour les systèmes little endian, ce serait
                 * adr+=(value <<(count*8));
                 */
                if(count!=3) // tant que l'on a pas atteint la quatrième valeur
                {
                    ss>>c; // un caractère doit séparer deux valeurs
                    if(c!='.') // et ce doit être un point
                        throw BadFormat(); // autrement, on refuse la création de
                                           // l'objet
                }
                count++;
            }
            if(count!=4) // si on n'a pas récupéré quatre valeurs exactement
                throw BadFormat(); // on refuse la création de l'objet
        }
        std::string const toString() const
        {
            std::string str;
            uint32_t temp=adr;
            unsigned char *tab=reinterpret_cast<unsigned char*> (&temp);
            std::stringstream ss;
            /* valide pour les système big endian */
            for(int i=3;i!=-1;--i)
            {
                ss<<(unsigned int )tab[i];
                if(i!=0)
                    ss<<".";
            }
            /* pour les système little endian, ce serait
             * for(int i=0;i<4;++i)
             * {
             *      ss<<(unsigned int) tab[i];
             *      if(i!=3)
             *          ss<<".";
             * }
             */
            return ss.str();
 
        }
 
        IP(uint32_t adr):adr(adr){}
        IP & operator++()
        {
            ++adr;
            return *this;
        }
        uint32_t value() const{return adr;}
    private:
        uint32_t adr;
};

qui pourrait être utilisé sous la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main()
{
    IP i("127.0.0.1");
    std::cout<<i.toString()<<std::endl;
    ++i;
    std::cout<<i.toString()<<std::endl;
    /* on pourrait envisager une boucle comme */
    while(i.toString()!="192.168.255.255")
    {
        /* ce qui doit être fait */
        ++i;
    }
    return 0;
}

ATTENTION: tout est basé sur une architecture "Big endian", et pour des adresses au format IP-V4, qui est destiné à terme à être remplacé par IP-V6

Quelques adaptations devraient donc encore être apportées :D

25/07/2010, 21h46
ram-0000

Citation:

Envoyé par koala01

[*]D'ajouter un opérateur d'incréementation.

Je ne vois pas bien le sens d'un opérateur d'incrémentation sur une adresse IP.

Par contre, je rajouterais bien des fonctions de manipulation d'adresses en fonction d'un masque réseau.

Avec cette adresse IP, quelle est l'adresse réseau si on utilise ce masque, quelle est son adresse de broadcast (par exemple) ?