comment faire pour obtenir le nombre de bit d'un entier a en C

what?

par exemple 32 en base 10 s'écrit 10000 en base 2, ce qu ej evoudrais faire c'est entré a=14689753 en base 10 et que la fonction me donne le nombre de chiffre en base 2 de cet entier a

En comparant par rapport à la puissance de 2 la plus proche.

CHAR_BIT * sizeof int
oups, c'est la réponse au premier post

 
Oui et donc?

Il n'y a pas cette formule qui donne le nombre de chiffres d'une nombre m dans une base n : ln(m)/ln(n)+1 ?

J'aurais du quoter, je répondais à son second post en fait, pas au tiens

désolé

si tu peux éviter de sortir 2 ln, et que tu fais le truc simple avec des >> & c'est mieux non ? voire sans boucle ou carrément si ton processeur a ça avec un cntlwz

 
jai fais ca comme ca c a verifier

Là tu comptes le nombre de bits à 1 dans c, pas le nombre de chiffres dans la représentation binaire.

Sans les mains, celà donne...

???

 
ltoa() , c'est pas fait pour les chiens...

itoa c'est pas standard.

log2 par extraction - non portable - de l'exposant - du flottant correspondant - qui se trouve être "le nombre de chiffre en base 2 de cet entier", bit de signe non compris.

ça j'avais cru comprendre, mais je ne vois aucun intérêt à cette méthode ...

C'est pourtant évident: O(1) , pas de table, pas de boucle, un minimum d'operations (load/store/shift/add) et nul besoin de se battre avec l'asm inline (ou les builtins spécifiques à chaque compilo) pour taquiner le bsr ou équivalent. Le tout est vectorisable.
 
Note: il y a d'autre façon de détourner les flottants pour le même résultat.  

La taille d'un entier étant fixe y'a pas franchement de raison de parler de complexité

Voilà voilà. Je saisis mal ce fétichisme pour les boucles, qui n'est justifiable ni par la vitesse d'exécution ni la concision mais si c'est votre truc qui suis-je pour juger. Surtout, on a vu chose plus intéressante à débattre.

Ca, c'est vrai que dans les langages pour pervers psychopathes genre le C

 
Ça tombe bien c'est un topic C

non pas du tout, il répond exactement à la question posée : il compte le nombre de bits significatifs.
 
attention toutefois, pour un nombre négatif, la valeur sera toujours de sizeof(var) * 8 (il faudra penser à faire un Abs() avant)
 
sinon, je suppose que le but du jeu ici, c'est, à partir d'un nombre de taille inconnue (par exemple, une saisie utilisateur) stocké dans une variable de grande taille, de détecter le plus petit type possible pour le stocker non ?
 
en C, je ne sais pas s'il y a des constantes "MIN" et "MAX" pour un type donné.
 
Mettons ici le code C#, à traduire selon les besoins (quitte à mettre les constantes en dur, de toute façon elles sont normalement figées) :
 

Int64 nbr = 1234567890; // Nombre saisi par l'utilisateur
 
if (Math.Abs(nbr) > (Int64)Int32.MaxValue)
{
    Console.WriteLine("On peut représenter ce nombre en 64 bits" );
}
else if (Math.Abs(nbr) > (Int64)Int16.MaxValue)
{
    Console.WriteLine("On peut représenter ce nombre en 32 bits" );
}
else if (Math.Abs(nbr) > (Int64)byte.MaxValue)
{
    Console.WriteLine("On peut représenter ce nombre en 16 bits" );
}
else
{
    Console.WriteLine("On peut représenter ce nombre en 8 bits" );
}

Ben non, il ajoute c&1 au lieu de 1. Donc il compte le nombre de bits à 1.

Ah oui effectivement.
Je suis pas habitué aux notations C à la con Il faut faire ++ et non coller le résultat d'un masque

Parcequ'en C# y'a pas de & ptêtre ?

c'est pas parceque C# a hérité d'une tétrachiée de conneries issues du C que je les utilise

 
Ouaip t'as raison. Il y a des dizaines de programmeurs qui se sont cassés le cul à introduire des outils en C comme la manipulation d'adresses, de bits ou autres hyper sympas (évidemment faut avoir un peu de jugeotte quand on les utilise) et voilà comment on les traite. Retourne au COBOL...

ca aussi ca marche...c'est même plus rapide.
 

Je n'arrive pas à trouver le principe mathématique qui a donné cet algo. Par ailleurs, je pense qu'il ne correspond pas à la question initiale
En effet, si on le déroule "à la main" sur le nombre 10 (1010 en binaire), alors on obtient ceci
- itération 1: i=i & (i - 1) => i= 1010 & 1001 = 1000 et nb passe à 1
- itération 2: i=i & (i - 1) => i= 1000 & 0111 = 0000 et nb passe à 2
i vaut 0 => fin de boucle => nb final vaut 2
 
Apparemment, cet algo te donne le nombre de bits à 1 d'un nombre (j'ai testé avec 11 et avec 6) mais le sujet initial était "avoir le nombre de bits total". Ceci dit, il est quand-même joli...

Allez, je participe aussi

Ne marche pas pour x = 0 .