c最难是~~~~~~~~~~

[xtss]

我现在学到了指针了，感到有些难呀！！

最近也不是常来这里了。我得学习。

真的好想你们呀，只有一个星期来一次了

问一下指针和FOR哪一个难学呀。在上机考试中那一个出题占的多一些呀

[badtou]

指针

[start550]

指针的爱情

1 指向变量的指针变量：
出身： int * point;
遭遇： 两人都另有新欢
心声： 你可以变心，我也可以爱别人，很公平。

2 指向常量的指针变量：
出身： const int * point;
遭遇： 抛弃对方
心声： 说过多少回了，我们之间已经结束了，你别再缠着我了，告诉你，我已经有了新的女朋友了

3 指向变量的指针常量：
出身： int * const point;
遭遇： 被对方抛弃
心声： 你怎么可以这样呢，你知道我的心里永远只有你一个，你怎么可以爱上别人呢

4 指向常量的指针常量：
出身： const int * const point;
遭遇： 两情相悦，天长地久
心声： 你是我的唯一，我是你的永远，钻石恒久远，怎即我俩情


原作者： delphisky
来 源： CSDN

[asvaboy1980]

c很简单,指针和结构体,还有函数,这是c的重点,你以后上<<数据结构>>的上机的时候就知道它们的重要性了

[lbaby]

指针，数组，与参数传递

[Bandry]

当然是指针最难，很多人学过一点就认为自己掌握了指针，呵呵，没那么容易，指针可是说变就变的，水平再高再小心的程序员遇到指针，他也得好好想想，否则一样死掉。

[Origianl]

不停的上机,没有好难的.

[dengpan]

我认为c中的最难问题是如何解决与另几种语言的衔接问题,比如java c++之类,面向对象和面向过程根本不是两回事-----学c会染上思想根深蒂固的毛病,就很难学好oop了.不止大家看法如何.至于指针,那些是低层次的东西,不必多学------

[bryan99]

把指针结合数组一起看,更容易了解...
一定要把指针这里弄明白...这样才算是真正的进入了C...

[cyh01]

记住指针指向一个内存单元

[cwanter]

这是我关于指针的粗陋看法，希望对你有帮助：

指针就是指向内存中某个地址的一个变量。要分清指针变量和指针指向的内存地址的区别。int *p;定义了一个指针变量，这个变量（注意是这个变量，也就是p）的地址（不是它指向的地址）在堆栈上，跟int i一样，i的地址也是在堆栈上。但p指向的地址（注意是指向的地址）不定，也就是所说的野指针。int *p=new int[100];定义了一个指针变量p,在堆栈为p分配了内存，同时在堆上分配了100个int大小的内存，它的首地址放在p的地址内。如果看懂了这段话，你就可以大体理解了指针。

[alphapaopao]

那个抛弃来抛弃去的回贴很有意思

[gq00001]

是啊，很有趣又形象的回贴

[never2113]

指针最难，但是把指针、数组、函数结合起来的时候总会发晕
这是才是很难

[assembly]

有空去编几段汇编小程序，这几个概念就都搞定了

[yoyodd]

都挺简单

[Crystal_arrow]

加油！

[zhengguoshan]

这两个比我觉得指针更难一些。。。。

[elvahuang]

好象是什么:世上无难事,只怕有心人

[zm_speed]

指针难理解点吧，比较抽像，下面是找来的！


--------------指针----------------
int a=10;
int *p=&a;

-------------指针的指针-----------
int b=20;
int *p=&b;
int **p2p=&p;

-------------简单数组-----------------
int c[10];//整数数组，含有10个整数元素
file://也就是说每一个元素都是整数

--------------指针数组--------------------
int *p[10];//指针数组，含有10个指针元素
file://也就是说每一个元素都是指针

--------------数组指针--------------------
int (*p)[10];//数组指针，这个指针可以用来指向
file://含有10个元素的整数数组

上面这些简单的形式是我们必须要首先理解，这个是基本的知识。
同时我们从上面也要得出一个很重要的知识提示：c++语言层面上
关于变量声明的部分，后缀结合变量的优先级比前缀要高的。
看我们上面的例子的最后两个就明白了，我们为了实现数组指针的
声明我们不得不变通一下。我们采用()来实现优先级的改变，实现了
数组指针的声明。

################################
# #
# 进一步提高知识 #
# #
################################

数组，数组的指针，指针的数组，概念太多了。我接受概念一多的
时候，我就想把这些复杂的东西简单一下。因为我太懒了，概念简化
一下，记住更容易一点。所以我们这里要认识一下上面这些概念本质。
这样可以简化概念，减少记忆的难度。

