Dst 8: Fill & Download for Free

Short answer: Use whichever one is clearest in the context.If you’re bit-fiddling, and by that I mean manipulating bitfields in a word, then shifts seem like a more natural fit. If you’re doing arithmetic, then expressing it as arithmetic seems like a more natural fit.With modern compilers on modern architectures, there’s generally no difference in performance. In fact, they’ll probably compile to identical code, but not always.For example, suppose I asked you to quadruple a number. Which of these makes that more obvious?int quadruple_1(int x) {  return x * 4; }  int quadruple_2(int x) {  return x << 2; } I think most folks would say the first one is clearer here. Compare compiler output here. They both compile to identical code.Now suppose I asked you to assemble this opcode: 9 8 6 5 3 2 0 +---+--------+--------+-------+ |dir| opcode | src1 | dst | +---+--------+--------+-------+ Which of these is clearer?unsigned assemble_1(unsigned dir, unsigned opcode,  unsigned src1, unsigned dst) {  return (dir % 2) * 512   + (opcode % 8) * 64  + (src1 % 8) * 8  + (dst % 8); }  unsigned assemble_2(unsigned dir, unsigned opcode,  unsigned src1, unsigned dst) {  return (dir & 1) << 9   | (opcode & 7) << 6  | (src1 & 7) << 3  | (dst & 7); } Here, I’d say the second one is clearer. This time, they don’t compile to identical code, at least on x86. I’d still prefer the second one.Also, some notes:If you’re bitfiddling, use unsigned data types. Shifting a signed value such that its sign bit might change is implementation defined at best, and undefined at worst. Shifting an unsigned value always has a well defined result, as long as the shift amount is less than the width of the data type.For right shifts vs. divides:Division rounds toward 0 as of C99. Furthermore, it’s implementation defined whether a right shift sign extends or zero extends with signed integers. Therefore, right shifts are not equivalent to dividing by powers of two for negative inputs. (-1)/2 == 0, while ((-1) >> 1) == -1 (but only if sign extension happens).“Round toward zero” affects modulo vs. bitmask as well. Modulo of a negative number returns a negative result.Punchline: If you’re using right shifts, you probably also want unsigned types, just like you did for left shifts.Bit-shift operators cannot be applied to floating point types. So if you’re writing generic code (templates) and you really wanted a multiply or a divide, use a multiply.

Data alignment restrictions often “byte” developers moving from x86 to any other processor. Also, alignment errorsOccur intermittently, depending on the address unaligned data gets storedPop up when a minor change in the code.May disappear when compiler optimization for performance is turned on.Most modern processors require int32 and float be aligned on 4-byte boundaries, and may require int64 and double be aligned on 8 byte boundaries. If you try to read/write an int32 from a non-aligned address the processor throws a processor exception.For historic reasons, x86 allows unaligned access (albeit with a serious performance penalty.)This usually causes a problem when deserializing data from a disk read or socket read. Below is an example that causes a Bus Error on Linux/ARM.void cause_data_exception() {   static const int N = 4;   int32_t src=42;  char dst[8];  int32_t* p;   int i;   for (i=0; i<N; i++)  {  memcpy(dst+i, &src, 4);  p = (int32_t*)(dst + i);  if (i % 4 == 0)  printf("This is safe %d\n", *p)  else   printf("This will blow up %d\n", *p);   }  } 

I have to preface this answer by, 1 - thanking Mr Lewis for saying what I’m thinking, and 2 - I’m totally flummoxed by the confusion in the rest of the country (except Hawaii) over what time it is in AZ! We don’t change our clocks, the rest of you do!Before I answer, one more thing. I assume you’re referring to TV listings, if not, than the answer will be different.The answer: it depends on what time of year it is. During DST, 8/7c would be 8 in AZ. During Standard Time, it be 7 in AZ. Did that confuse you? Well, it’s your own fault, you keep changing your clocks. No wonder you’re confused!