[C++] Opérateur >>>

Résolu
Salam,

j'utilise l'opérateur de "Rotation à droite avec remplissage de zéros" >>>, en java aucun problème.
mais en C++ je rencontre l'erreur "expected primary-expression before '>' token" (je travail avec Code::Blocks 8.02)

Exemple:

int I=125;
int I2= I >>> 2 ;

Les autres opérateurs de rotation << et >> sont acceptés sauf celui là.

y a t il quelqu'un qui peut m'expliquer pourquoi???

l'opérateur existe vous pouvez le voir ici : https://www.commentcamarche.net/contents/191-langage-c-les-operateurs en bas de page

Merci d'avance
Configuration: Windows XP
Safari 525.19

9 réponses

  1. Re salut,

    Après test, >> et la division par 2 font ce que tu veux, mais uniqument sur les entiers non signés. Donc, le plus pratique est je pense de faire quelque chose du genre :

    int i= ... ;
    unsigned int ui = (unsigned int)(i); // transtypage explicite. Les bits de la variable sont recopiés tels quels, mais leur interprétation change
    int i2 = (int) (ui >> 2) // re transtypage dans l'autre sens de l'opération de décalage

    Si il est certain que i est positif, le transtypage n'est aps nécessaire, et il suffit de faire i2 = (i >> 2);
    2
    1. Salut,

      Aucune mention de cet opérateur dans la dernière édition du Stroustrup. A mon avis, ce n'est pas un truc standard...
      0
      1. merci, est ce qu'il y a une alternative.
        comment je peux réaliser la même opération sans cet opérateur???
        0
        1. Hmmm, si cette opération est un bête décalage, il te suffit de diviser par 2 ton entier autant de fois que tu veux dacaler les bits. (pour 2 bits, divises par 4, pour 3 bits par 8, etc.)

          donc, I2 = I / 4 dans ton cas.
          0
          1. En C, le décalage à droite ou à gauche est tout simplement et respectivement: >> et >>
            0
            1. << Rotation à gauche : Décale les bits vers la gauche (multiplie par 2 à chaque décalage). Les zéros qui sortent à gauche sont perdus, tandis que des zéros sont insérés à droite

              >> Rotation à droite avec conservation du signe : Décale les bits vers la droite (divise par 2 à chaque décalage). Les zéros qui sortent à droite sont perdus, tandis que le bit non nul de poids plus fort est recopié à gauche

              >>> Rotation à droite avec remplissage de zéros : Décale les bits vers la droite (divise par 2 à chaque décalage). Les zéros qui sortent à droite sont perdus, tandis que des zéros sont insérés à gauche

              Moi je cherche la dernière "avec remplissage de zéros"
              est ce que la division remplit cette tâche?
              0
              1. Merci, je vais essayer ça
                0
                1. En fait, ce que je voulais faire c'était de lire un entier octet par octet et le stocker de la même façon.
                  La version java du programme fait comme ceci:

                  write((byte)((I >>> 24) & 0xFF));
                  write((byte)((I >>> 16) & 0xFF));
                  write((byte)((I >>> 8) & 0xFF));
                  write((byte)((I >>> 0) & 0xFF));

                  Vous trouverez ce code dans la source de la classe RandomAccessFile.

                  Pour des raisons de compatibilité avec d'autres programmes (qui étaient réalisés en C++) je suis obligé de traduire mon programme en C++.

                  L'alternative qui marche jusqu'à maintenant est à peu prés celle proposée par Jamian (message 6).
                  et donc le codes est devenu:

                  write((char)(((long int) (I >> 0)) & 0xFF));
                  write((char)(((long int) (I >> 8)) & 0xFF));
                  write((char)(((long int) (I >> 16)) & 0xFF));
                  write((char)(((long int) (I >> 24)) & 0xFF));

                  I ici est un long int (4 octs)

                  Merci à vous tous

                  Allah mo3ine
                  0