Se débarrasser du décalage gcc par avertissement négatif

Question

J'ai un code qui ressemble à:

template<unsigned int A, unsigned int B> 
int foo() { 
    int v = 1; 
    const int x = A - B; 
    if (x > 0) { 
    v = v << x; 
    } 
    bar(v); 
} 

gcc se plaindra de x étant négatif pour certaines instanciations de A, B; cependant, j'effectue une vérification pour m'assurer qu'il est non négatif. Quel est le meilleur moyen de contourner cela? Je sais que je peux lancer x pour être unsigned int mais cela entraînera des avertissements à propos de x étant plus grand que la largeur de v (puisqu'il émet un nombre négatif pour être positif). Je sais qu'il existe une solution de rechange qui consiste à créer une nouvelle fonction shift, mais je voudrais éviter cela si possible.

Answer 1

Depuis A et B sont connus au moment de la compilation, non seulement pouvez-vous vous débarrasser de votre avertissement, mais vous pouvez également vous débarrasser d'une exécution if, sans moulages, comme ceci:

#include <iostream> 
using namespace std; 

template< unsigned int A, unsigned int B > 
struct my 
{ 
    template< bool P > 
    static void shift_if(int &); 

    template<> 
    static void shift_if<false>(int &) {} 

    template<> 
    static void shift_if<true>(int & v) { v <<= A - B; } 

    static void op(int & v) { shift_if< (A > B) >(v); } 
}; 

template< unsigned int A, unsigned int B > 
int foo() 
{ 
    int v = 1; 
    my< A, B >::op(v); 
    return v; 
} 

int main() { 
    cout << foo< 1, 3 >() << endl; 
    cout << foo< 3, 1 >() << endl; 
    cout << foo< 300, 1 >() << endl; 
    cout << foo< 25, 31 >() << endl; 
    return 0; 
} 

Answer 2

Est-ce que cela fonctionnerait?

const short unsigned int x = A - B; 

Il est couper beaucoup plus de bits que le besoin d'être coupé, mais si vos valeurs de A - B sont assez petits ...

Answer 3

pourquoi ne pas faire x type unsigned char et de le jeter ? vous n'avez sûrement pas besoin de changer plus de 255 bits?

const unsigned char x = static_cast<unsigned char>(A - B); 

ou peut-être utiliser le masquage pour faire en sorte que le changement est dans les limites comme celui-ci:

const unsigned int x = static_cast<unsigned int>(A - B) & 0x1f; // limit A-B to have a range of (0 - 31) 

EDIT:

en réponse au commentaire est ici une idée:

template<unsigned int A, unsigned int B> 
int foo() { 
    int v = 1; 
    const int x = A - B; 
    if (x > 0) { 
    v = v << (static_cast<unsigned int>(x) & 0x1f); 
    } 
    bar(v); 
} 

REMARQUE: vous pouvez remplacer 0x1f avec quelque chose comme: (CHAR_BIT * sizeof (T) - 1)

EDIT: en réponse au dernier commentaire, ce code ne délivre aucun avertissement avec la compilation: g ++ -W -Wall -ansi -pedantic test.cc -o Test

#include <iostream> 

template<unsigned int A, unsigned int B> 
int foo() { 
    int v = 1; 
    const int x = A - B; 
    if (x > 0) { 
    v = v << (static_cast<unsigned int>(x) & 0x1f); 
    } 
    return v; 
} 

int main() { 
    std::cout << foo<1, 3>() << std::endl; 
    std::cout << foo<3, 1>() << std::endl; 
    std::cout << foo<300, 1>() << std::endl; 
    std::cout << foo<25, 31>() << std::endl; 
}