先看一段程序。
#include <iostream>
#include <typeinfo>
using namespace std;
int main()
{
int vInt=10;
int arr[2]={10,20};

int *p=&vInt;
int **p2p=&p;

int *parr[2]={&vInt,&vInt};
int (*p2arr)[2]=&arr;

cout<<"Declaration [int vInt=10] type=="<<typeid(vInt).name()<<endl;
cout<<"Declaration [arr[2]={10,20}] type=="<<typeid(arr).name()<<endl;
cout<<"Declaration [int *p=&vInt] type=="<<typeid(p).name()<<endl;
cout<<"Declaration [int **p2p=&p] type=="<<typeid(p2p).name()<<endl;
cout<<"Declaration [int *parr[2]={&vInt,&vInt}] type=="<<typeid(parr).name()<<endl;
cout<<"Declaration [int (*p2arr)[2]=&arr] type=="<<typeid(p2arr).name()<<endl;

return 0;
}

运行的结果如下：(我在前面加了行号#XX)
#01 Declaration [int vInt=10] type==int
#02 Declaration [arr[2]={10,20}] type==int *
#03 Declaration [int *p=&vInt] type==int *
#04 Declaration [int **p2p=&p] type==int * *
#05 Declaration [int *parr[2]={&vInt,&vInt}] type==int **
#06 Declaration [int (*p2arr)[2]=&arr] type==int (*)[2]

现在我们来分析一下结果。因为我们已经具有了第一部分的基本知识，我们现在
可以很明确区别出来我们声明的类型。这里主要有两个很重要的部分，我们不过
是就事讲事情，编译器是如何实现的原理不在这里讨论之列。

--------#02：数组------------

现在看#02,想到了什么没有呀？在编译器看来数组只是相对应类型的指针类型。
当我们把数组传递给函数作为参数的时候，传递的是指针，所以我们可以利用
参数来修改数组元素。这个转化是编译器自动完成的。

void f(int[]);
int a[2]={10,20};
f(a);//这行等价于编译器完成的函数转化f(int *p)

也就是说这里编译器自动完成了int[]类型到int *的转化，
注意是编译器完成的，也可以说是语言本身实现的，我们
对此只有接受的份了。

-------#05：指针数组---------------

指针数组的编译器内部表示也是对应类型的指针。

------#06：数组指针----------------
数组指针的编译器内部表示就是有一点特别了。
编译器(或者说是语言本身)有数组指针这个内部表示。
由于c++语言的类型严格检查的语言（当然还有一些是存在隐式类型转化的）

所以我们下面的写法是不能编译通过的。
{
file://---------编译不能通过--------------
int arr[3]={10,20};//注意是3个元素数组
int (*p2arr)[2]=&arr;//注意是指向2个元素数组的指针
file://---------编译不能通过--------------
}

################################
# #
# 初步小结 #
# #
################################

通过上面两个小节的内容，大家应该基本明白了，
数组，指针，指针数组，数组指针到底是怎么一回事情了吧。

-----------补充开始-----------------------
关于数组和指针的转化，以及我们使用指针(++,--)等来操作数组，
是基于数组在内存中是连续分布的。

但是我们使用“迭代器”的时候，情况是不一样的。
这个问题本文不讨论。

-----------补充结束---------------------

不过c++语言本身有很多诡异的地方（因为c++要考虑到跟c语言以及旧的c++版本兼容）。
内建类型的这些性质特征到了函数部分会有一点小的变化，不过如果你了解了编译器做了
什么以后的话，你也就不会太奇怪了。不过关于函数部分的内容我下次再说了。

现在回到上面的内容。我们这里还是讲一下内建类型。显然一样类型的变量是可以互相赋值。
不过当然还有一些其他情况也是可以的，比如类型的宽化，关于类的继承体系问题等等。

当然了，不一样的类型一般来说是不能互相赋值，当然这里的例外就是强制转化，
类的继承体系等情况了。

看到这里就会明白下面的程序为什么会运行的了。
我这里也把下面的程序作为今天内容的总结：

#include <iostream>
using namespace std;
int main()
{
int a[2]={10,20};
int *p=a;//根据上面说明，由于编译器的参与，两者类型转化后一致

int vInt=10;
int *parr[2]={&vInt,&vInt};
int **p2p=parr;//上面分析，类型一致

return 0;
}

[一闻]

指针多看点经典例题学习就很快了，看看
《C Primer Plus》中文第四版中的指针说明，篇幅很少，但讲得很清楚