== 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.

= is an assignment operator in C. According to C99 6.5.16:

An assignment operator stores a value in the object designated by the left operand. An assignment expression has the value of the left operand after the assignment, but is not an lvalue.

It means that expression a = 5 will return 5 and therefore instructions inside if block will be executed. In contrary, if you replaced it with a = 0 then 0 would be returned by assignment expression and instructions inside if would not be executed.

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:

Copyx += y;

it's equivalent to

Copyx = x + y;

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

If you write:

Copyx =+ y;

then it's parsed as

Copyx = + 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".)