Should compilers automatically translate operations into shortcuts?
First compilers may (and often will depending on the optimization level) do transformations far more complex than the one you describe.  You should not be concerned about the performance implication of the way you express the increment or the division before being sure that you are using a compiler for which it matters.

But there are some other implications.  Some are just stylistic (and here my recommendation is that you just follow what is the style of your organization, if you are in position to chose the style, chose one which suit you and don't second guess yourself about it every other week).  Other are semantic.

a += 1 and a++ are equivalent only if the context allows.  In C and C++, they are both expressions, and if the result of the expression is different (a += 1 is the incremented value; a++ is the non incremented value, ++a returns the incremented value).

a/8 and a&gt;&gt;3 are equivalent only if the value of a is positive or null.  For negative values, C and C++ the result is not determined by the C and C++ standards but left to the implementation(*).  The most common behavior gives the same result as a/8 for exact multiple of 8.  For negative values which are not a multiple of 8, a/8 has a result truncated towards 0 (i.e. -1/8 is 0) while a&gt;&gt;3 is truncated towards minus infinity (i.e. -1 &gt;&gt; 3 is -1).  You may know that the replacement is valid for your program but that is hard to determine for the compiler which will often not do the replacement or use a more complex one.



(*) Two reasons: the standards are defined in such a way that machines with ones' complement or sign and magnitude representation for signed values is possible and what is the natural result depend on the representation; some uncommon machines have only an unsigned shift.