请问为什么有->*运算符，而没有->&运算符

2015-10-22 02:24:20 179 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

srxumin 墨衍会员 · AI 创作全网分发关注 + 加入社区

mysql数据库之运算符 mysql运算符阅读详情

如题：*和&是相反的运算符呀

...全文

C++重载运算符本文主要介绍：结构体中重载运算符、类重载运算符以及容器排序重载运算符。 1、结构体重载运算符typedef struct tagSaveImgFile { tagSaveImgFile &operator = (tagSaveImgFile &other) //放在结构体内部 { m_scale = other.m_scale; m_imgPath 阅读详情

srxumin

C++ 语言 65,214 成员 250,514 内容

+ 关注 + 加入社区

切换为时间正序

赵4老师 2015-10-23

打赏
举报

《深度探索C++对象模型》《C++反汇编与逆向分析技术揭秘》

fefe82 2015-10-23

打赏
举报

引用 3 楼 srxumin 的回复:

TO 赵老师：我知道没有->&运算符的，我只是想知道为什么没有，谢谢了。 TO Saleayas：为什么用&号时&Class::Member就放在前面，而用*号时Class->*Member就放在后面？你不觉得对于一个初学者，很容易在记忆上造成混乱吗？既然容易造成混乱，C++的创始人肯定也知道的，所以想我知道它们宁愿造成混乱也要把*号放在中间的原因

指向成员的指针与普通指针有一个很大的不同，就是他解引用的时候需要两个操作数（一个是指向成员的指针，另一个是类的实例），而普通指针值只需要一个（即指针本身）。于是出现了 ->* 与 .* 来在左侧提供类的实例，右边放指向成员指针。但是取地址的时候，无论指向成员的指针还是普通指针，都只需要一个操作数。于是大家共用了 & 操作符。

fly_dragon_fly 2015-10-23

打赏
举报

C++这么多年了, 也许连创始人也不记得当年发生了什么, 现在找一个说法与当时可能已经相差甚远. 我提种说法, 觉得可以就信之, 不可以再看其它人的解释取成员地址,不需要实例, 比如class A{ public: void fun(){} }; 可以直接&A::fun, 如果要写成->&的形式, 就需要A*pa, pa->&才行, 直接A->这种语法也没有

ipqtjmqj 2015-10-23

打赏
举报

为什么只有->*和.*呢, 很好理解, 因为 ->和.原来后面跟的都是具体相对地址的变量, 而不是指针. *运算符通常后面跟个指针, 返回指向的变量, 这与->和.的要求相符. &运算符通常后面跟个变量, 返回内容为该变量地址的指针, 这与-和.的要求不符.

srxumin 2015-10-22

打赏
举报

TO 赵老师：我知道没有->&运算符的，我只是想知道为什么没有，谢谢了。 TO Saleayas：为什么用&号时&Class::Member就放在前面，而用*号时Class->*Member就放在后面？你不觉得对于一个初学者，很容易在记忆上造成混乱吗？既然容易造成混乱，C++的创始人肯定也知道的，所以想我知道它们宁愿造成混乱也要把*号放在中间的原因

赵4老师 2015-10-22

打赏
举报

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

Saleayas 2015-10-22

打赏
举报

&Class::Member

请问为什么有->*运算符，而没有->&运算符

相关推荐