ASM全部都是指针
对于从ASM学C的人来说，指针的确易于理解

对于习惯使用高级语言的人来说，用类用多了。

我还不是一样不习惯用类。

为什么要面向对象？

以前我一直不明白指针是啥意思．所以我放弃学Ｃ，一直用asm写程序，后来回过头看来，Ｃ的指针和asm也是一回事，自然而然就会Ｃ了。

szBuff db "test",0

szBuff就是一个指针。

所以存取其内容就这样addr szBuff

当然也可以 lea eax,szBuff把szBuff所指的内容存eax，这样就变成int了。

理解指针最好还是先从asm学起

楼主说用指针不觉得简单？

举个例子，比如你要取PROCESSENTRY32里的进程名，用指针的话，直接定义
Process PROCESSENTRY32<>，然后addr Process.szExeFile就完了。

不用指针，你怎么取捏？

指针？貌似效率不错

指针可以很好的避免内存的浪费

指针``挺不错的``

不过用错地址的话，不知会发生啥事``哦呵呵``

危险`

指针是个好东西

指针是最简单的概念，许多书都把他写复杂了，所谓的指针，就是该地址的内容指向另一个地方，就这么多。千万不要把问题想复杂了，本来是最简单的东西。
例如：
LPCSTR  typedef  DWORD
target  db  '这里是目标',0
lptar   LPCSTR  offset target  ;这个就是所谓的指针了
这个lptar就是指针了，什么都没有，不过里面放了一个地址而已，就这么简单的一个概念，弄死多少人，在高级语言中，很多时候还可以看到多层的指针，就是这个指针所指的地方还是指针，而还是指针的地方指的还是指针，就这么一层一层的套，没有什么复杂的问题。

世上本没有指针,只是这块内存可读,也就成了指针

指哪读哪啊，好东西，不过搞不好也容易出问题的。

指针可是个好东西,用上瘾了想不用都难.

void copymem(CHAR *P1,CHAR *P2,int size){
// 这样只要复制一次，只需要 4*3 开销
}

void copymem(CHAR p1[1024],p2[1024]){
//使用这种需要复制三次了，并且需要多开销 1024*2 的内容
}

指针是我们的敌人，同时，指针是我们的朋友！

[QUOTE=chken;299038]void copymem(CHAR *P1,CHAR *P2,int size){
// 这样只要复制一次，只需要 4*3 开销
}

void copymem(CHAR p1[1024],p2[1024]){
//使用这种需要复制三次了，并且需要多开销 1024*2 的内容
}[/QUOTE]

其实在C语言里即使参数定义成"CHAR p1[1024]",也只是传指针p1而已,不传数组里的值.

[QUOTE=dwing;299067]其实在C语言里即使参数定义成"CHAR p1[1024]",也只是传指针p1而已,不传数组里的值.[/QUOTE]

void copymem(CHAR p1[1024],CHAR p2[1024]){
        memcpy(p1,p2,sizeof(p1));
}

void main(){
        char buf1[1024],buf2[1024];
        copymem(buf1,buf2);
}

_TEXT        SEGMENT
_p1$ = 8                                                ; size = 4
_p2$ = 12                                                ; size = 4
?copymem@@YAXQAD0@Z PROC                                ; copymem

; 6    : void copymem(CHAR p1[1024],CHAR p2[1024]){

        push        ebp
        mov        ebp, esp

; 7    :         memcpy(p1,p2,sizeof(p1));

        push        4
        mov        eax, DWORD PTR _p2$[ebp]
        push        eax
        mov        ecx, DWORD PTR _p1$[ebp]
        push        ecx
        call        _memcpy
        add        esp, 12                                        ; 0000000cH

; 8    : }

        pop        ebp
        ret        0
?copymem@@YAXQAD0@Z ENDP                                ; copymem
_TEXT        ENDS
PUBLIC        _main
; Function compile flags: /Odtp
_TEXT        SEGMENT
_buf1$ = -2048                                                ; size = 1024
_buf2$ = -1024                                                ; size = 1024
_main        PROC

; 10   : void main(){

        push        ebp
        mov        ebp, esp
        sub        esp, 2048                                ; 00000800H

; 11   :         char buf1[1024],buf2[1024];
; 12   :         copymem(buf1,buf2);

        lea        eax, DWORD PTR _buf2$[ebp]
        push        eax
        lea        ecx, DWORD PTR _buf1$[ebp]
        push        ecx
        call        ?copymem@@YAXQAD0@Z                        ; copymem
        add        esp, 8

; 13   : }

        xor        eax, eax
        mov        esp, ebp
        pop        ebp
        ret        0
_main        ENDP

编译后，真是无法理解
        push        4                       ;sizeof(p1)=4???
        mov        eax, DWORD PTR _p2$[ebp]
        push        eax
        mov        ecx, DWORD PTR _p1$[ebp]
        push        ecx
        call        _memcpy

sizeof(p1)=4???
极度危险的操作呀~

数组退化为指针
指针大小为4

有了指针  可以随便访问东西  而且类型也变灵活了 Dword你可以按byte访问

差不多的类型可以按同一种指针来访问 实现多态什么的.....  

反正可以直接操作内存 那真是爽啊

比如说 有个变量 a=55   在地址437 用内存工具察看的话是这样

    01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0F
410 00 00 00 00 00 00 00 00 00 00 00 00 00 00
420 00 00 00 00 00 00 00 00 00 00 00 00 00 00
430 00 00 00 00 00 00 55 00 00 00 00 00 00 00
440 00 00 00 00 00 00 00 00 00 00 00 00 00 00
450 00 00 00 00 00 00 00 00 00 00 00 00 00 00
460 00 00 00 00 00 00 00 00 00 00 00 00 00 00

你不想让别人马上确定这个55就是变量A 所以你要在周围加 一圈55来做掩护  (&a-14 -15 -16 -1 +1 +14 +15 +16)变成这样

    01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0F
410 00 00 00 00 00 00 00 00 00 00 00 00 00 00
420 00 00 00 00 00 55 55 55 00 00 00 00 00 00
430 00 00 00 00 00 55 55 55 00 00 00 00 00 00
440 00 00 00 00 00 55 55 55 00 00 00 00 00 00
450 00 00 00 00 00 00 00 00 00 00 00 00 00 00
460 00 00 00 00 00 00 00 00 00 00 00 00 00 00

没指针你咋实现?

指针就是一个直接操作内存的机器字！很简单而已，当然，喜欢用高级语言特别是JAVA的人，是不会懂得什么叫指针的。

Java 中所謂的 reference 在某種意義上其實就是 C/C++ 中的 pointer
在 Java 中除了基本型態 (char, int ...), 所有的 object 都是靠 reference "間接"存取的
C/C++ 之所以容易讓人搞混, 是因為, 使用者可以自行決定要"間接"或"直接"存取一個東西

工作多年，一直用c

既然这个版块是讲编程
那我就插嘴咯（我的汇编水平很一般）

高级语言里面
更前的我不知道
但C是铁了心支持指针的（大概是年代久远的原因~）
C++依然有指针的原因只是为了保留C的特性而已（毕竟C++还带个“C”的嘛）
实际上C++标准推荐使用的是引用，并希望尽可能少地使用指针
（即使使用也推荐使用智能指针以及迭代器（也是智能指针嘛））
原因很复杂 这个只有那些不知道玩了语言多久的专家才能说的很清楚
我就简而化之 -- 你未必能用对，尤其是在软件架构繁杂的时候 （表砸我~~~）

汇编里面到处都是指针
确实，如LS几位所说，学汇编后对指针会有另一个层次的认识
不过高级语言的特别之处在于
它封装了太多的东西（也就是说它高级嘛~~怎么又有人砸我...）
这样以来这个底层的
却完全扮演这“双刃剑”角色的指针就成了软肋
这是事实，尤其是在OOPL里面，以C++为例
尽管C++是强类型语言，但指针却是一个弱类型
指针不会自动帮你进行深复制
指针不会自动撤销（申请到的空间）
指针可能不小心做一些非法修改
指针可能指向孤儿内存或者不小心撤销掉你不希望撤销的内存
各种各样的类型强制或者隐式转换
...
其实那
汇编使用指针方便简单的原因是因为它够底层
但不要忘了高级语言里面，物理内存是完全透明的~
而JAVA就是为了让C++更简单更容易使用才出现的
也因此取消了指针

所以那~~指针是必要的
但必要的不是一定需要用的嘛
如果你依然学C那你还是要边学学汇编
如果已经下定决心学C++了（实际上C++的繁杂程度较之C...简直是大象比蚂蚁唉...）
那就摒弃所有C的想法
尤其是刚开始的时候
千万不要把C++看作是C的超集
最好把这两个看作是完全不一样的语言~~~
不然会后悔的哦~~

看没有指针，不可能访问堆，也不可能访问数组和不定长的数据块。如果说可以用类访问，这样的类的编写本身就成问题。

C++的引用内部实质上也是指针，高级语言只是限制了对于指针的引用而已

没有指针怎么做底层？

感觉指针无处不在...