C quick calculation of next multiple of 4?

What's a fast way to round up an unsigned int to a multiple of 4?

A multiple of 4 has the two least significant bits 0, right? So I could mask them out and then do a switch statement, adding either 1,2 or 3 to the given uint.

That's not a very elegant solution..

There's also the arithmetic roundup:

 myint == 0 ? 0 : ((myint+3)/4)*4

Probably there's 开发者_运维问答a better way including some bit operations?

---

(myint + 3) & ~0x03

The addition of 3 is so that the next multiple of 4 becomes previous multiple of 4, which is produced by a modulo operation, doable by masking since the divisor is a power of 2.

---

I assume that what you are trying to achieve is the alignment of the input number, i.e. if the original number is already a multiple of 4, then it doesn't need to be changed. However, this is not clear from your question. Maybe you want next multiple even when the original number is already a multiple? Please, clarify.

In order to align an arbitrary non-negative number i on an arbitrary boundary n you just need to do

i = i / n * n;

But this will align it towards the negative infinity. In order to align it to the positive infinity, add n - 1 before peforming the alignment

i = (i + n - 1) / n * n;

This is already good enough for all intents and purposes. In your case it would be

i = (i + 3) / 4 * 4;

However, if you would prefer to to squeeze a few CPU clocks out of this, you might use the fact that the i / 4 * 4 can be replaced with a bit-twiddling i & ~0x3, giving you

i = (i + 3) & ~0x3;

although it wouldn't surprise me if modern compilers could figure out the latter by themselves.

---

If by "next multiple of 4" you mean the smallest multiple of 4 that is larger than your unsigned int value myint, then this will work:

(myint | 0x03) + 1;

---

(myint + 4) & 0xFFFC

---

If you want the next multiple of 4 strictly greater than myint, this solution will do (similar to previous posts):

(myint + 4) & ~3u

If you instead want to round up to the nearest multiple of 4 (leaving myint unchanged if it is a multiple of 4), this should work:

(0 == myint & 0x3) ? myint : ((myint + 4) & ~3u);

---

myint = (myint + 4) & 0xffffffc

This is assuming that by "next multiple of 4" that you are always moving upwards; i.e. 5 -> 8 and 4 -> 8.

---

This is branch-free, generally configurable, easy to understand (if you know about C byte strings), and it lets you avoid thinking about the bit size of myInt:

myInt += "\x00\x03\x02\x01"[myInt & 0x3];

Only downside is a possible single memory access to elsewhere (static string storage) than the stack.