//C++ Operators

//  Operators specify an evaluation to be performed on one of the following:

//    One operand (unary operator)

//    Two operands (binary operator)

//    Three operands (ternary operator)

//  The C++ language includes all C operators and adds several new operators.

//  Table 1.1 lists the operators available in Microsoft C++.

//  Operators follow a strict precedence which defines the evaluation order of

//expressions containing these operators.  Operators associate with either the

//expression on their left or the expression on their right;    this is called

//“associativity.” Operators in the same group have equal precedence and are

//evaluated left to right in an expression unless explicitly forced by a pair of

//parentheses, ( ).

//  Table 1.1 shows the precedence and associativity of C++ operators

//  (from highest to lowest precedence).

//

//Table 1.1   C++ Operator Precedence and Associativity

// The highest precedence level is at the top of the table.

//+------------------+-----------------------------------------+---------------+

//| Operator         | Name or Meaning                         | Associativity |

//+------------------+-----------------------------------------+---------------+

//| ::               | Scope resolution                        | None          |

//| ::               | Global                                  | None          |

//| [ ]              | Array subscript                         | Left to right |

//| ( )              | Function call                           | Left to right |

//| ( )              | Conversion                              | None          |

//| .                | Member selection (object)               | Left to right |

//| ->               | Member selection (pointer)              | Left to right |

//| ++               | Postfix increment                       | None          |

//| --               | Postfix decrement                       | None          |

//| new              | Allocate object                         | None          |

//| delete           | Deallocate object                       | None          |

//| delete[ ]        | Deallocate object                       | None          |

//| ++               | Prefix increment                        | None          |

//| --               | Prefix decrement                        | None          |

//| *                | Dereference                             | None          |

//| &                | Address-of                              | None          |

//| +                | Unary plus                              | None          |

//| -                | Arithmetic negation (unary)             | None          |

//| !                | Logical NOT                             | None          |

//| ~                | Bitwise complement                      | None          |

//| sizeof           | Size of object                          | None          |

//| sizeof ( )       | Size of type                            | None          |

//| typeid( )        | type name                               | None          |

//| (type)           | Type cast (conversion)                  | Right to left |

//| const_cast       | Type cast (conversion)                  | None          |

//| dynamic_cast     | Type cast (conversion)                  | None          |

//| reinterpret_cast | Type cast (conversion)                  | None          |

//| static_cast      | Type cast (conversion)                  | None          |

//| .*               | Apply pointer to class member (objects) | Left to right |

//| ->*              | Dereference pointer to class member     | Left to right |

//| *                | Multiplication                          | Left to right |

//| /                | Division                                | Left to right |

//| %                | Remainder (modulus)                     | Left to right |

//| +                | Addition                                | Left to right |

//| -                | Subtraction                             | Left to right |

//| <<               | Left shift                              | Left to right |

//| >>               | Right shift                             | Left to right |

//| <                | Less than                               | Left to right |

//| >                | Greater than                            | Left to right |

//| <=               | Less than or equal to                   | Left to right |

//| >=               | Greater than or equal to                | Left to right |

//| ==               | Equality                                | Left to right |

//| !=               | Inequality                              | Left to right |

//| &                | Bitwise AND                             | Left to right |

//| ^                | Bitwise exclusive OR                    | Left to right |

//| |                | Bitwise OR                              | Left to right |

//| &&               | Logical AND                             | Left to right |

//| ||               | Logical OR                              | Left to right |

//| e1?e2:e3         | Conditional                             | Right to left |

//| =                | Assignment                              | Right to left |

//| *=               | Multiplication assignment               | Right to left |

//| /=               | Division assignment                     | Right to left |

//| %=               | Modulus assignment                      | Right to left |

//| +=               | Addition assignment                     | Right to left |

//| -=               | Subtraction assignment                  | Right to left |

//| <<=              | Left-shift assignment                   | Right to left |

//| >>=              | Right-shift assignment                  | Right to left |

//| &=               | Bitwise AND assignment                  | Right to left |

//| |=               | Bitwise inclusive OR assignment         | Right to left |

//| ^=               | Bitwise exclusive OR assignment         | Right to left |

//| ,                | Comma                                   | Left to right |

//+------------------+-----------------------------------------+---------------+

namespace for_eachFun

{

	template<class T>

	class AddValue

	{

	public:

		AddValue(const T &t):theValue(t) {}

		//适用于for_each算法的仿函数

		void operator() (T &elem)  //我这个是带参的仿函数，完全可以不带参像你说的那样

		{

			elem += theValue;

		}

	private:

		T theValue;

	};

}