Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 6 sur 6
  1. #1
    Invité de passage
    Inscrit en
    juillet 2010
    Messages
    2
    Détails du profil
    Informations forums :
    Inscription : juillet 2010
    Messages : 2
    Points : 1
    Points
    1

    Par défaut 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

  2. #2
    Modérateur
    Avatar de koala01
    Profil pro Philippe Dunski
    Inscrit en
    octobre 2004
    Messages
    9 703
    Détails du profil
    Informations personnelles :
    Nom : Philippe Dunski
    Âge : 42

    Informations forums :
    Inscription : octobre 2004
    Messages : 9 703
    Points : 15 809
    Points
    15 809

    Par défaut

    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_;
    };
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  3. #3
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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.
    Mieux que SDL : découvrez SFML

  4. #4
    Invité de passage
    Inscrit en
    juillet 2010
    Messages
    2
    Détails du profil
    Informations forums :
    Inscription : juillet 2010
    Messages : 2
    Points : 1
    Points
    1

    Par défaut Merci

    Citation Envoyé par koala01 Voir le message
    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 ?!

  5. #5
    Modérateur
    Avatar de koala01
    Profil pro Philippe Dunski
    Inscrit en
    octobre 2004
    Messages
    9 703
    Détails du profil
    Informations personnelles :
    Nom : Philippe Dunski
    Âge : 42

    Informations forums :
    Inscription : octobre 2004
    Messages : 9 703
    Points : 15 809
    Points
    15 809

    Par défaut

    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:

    1. D'ajouter un constructeur prenant un uint32_t comme argument (même s'il risque de ne pas être utilisé)
    2. De modifier la classe pour qu'elle maintienne effectivement l'adresse sous la forme d'un uint_32
    3. Modifier le constructeur prenant une std::string pour qu'il convertisse l'adresse.
    4. D'ajouter une fonction permettant de converir la valeur en std::string (ce sera plus pratique pour l'affichage)
    5. D'ajouter un accesseur sur uint32_t (au cas où)
    6. 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
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  6. #6
    Responsable Réseaux

    Avatar de ram-0000
    Homme Profil pro Raymond Mercier
    Consultant en sécurité
    Inscrit en
    mai 2007
    Messages
    11 186
    Détails du profil
    Informations personnelles :
    Nom : Homme Raymond Mercier
    Âge : 51
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Consultant en sécurité
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : mai 2007
    Messages : 11 186
    Points : 46 532
    Points
    46 532

    Par défaut

    Citation Envoyé par koala01 Voir le message
    [*]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) ?
    Raymond
    Vous souhaitez participer à la rubrique Réseaux ? Contactez-moi

    Cafuro Cafuro est un outil SNMP dont le but est d'aider les administrateurs système et réseau à configurer leurs équipements SNMP réseau.
    e-verbe Un logiciel de conjugaison des verbes de la langue française.

    Ma page personnelle sur DVP
    .

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •