user-0 提问: 指针强制转换问题 （int*)(char*)buffer

回复:
user: user-1
content: 类型转换 只是对内存解释的方式改变了而已

user: user-2
content: 计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） //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-0
content: 引用 10 楼 worldy 的回复:[quote=引用 8 楼 wenbei2006 的回复:] [quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗 [/quote]  对象怎么能直接转换成指针？（char*）应该是个重载运算[/quote]一语惊破梦中人，我再好好看下

user: user-3
content: 引用 8 楼 wenbei2006 的回复:[quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗 [/quote]  对象怎么能直接转换成指针？（char*）应该是个重载运算

user: user-4
content: cv::AutoBuffer<char> buffer; 楼主看看这个

user: user-0
content: 引用 1 楼 turingo 的回复:强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗

user: user-0
content: 引用 6 楼 worldy 的回复:cv::AutoBuffer<char> buffer;//char类型的模板类 int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer;//(char*)应该是一个模板类的运算符，用于将模板类对象转换为类型指针（char*），然后再讲char*转换为int*  有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？ 直接强制转换成int型指针和这样转换有什么区别呢？我的意思是 mag_buf[0] = (int*)(char*)buffer和 mag_buf[0] = (int*)buffer 的区别是什么？

user: user-0
content: 引用 4 楼 AnYidan 的回复:[quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote]  站在不同的角度看同样的object[/quote] 看了一下，果然是  引用 11 楼 wenbei2006 的回复:[quote=引用 10 楼 worldy 的回复:] [quote=引用 8 楼 wenbei2006 的回复:] [quote=引用 1 楼 turingo 的回复:] 强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote] mag_buf[0] = (int*)(char*)buffer;这个为什么要先强制转换char* 然后再转换成int*，直接转到int*不行吗 [/quote]  对象怎么能直接转换成指针？（char*）应该是个重载运算[/quote]一语惊破梦中人，我再好好看下[/quote]  我看了一下cv::AutoBuffer<char> 的源码，果然是对指针强制转换进行了重载，厉害厉害，这样就明白了，分给你了

user: user-3
content: cv::AutoBuffer<char> buffer;//char类型的模板类 int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer;//(char*)应该是一个模板类的运算符，用于将模板类对象转换为类型指针（char*），然后再讲char*转换为int*  有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？

user: user-5
content: 强制转换的意义在于用一种不同的方法操作数据，前提是那个数据确实是可以那样操作的。 比如电视上有人能够吃玻璃，那就是因为他把玻璃强制转换成食物了，前提是他吃了不会有事。 这个比喻如何啊？

user: user-6
content: 引用 1 楼 turingo 的回复:强制转换在于buffer本身的地址不变，但是其意义改变了。  [quote=引用 楼主 wenbei2006 的回复:] 刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？[/quote]  站在不同的角度看同样的object

user: user-7
content: 目测这个操作是将 buffer这个容器作为mag_buf这个指针数组的一个元素 首先要获取buffer这个容器地址，因为容器是char型的，所以先获取一个char*即(char*)buffer 又因为要把它赋给mag_buf这个int*的变量，所以在强制转换一下 最终即 mag_buf[0] = (int*)(char*)buffer; 错了勿喷！！！

user: user-8
content: 未知类型 -> int* 不保证正确 未定义行为 还是 实现定义行为就记不清了  但是呢  任意类型 -> char* 有做保证 指向对象最低单元 另外  char* -> int* 依稀记得可能会造成 严格别名(Strict alias) 内存对齐 等问题 [就是说 如果能确保不会出现那些问题 那么 char* -> int* 就是安全的 ]

user: user-9
content: 强制转换在于buffer本身的地址不变，但是其意义改变了。  引用 楼主 wenbei2006 的回复:刚刚在看opencv源代码的cvcanny的时候，看到这样一段代码： cv::AutoBuffer<char> buffer; int* mag_buf[3]; mag_buf[0] = (int*)(char*)buffer; 有没有高手解释一下最后一行代码的意思是什么啊？指针这样强制转换的意义何在？