这个是加载动态dll的强制转换。。

解决方案 »

  1.   

    //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 |
    //+------------------+-----------------------------------------+---------------+