#define MSB (~(~0U >> 1))

int lrotate(int x)
{
    return (x << 1) | !!(x & MSB);
}

int rrotate(int x)
{
    return ((unsigned)x >> 1) | ((x & 01) ? MSB : 0);
}

これは別の方法です。

int int_bits(void)
{
    int i = 0, x = ~0;
    while (x)
        i++, x <<= 1;
    return i;
}

int lrotate(int x)
{
    return (x << 1) | ((unsigned)x >> (int_bits() - 1));
}

int rrotate(int x)
{
    return ((unsigned)x >> 1) | (x << (int_bits() - 1));
}

> これは別の方法です。
> 
> int int_bits(void)
> {
>     int i = 0, x = ~0;
>     while (x)
>         i++, x <<= 1;
>     return i;
> }

#include <limits.h>

#define N  (sizeof(int) * CHAR_BIT - 1)

int lrotate(int x) { return (unsigned)x>>N | x<<1; }

int rrotate(int x) { return (unsigned)x>>1 | x<<N; }

>int のビット数はヘッダファイル <limits.h> に書かれている
>CHAR_BIT と sizeof(int) の積で、コンパイル時に分かるのに、
>実行時に毎回計算し直しているのはなぜですか。

以前別の掲示板で教えていただいたのですが、int のビット数は char の
ビット数の整数倍とは限らないらしいのです。このページを教えてもらい
ました。(int が16ビット未満という点はおかしいんですけど。)

    http://www.bohyoh.com/CandCPP/FAQ/FAQ00018.html

このようなやり方で int のビット数をわざわざ計算しているのを、本など
でもたまに見かけます。

>また、x = 1;でいいはずなのに、わざわざ x = ~0; としているのはなぜですか。
>初心者の勉強のためでしょうか。

x = 1 でも良いということには気が付いていませんでしたが、x = ~0 よりも
x = 1 の方が良いと考える理由は何でしょう。

>int i = 0, x = ~0;
>while (x)
>    i++, x <<= 1;

私はこんなふうに考えています。
「x = ~0 で int 型オブジェクトのビットを全部セットし、x <<= 1 で一つ消
すと同時に i++ でその消した分をカウントする。全部消えたらループを出る。」

>私はこんなふうに考えています。
>「x = ~0 で int 型オブジェクトのビットを全部セットし、x <<= 1 で一つ消
>すと同時に i++ でその消した分をカウントする。全部消えたらループを出る。」

いや、正確に言うとこれを書いたときは、この通りには考えていなかったと思い
ます。本当にこう考えていたなら、i++, x <<= 1; ではなく、x <<= 1, i++ と
書いていたと思います。どうでもいいと言われそうですが。

>> 以前別の掲示板で教えていただいたのですが、int のビット数は char の
>> ビット数の整数倍とは限らないらしいのです。このページを教えてもらい
>> ました。(int が16ビット未満という点はおかしいんですけど。)
>> 
>> http://www.bohyoh.com/CandCPP/FAQ/FAQ00018.html
>
>それは、規格に従っていない C のことでしょう。
>
>規格に従えば、int のビット数は char のビット数の整数倍です。
>ANSI の 1.6 Definitions of Terms (JIS なら 3.用語の定義及び規約) の
>ところに、ビット、バイト、オブジェクトの定義があり、ビットフィールド
>以外のオブジェクトは、1バイト以上が連続するものとなっています。

いいえ。オブジェクトの最小単位はバイトですが、オブジェクトを構成する
すべてのビットが値を表現するために使われているとは限らないようです。
つまり、オブジェクトはその中に padding bits をもっても良いということ
です。こちらを読んでみてください。

    http://dbforums.com/t583479.html

>> x = 1 でも良いということには気が付いていませんでしたが、x = ~0 よりも
>> x = 1 の方が良いと考える理由は何でしょう。
>
>左シフトで、最初の x の LSB 以外のビットが捨てられ、最後に LSB が
>消えたことを判定して、ビット数を数えるのだから、

私はそのようには考えていません。立てたビットを集合の要素(~0は空集合の
補集合)と考え、右端の要素を消しながら 1、2、3... と要素数を数えている
つもりです。

>捨てられるビットをわざわざ 1 にする必要はありませんね。 x = 1; で 十分であり、
>x = ~0; はちょっとひっかかるという程度のことです。

x = ~0 でも x = 1 でも効率は同じですよね。すべてのビットをセットするのに
手間はかからないので、「わざわざ」といわれると考え込んでしまいます。プロ
グラムの見方(どのような方法で数えていると見るか)によってそう感じるのでし
ょうか。かずまさんはビットが置かれるべき「場所」を数えていると考えている
(?)のに対し私は「ビットそのもの」を数えていると考えている、と。私の考え
は不自然でしょうか。

int int_bits(void)
{
    int i = 0, x = ~0;

    while (x) {
        if (x & 0x80000000) i++;
        x <<= 1;
    }
    return i;
}

>面白いページを紹介していただき、ありがとうございました。
>
>しかし、ここでの議論は、型の持つビット数と、値の表現に必要なビット数を
>混同しているように、私には読めました。
>
>long型が 32 ビットでも、1ビットは符号ビットだから、31ビットが値を表現する
>もので、sizeof(long) * CHAR_BIT では、その 31 が求められないと言っている
>ようです。

明らかに読み間違いをされていると思います。下に訳してみました。

------- John ------------------------------------------------------------

int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
Is this a portable way to find out how many bits are in a given type?

これは与えられた型の中にいくつのビットがあるかを調べる可搬性のある方法
でしょうか？

------- Kevin Easton ----------------------------------------------------
John wrote:
  > int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
  > 
  > Is this a portable way to find out how many bits are in a given type?

Yes. However, this number is almost useless, because it may include
padding bits, so you can't necessarily extrapolate from the number of
bits to the range of the type.

はい、そうです。でもこの数字はたいてい役に立ちません。なぜなら、パディン
グビットを含んでいるかもしれないからです。だからあなたは必ずしもその数字
からその型(で表現できる値)の範囲を外挿(既知の数字などから未知の数字を推定
すること)する事は出来ません。

------- Emmanuel Delahaye -----------------------------------------------
In 'comp.lang.c', "John" wrote:

  > int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
  > 
  > Is this a portable way to find out how many bits are in a given type?

No. Only a char is both defined in number of bits and by a range. All the 
other types are only defined by a range in for integer and in 
for floating points.

いいえ、ちがいます。char型だけがビット数と範囲の両方で定義されています。
その他のすべての型は範囲でのみ定義されています。(in for の訳し方がわから
ないので in for 以降を無視した。)

------- Rjh -------------------------------------------------------------

John wrote:

  > int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
  > 
  > Is this a portable way to find out how many bits are in a given type?

Not quite. :-(

size_t bits = sizeof(long) * CHAR_BIT is better, *but* it doesn't mean quite 
what you might think. It will give you the right number of bits, but this 
will include not only the value bits, but also the sign bit (in the case of 
types where this is meaningful) and any padding bits that the 
implementation might choose to incorporate into the type.

完全に可搬性があるわけではありません。

size_t bits = sizeof(long) * CHAR_BITとした方がもっと良いですが、でもこれは
必ずしもあなたが期待しているものを意味しません。この式はビットの正しい個数を
与えますが、それは値の表現に使われるビットだけでなく、符号ビット(符号が意味
をもつ型の場合)や処理系がその型に組み入れたパディングビットを含むかもしれま
せん。

------- Christian Bau ----------------------------------------------------
In article ,
"John" wrote:

  > int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
  > 
  > Is this a portable way to find out how many bits are in a given type?

There are degrees of portability. It will give the correct answer on 
many C implementations, but not on all. 

可搬性には程度があります。その方法は多くのCの処理系で正しい答えを与える
でしょう。でもすべての処理系ではありません。

There is for example one DSP processor that has 40 bit long which is 
stored in 64 bits. Variable "bits" will be 64, but only 40 bits can be 
used. 

例えば64ビットの中に収納された40ビットのlong型をもつDSPプロセッサがあり
ます。変数のビット数は64なのでしょう、でも40ビットだけが使用可能です。

And very hypothetically, you could have a C implementation with 16 bit 
int and 32768 bit long :-)

また、非常に仮定的な話ですが、16ビットのintと32768ビットのlongをもつCの
処理系もありえます。:-)

--- 続きがあります ---

続きです

------- Dan Pop↓ -------------------------------------------------------
In Emmanuel Delahaye writes:

  >In 'comp.lang.c', "John" wrote:
     >> int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
     >> 
     >> Is this a portable way to find out how many bits are in a given type?
  >No. Only a char is both defined in number of bits and by a range.

Nope, it is unsigned char that has this property. Plain char may have
padding bits, like any other type.

うんにゃ。この属性をもつのは unsigned char です。'単なるchar'は他のすべての型
と同じく、パディングビットをもつかもしれません。

------- Dan Pop↓ ------------------------------------------------------------
In rjh writes:

  >John wrote:
     >> int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
     >> 
     >> Is this a portable way to find out how many bits are in a given type?
  >Not quite. :-(
  >size_t bits = sizeof(long) * CHAR_BIT is better,

Or worse, depending on the relationship between INT_MAX and (size_t)-1 :-)
In practice, neither is better or worse than the other.

より悪いともいえます。INT_MAX と (size_t)-1 の関係次第では。:-)
実際には、どちらがどちらより良くも悪くもありません。

-------  Dan Pop↓ ----------------------------------------------------------
In "John" writes:

  >int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
  >Is this a portable way to find out how many bits are in a given type?

It is a portable method of obtaining the size in bits of a type.

その方法は型のビット単位のサイズを得るための可搬性のある方法です。

However, this value is not particularly useful, because you have no
guarantee that all the bits contribute to the actual value (well, in
your particular example you have, because a long can't have less than
31 value bits and one sign bit).

しかし、その値は特に役に立つ値ではありません。なぜなら、そのすべての
ビットが本当の値に対して貢献しているという保証はないからです(ところで、
あなたが示した特別な例ではこの保証があります。なぜならlong型は31ビット
と符号の1ビットより少ないビット数を持つことはありえないからです)。

Besides value bits and sign bit, you can also have padding bits, which 
you can count, but you cannot directly access (you must alias your long
with an array of unsigned char to get at them). You can figure out the
number of padding bits by computing the number of value bits (from
LONG_MAX, defined in ). Just subtract this number and one
for the sign bit from sizeof(long) * CHAR_BIT.

値のビットと符号ビットに加えて、パディングビットがあるかもしれません。そ
のパディングビットの数を数えることはできますが、それに直接アクセスするこ
とは出来ません(アクセスする為には long を unsigned char の配列でaliasしな
ければならない)。あなたは値のビット数を(LONG_MAXを使って)計算することによ
ってパディングビットの数を求めることが出来ます。値のビット数と符号ビット
分の1を sizeof(long) * CHAR_BIT から引くだけです。

Note that, in practice, hosted implementations using padding bits
are few and far between.

実際のところ、パディングビットを使っているホスト処理系はわずだという
ことに注意してください。

comp.lang.c の問題のスレッドの記事を読んで考えてみると、int のビット
数は sizeof(int) * CHAR_BIT の値と等しく、次の式で表せるということに
なると思います。[]は無いかもしれないという事を表しています。

intのビット数 = [パディングビット] + 1ビットの符号ビット + 値のビット

私は「int のビット数は char のビット数の整数倍とは限らない」と書きま
したが、この部分は正確にいうと間違っているので訂正させてください。
「int型がもっているビット数のうち実際に使用されるビット数は CHAR_BIT
 の整数倍であるとは限らない」とすべきでした。

>その前にもう一度問題を整理してみます。
>まず、発端はローテートですが、これについては置いておいて、
>int 型のビット数をどうやって知るかという問題に焦点を当てます。
>配列や構造体を含む一般の型についてではありません。int型についてです。

>(1) #include <limits.h> で、sizeof(int) * CHAR_BIT
>(2) int_bits() という関数を用意する。

この問題の整理の仕方には不満があります。int 型のビット数をどうやって知
るかということなら、(1)で良いのでしょう。でも問題は int 型の「正味の」
ビット数のはずです。ローテート関数が正しく動作するためには正味のビット
数が必要なのですから。私は下のかずまさんのローテート関数が、どの規格準
拠の処理系においてでも、期待する結果を返すかどうかが問題だと考えていま
す。

>#include <limits.h>
>#define N  (sizeof(int) * CHAR_BIT - 1)
>int lrotate(int x) { return (unsigned)x>>N | x<<1; }
>int rrotate(int x) { return (unsigned)x>>1 | x<<N; }

言い換えるとこうです。

すべての規格準拠の処理系について sizeof(int) * CHAR_BIT の値は、私の
int_bits 関数が返す値と等しいか?

私は「等しいとは限らない」、かずまさんは「等しい」、ですね？

>しかし、その根拠として挙げた
>http://www.bohyoh.com/CandCPP/FAQ/FAQ00018.html では、int が 12ビット
>の処理系という規格はずれのものに対応しようとしています。

例として12という数字を使っている点は明らかにまずいですね。また、「int型
が12ビットである処理系」という所も「int型が実際に使用するビットが12ビッ
トである処理系」としないと正確ではないのでしょう。でも規格はずれのものに
対応しようとしている、という見方以外に単に例として使う数字や表現を間違え
ただけという見方もできます。

>次に、http://dbforums.com/t583479.html ですが、最初の質問、
------- John ------------------------------------------------------------
>int bits = sizeof(long) * CHAR_BIT; /* 32 on my system */
>Is this a portable way to find out how many bits are in a given type?

>ここで、John は、long を例に挙げ、a given type という一般の型のサイズに
>ついて、そのビット数の数え方がこれでいいのか尋ねています。

>この時点で、int 型のビット数を数えることから離れているので、その後の議論は
>(1)か (2)かという問題には関係ありません。

意味がわかりません。このスレッドの中で頻繁に出てくる 「padding bits」の意味
を説明して下さい。まさかこの言葉が構造体のパディングのことのみを指していると
でもお考えですか？