When does C++11 give warnings about operator precedence? - c++11

Question

When writing code, for a long time I knew that && has higher precedence than ||; however, compiling it using the C++11 standard gave me a warning that I should now use parentheses when using both in a single statement.
Now I got a warning that combining >> and + also should have parentheses. Now my statements look really ugly, with 5 or more parentheses floating around them.
1) Is there a resource that says which combinations of operators now require parentheses?
2) Is there a way to silence just the operator precedence warnings, but to keep the other warnings?
Compiler gcc with flags -O2 -Wall -g
The warnings came in when I added the flag -std=c++11
Sample expression:
(((string[0] << CHAR_BIT) + string[1] << CHAR_BIT) + string[2] << CHAR_BIT) + string[3];

Answer 1

When does C++11 give warnings about operator precedence?
The only case when the standard requires a diagnostic message (note that the standard does not distinguish between warnings and errors that halt the compilation) is when the program violates the standard. Except when the compiler is excempt from that with wording "no diagnostic required".
All other warnings are optional for the compiler and not required by the standard.
1) Is there a resource that says which combinations of operators now require parentheses?
No, because the parentheses are not required. The warning is just a suggestion by the compiler. The program is well-formed.
The warnings came in when I added the flag -std=c++11
For what it's worth, my GCC warns regardless of the standard argument.
2) Is there a way to silence just the operator precedence warnings, but to keep the other warnings?
The warning itself tells which warning option has enabled it (here is the warning from my GCC):
warning: suggest parentheses around '+' inside '<<' [-Wparentheses]
To disable, you can use the corresponding option to disable it: -Wno-WHATEVER.
Now my statements look really ugly, with 5 or more parentheses floating around them.
I recommend instead to extract the repetitive structure, and reuse a standard algorithm:
std::accumulate(string, string + 4, 0, [](auto sum, auto value) {
return (sum << CHAR_BIT) + value;
});
Much fewer parentheses :) Note that in C++11 (prior to C++14) you can not use auto as the type of an argument of a lambda. I don't know what types you use.

Answer 2

See the gcc manual:
-Wparentheses
Warn if parentheses are omitted in certain contexts, such as when there is an assignment in a context where a truth value is expected,
or when operators are nested whose precedence people often get
confused about.
Also warn if a comparison like x<=y<=z appears; this is equivalent to (x<=y ? 1 : 0) <= z, which is a different interpretation from that
of ordinary mathematical notation.
Also warn for dangerous uses of the GNU extension to ?: with omitted middle operand. When the condition in the ?: operator is a
boolean expression, the omitted value is always 1. Often programmers
expect it to be a value computed inside the conditional expression
instead.
(I added the emphasis)
To turn this behavior off, specify -Wno-parentheses to gcc/g++.