Publicité
+ Répondre à la discussion Actualité déjà publiée
Page 3 sur 3 PremièrePremière 123
Affichage des résultats 41 à 55 sur 55
  1. #41
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut

    Le nouveau design des articles est vraiment excellent !

    Ne manque-t-il pas la partie I ?
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  2. #42
    Inactif


    Homme Profil pro Guillaume Belz
    Biochimiste
    Inscrit en
    novembre 2008
    Messages
    5 318
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume Belz
    Âge : 38
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Biochimiste
    Secteur : Santé

    Informations forums :
    Inscription : novembre 2008
    Messages : 5 318
    Points : 17 319
    Points
    17 319

    Par défaut

    La partie correspond à gcc 4.8. Elle n'est pas encore rédigée, elle est donc masquée

    Pour rappel, si vous voulez participer à cet article et rédiger des parties (ou compléter des parties existantes), n'hésitez pas

  3. #43
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut

    Moi je veux bien t'aider, mais que manque-t-il ?
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  4. #44
    Inactif


    Homme Profil pro Guillaume Belz
    Biochimiste
    Inscrit en
    novembre 2008
    Messages
    5 318
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume Belz
    Âge : 38
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Biochimiste
    Secteur : Santé

    Informations forums :
    Inscription : novembre 2008
    Messages : 5 318
    Points : 17 319
    Points
    17 319

    Par défaut

    Voir le premier post : les parties "à faire" de gcc 4.4 et tout gcc 4.3. Et relire et compléter si nécessaire ce qui est déjà écrit

    J'ai attaqué la partie move semantic, donc ça c'est bon

  5. #45
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut énumérations fortement typées

    Les énumérations simples (dites faiblement typées) se déclarent ainsi :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
     
    enum Direction
    {
        Nord,// = 0
        Est,// = 1
        Sud,// = 2
        Ouest// = 3
    };
    Elles s'utilisent comme ceci :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    Direction d = Nord;
     
    d = 2;//ce qui sous entend d = Sud
     
    int i = d*Ouest;//i = 8
     
    d = (d*3)%Sud;//d = Nord
     
    d = Ouest;
     
    ++d;//d = 5 => boom, mais le compilateur ne dira rien parce que c'est tout à fait légal
    Ces énumérations sont implicitement transformables en entiers, ce qui permet comme le montre le code ci-dessus de faire des opérations incongrues (multiplier le sud par le nord ne poserait aucun problème au compilateur), et même d'arriver à des valeurs même pas comprises dans la définition de l'énumération.

    Le C++11 apporte une solution pour remédier à cela : les énumérations fortement typées. Elle se définissent en ajoutant le mot-clé class devant le nom de l'énumération :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
     
    enum class Direction
    {
        Nord,
        Est,
        Sud,
        Ouest
    };
    L'utilisation est plus claire et plus sécurisée :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
     
    Direction d = Direction::Sud//ok
    Direction d2 = Nord;//error: Nord est inconnu
     
    d = 2;//error: on ne mélange pas les choux et les carottes
    d = (d*3)%Sud;//error
    ++d;//error
     
    d = Ouest;//error: Nord est inconnu
    d = Direction::Est;//ok
     
    int i = d*Ouest;//error
    int i2 = static_cast<int>(d);//ok i2 = 1, transformation explicite
    Bien sûr, les énumérations faiblement typées n'en sont pas pour autant obsolètes : elles restent nécessaires pour utiliser les flags. Ces deux typages (faible et fort) sont donc complémentaires.
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  6. #46
    Inactif


    Homme Profil pro Guillaume Belz
    Biochimiste
    Inscrit en
    novembre 2008
    Messages
    5 318
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume Belz
    Âge : 38
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Biochimiste
    Secteur : Santé

    Informations forums :
    Inscription : novembre 2008
    Messages : 5 318
    Points : 17 319
    Points
    17 319

    Par défaut

    Copié collé depuis le chat :
    "définissent" -> c'est pas une définition, c'est un exemple
    ne pas parler des valeurs par défaut des énums dans le premier code, on n'en parle plus après
    dans le second code, séparer le code d'utilisation correcte et le code problématique
    "les énumérations faiblement typées n'en sont pas pour autant obsolètes : elles restent nécessaires pour utiliser les flags." On peut pas faire les flags avec les enums class ? Et si on parle des flags, faut donner du code d'explication
    (avant que quelqu'un fait la remarque : il manque des choses (les underlying types en particulier), c'est pour la suite)

  7. #47
    Membre éprouvé

    Homme Profil pro
    Doctorant en astrophysique
    Inscrit en
    juin 2007
    Messages
    363
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 25
    Localisation : France

    Informations professionnelles :
    Activité : Doctorant en astrophysique

    Informations forums :
    Inscription : juin 2007
    Messages : 363
    Points : 498
    Points
    498

    Par défaut

    Note aussi qu'on peut :
    1. expliciter le type physique sous-jacent à l'énumération (int par défaut) pour les deux types d'énumération :
      Code :
      1
      2
      3
      4
      5
      6
      7
      enum /*class*/ Direction : unsigned char
      {
          Nord,
          Est,
          Sud,
          Ouest
      };
    2. faire une déclaration anticipée d'une énumération. Il faut alors préciser le type sous-jacent, sauf si l'on déclare une énumération fortement typée (qui aura alors le type par défaut, int) :
      Code :
      1
      2
      3
      enum Direction : unsigned char;
      enum class Direction ; // Direction est de type int
      enum Direction; // erreur : c'est interdit


    Edit : grillé par gbdivers, du coup j'ai l'air bête...

  8. #48
    Expert Confirmé Sénior
    Avatar de Luc Hermitte
    Homme Profil pro Luc Hermitte
    Développeur informatique
    Inscrit en
    août 2003
    Messages
    4 710
    Détails du profil
    Informations personnelles :
    Nom : Homme Luc Hermitte
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : août 2003
    Messages : 4 710
    Points : 7 007
    Points
    7 007

    Par défaut

    Pour un enum normal (98), Il n'y a pas de pré-fixage par le nom de l'enum comme tu l'as écris, germinolegrand, en ligne 3 du 2e code.
    Blog|FAQ C++|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS|Bons livres sur le C++
    Les MP ne sont pas une hotline. Je ne réponds à aucune question technique par le biais de ce média.

  9. #49
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut

    @kalith: déclaration anticipée : déjà fait et dans une autre version : http://cpp.developpez.com/redaction/.../cpp11/#LIII-C

    @luc: merci, rectifié.

    @gbdivers:
    #1: rectifié
    #2: si justement j'en parle après dans les calculs faits sur les valeurs d'enums qui sont justement basées sur ces valeurs, donc je les précise pour pouvoir comprendre le résultat des calculs du 2e code.
    #3: rectifié
    #4: non, on ne peut pas sans cast de cast de cast . J'ai ajouté un lien puisque tu y tiens () et je signale au passage que tu les utilises ailleurs sans vergogne ^^ (http://cpp.developpez.com/redaction/.../cpp11/#LIII-D) d'ailleurs tu définis des opérateurs inutiles dans ton code

    Peut-être pour illustrer les constexpr eut-il été préférable de montrer un pow implémenté en constexpr ? (très simple)
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  10. #50
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut

    Code :
    1
    2
    3
    4
    5
    template <class T>
    constrexpr T pow(const T t, const unsigned int n)
    {
        return n ? t*pow(t, n - 1): 1;
    }
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  11. #51
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut

    Un 'r' en trop à "constrexpr" dans mon message précédent.

    --------------------

    Le type sous-jacent des énumérations

    Les énumérations sont converties à la compilation vers un type entier. Par défaut ce type est celui du plus petit type entier signé capable de contenir toutes les valeurs de l'énumération.

    Afin de forcer ce type à int, il était d'usage d'ajouter cette valeur inutile :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    enum MY_INT_ENUM
    {
        Nord,
        Sud,
        Ouest,
        Est,
        MY_INT_ENUM_FORCE_32BITS = 0xffffffff;
    };
    Le C++11 introduit la définition explicite du type sous-jacent. Ainsi, il est possible de choisir le type sous-jacent à ses énumérations, ce qui offre de plus la possibilité d'utiliser des types non-signés :

    Code :
    1
    2
    3
    4
    5
    6
    7
    enum MY_USHORT_ENUM : unsigned short
    {
        Nord,
        Sud,
        Ouest,
        Est,
    };
    Ceci se marie tout à fait avec les énumérations fortement typées :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    enum class Direction : unsigned short
    {
        Nord,
        Sud,
        Ouest,
        Est,
    };
     
    Direction directionDuSoleil = Sud;
    Il est garanti que sizeof(directionDuSoleil) == sizeof(unsigned short).

    La programmation générique n'est pas en reste avec cette nouvelle fonctionnalité, puisque le header <type_traits> fournit le trait std::underlying_type qui permet de récupérer le type sous-jacent de l'énumération :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include <type_traits>
     
    enum class Vase : unsigned int
    {
        PleinDeFuites = 0;
        BonEtat = 1;
    };
     
     
    template <class T>
    std::underlying_type<T> remplir(T etat, std::underlying_type<T> remplissage)
    {
        return static_cast<std::underlying_type<T>>(etat)*remplissage;
    }
     
    //[...]
     
    if(remplir(Vase::PleinDeFuites, 90) == 0)
        std::cout << "Je vous l'avais dit, c'est pas avec ça qu'on éteindra un incendie !" << std::endl;
    ---------------
    Remarques bienvenues.
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  12. #52
    Inactif


    Homme Profil pro Guillaume Belz
    Biochimiste
    Inscrit en
    novembre 2008
    Messages
    5 318
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume Belz
    Âge : 38
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Biochimiste
    Secteur : Santé

    Informations forums :
    Inscription : novembre 2008
    Messages : 5 318
    Points : 17 319
    Points
    17 319

    Par défaut

    Ajouté l'exemple sur constexpr et les enums, avec quelques corrections :
    - j'ai changer les noms de variables de pow, que ça soit similaire à la fonction std::pow
    - j'ai ajouté la version avec template récursif pour pow
    - j'ai retiré le template de la fonction constexpr pour que la distinction soit plus nette avec la version avec template (même si bien sur, il faudrait utiliser les template... voir utiliser common_type)
    - pour le dernier exemple des enum class avec sizeof, j'ai utilisé le code de cppreference, le tiens me semblait moins claire (en fait, il faudrait même faire comme pour l'exemple sur les constexpr, avoir un code copié-collable-compilable)
    - il manque un petit texte pour la porté des enum class vs les enums

    Merci

  13. #53
    Expert Confirmé

    Avatar de germinolegrand
    Homme Profil pro Germino Legrand
    Développeur de jeux vidéo
    Inscrit en
    octobre 2010
    Messages
    731
    Détails du profil
    Informations personnelles :
    Nom : Homme Germino Legrand
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : octobre 2010
    Messages : 731
    Points : 3 940
    Points
    3 940

    Par défaut

    Typo :
    Les chaînes littérales sont concaténées que si elles ont le même préfixe ou que l'une des deux chaînes n'a pas de préfixe :
    => soit virer le "que" soit rajouter un "ne"
    Choisis un travail que tu aimes et tu n'auras pas à travailler un seul jour de ta vie.

    N'oubliez pas de marquer votre sujet comme et de mettre des aux messages apportant un plus à votre discussion.

    Si vous souhaitez participer à la rubrique C++, ne me contactez plus !

  14. #54
    Inactif


    Homme Profil pro Guillaume Belz
    Biochimiste
    Inscrit en
    novembre 2008
    Messages
    5 318
    Détails du profil
    Informations personnelles :
    Nom : Homme Guillaume Belz
    Âge : 38
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Biochimiste
    Secteur : Santé

    Informations forums :
    Inscription : novembre 2008
    Messages : 5 318
    Points : 17 319
    Points
    17 319

    Par défaut

    Ajout d'une petite note pour gcc 4.8 sur les premières nouvelles fonctionnalités implémentées : GCC 4.8. Cela sera détaillé par la suite

  15. #55
    Membre éclairé
    Profil pro
    Inscrit en
    août 2008
    Messages
    331
    Détails du profil
    Informations personnelles :
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : août 2008
    Messages : 331
    Points : 311
    Points
    311

    Par défaut

    GCC 4.8 vient de sortir.

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
  •