user-0 提问: 函数指针

回复:
user: user-1
content: 引用 14 楼 zhao4zhong1 的回复:理解和讨论之前请先学会如何观察！ 赵4老师跟赵四小姐是什么关系?

user: user-2
content: 理解和讨论之前请先学会如何观察！

user: user-2
content: 引用 10 楼 qq_28743877 的回复:赵4老师正解!!!

user: user-3
content: 引用 3 楼 qq423399099 的回复:通过函数指针调用函数不需要加星号  这个好像有一点不同，加与不加含义是不同的，我在调试的时候发现，如果不加p显示为一个变量，如果加上*p显示为一个函数，结果是一样的，但是这种情况仅仅出现在费成语痷函数的指针上，如果是成员函数的指针，结果又不一样了

user: user-2
content: 引用 15 楼 u010312274 的回复:[quote=引用 14 楼 zhao4zhong1 的回复:] 理解和讨论之前请先学会如何观察！ 赵4老师跟赵四小姐是什么关系?[/quote] 就是普通老师跟小姐的关系。

user: user-0
content: 引用 4楼paschen 的回复:函数指针解引了还是本身，所以你可以对函数指针一直解引，也可以不解引就直接调用函数什么是解引

user: user-0
content: 引用 3楼小灸舞 的回复:通过函数指针调用函数不需要加星号不加*就不是指针了啊

user: user-4
content: 函数指针解引了还是本身，所以你可以对函数指针一直解引，也可以不解引就直接调用函数

user: user-4
content: 引用 9 楼 user-7 的回复:[quote=引用 4 楼 paschen 的回复:] 函数指针解引了还是本身，所以你可以对函数指针一直解引，也可以不解引就直接调用函数  函数指针和函数还是不是一回事的。函数只是会自动转换成函数指针而已，所以可以一直解引用。  碰到不会转换的地方，比如 sizeof, typeid, template, ... ，就会发现他们的不同。[/quote]  嗯嗯，是我说的不准确，是函数可以一直转换成函数指针  而且指向成员函数的指针就不是这样了

user: user-5
content: 通过函数指针调用函数不需要加星号

user: user-1
content: 本来就是这样理解，有什么问题吗。 而且target[i] = (*p)(source[i]); 还可以省略*，写成target[i]=p(source[i]);

user: user-3
content: 函数指针指p向返回值类型为double并且接受一个double类型参数的的函数

user: user-6
content: 赵4老师正解!!!

user: user-7
content: 引用 4 楼 paschen 的回复:函数指针解引了还是本身，所以你可以对函数指针一直解引，也可以不解引就直接调用函数  函数指针和函数还是不是一回事的。函数只是会自动转换成函数指针而已，所以可以一直解引用。  碰到不会转换的地方，比如 sizeof, typeid, template, ... ，就会发现他们的不同。

user: user-2
content: //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 | //+------------------+-----------------------------------------+---------------+

user: user-2
content: 仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]