== is a test for equality. = is an assignment.

Any good C book should cover this (fairly early on in the book I would imagine).

For example:

int i = 3;                       // sets i to 3.
if (i == 3) printf("i is 3\n");  // prints it.

Just watch out for the heinous:

if (i = 4) { }

which is valid C and frequently catches people out. This actually assigns 4 to the variable i and uses that as the truth value in the if statement. This leads a lot of people to use the uglier but safer:

if (4 == i) {}

which, if you accidentally use = instead of ==, is a compile-time error rather than something that will bite you on the backside while your program is running :-)

The logical-or operator is two vertical bar characters, one after the other, not a single character. Here it is lined up with a logical-and, and a variable called b4:

||
&&
b4

No magic there.

Double quotes is for string and single quotes for character. But since you are using character in both of your samples then it doesnt make any difference. You can store character using double quotes but not the vice versa

The first operation is called bitwise OR | and it works as follows imagining the numbers A=200 and B=184, which in binary will be, 11001000 and 10111000, respectively. The operator "|" will compare bit a bit of each of those numbers, and returns 1 when either of the bits is 1, 0 otherwise. So in your case:

  11001000  
| 10111000 
  -------- 
= 11111000

the result will be 248 (11111000 in binary). Therefore DDRB |= 0b00000001; is DDRB = DDRB | 0b00000001.

The second operation (e.g., DDRB = 0b00000001) is just an assignment of a value to a variable.

In modern C, or even moderately ancient C, += is a compound assignment operator, and =+ is parsed as two separate tokens. = and +. Punctuation tokens are allowed to be adjacent.

So if you write:

x += y;

it's equivalent to

x = x + y;

except that x is only evaluated once (which can matter if it's a more complicated expression).

If you write:

x =+ y;

then it's parsed as

x = + y;

and the + is a unary plus operator.

Very early versions of C (around the mid 1970s, before the publication of K&R1 in 1978) used different symbols for compound assignments. Where modern C uses +=, early C used =+. Early C had no unary + operator, but it did have a unary - operator, and the use of =- caused problems; programmers would write x=-y intending it to mean x = -y, but it was silently interpreted as x =- y. The language was changed some time between 1975 and 1978 to avoid that problem. As late as 1999, I worked with a compiler (VAXC on VMS) that would warn about an ambiguous use of =-, but would use the older meaning. That shouldn't be a concern now unless you're a hobbyist playing with some very old software and/or hardware.

(A 1975 C Reference Manual shows the old =-, =+, et al forms of the compound assignment operators. The first edition of The C Programming Language by Kernighan and Ritchie, published in 1978, shows the modern -=, +=, et al, but mentions the older forms under "Anachronisms".)

In C, a == b == c is equivalent to (a == b) == c, where a == b yields 1 if true, 0 otherwise.

In your case, a == b is true, so a == b == c is equivalent to 1 == c, which is false.

You can further try it with:

printf("%d\n%d\n", 0 == 0, 0 == 1);

which gives the result:

1
0