若有以下定义和语句 int a=4,b=3,*p,*q,*w; p=&a;q=&b;w=q;q=..._教育_考试与招生资讯网
若有以下定义和语句 int a=4,b=3,*p,*q,*w; p=&a;q=&b;w=q;q=...
发表于： 05:59:39& 整理: &来源:网络
int a=4,b=3,*p,*q,*w;p=&a;q=&b;w=q;q=null为什么*q=0是错...
=&a 这样才是对的，因为是地址对地址的赋值
*q =0这样是不对的，因为这样是把数值赋值给地址，是没办法的！
最佳答案: *p
=&a 这样才是对的，因为是地址对地址的赋值
*q =0这样是不对的，因为这样是把数值赋值给地址，是没办法的！把q = null 改为 q = NULL就对了不知道怎么回事，楼上怎么胡说啊？ *q =0，在后面的 语句 中是没错的，但在初始化中式不可以的，因为初始化时， int
*是类别， 如果 写... *q =0可以啊，问题是& q= null& q是个0x的地址，这个地址当然不能赋值了。。初始化时 int
= 0；也是可以的哦，因为NULL都是被宏 定义 为0；就相当于
若有一下定义和语句#include &stdio.h& int a=4,b=3,*p,*q,*w;...
问：选项如下其中错误的是（）A. *q =0; b. w=q;
C. *p =a; D. *p = *w； 希望...
若有 一下 定义和语句 #include
a=4 , b=3 , *p , *q , *w;
w=q;q= NUA . q = NULL 了对NULL的解引用
= 0； 是错误的。
最佳答案:A . q = NULL 了 对 NULL的解引用
= 0； 是错误的。A， 不能给空指针赋值
以下不正确的语句（设有 int q,p）是
以下 不正确的 语句 （设有
q,p）是_____。 A) p* =3 ; B) p/ =q;
C) p+ =3 ; D) pD 不对。C/C++ 里只有 &= ，没有 &&= 。&= 是按位与...
最佳答案:D 不对。C/C++ 里只有 &= ，没有 &&= 。&= 是按位与操作 & 的简写，相当于 p = p & q ；而逻辑与操作符 && 没有简写。对于 B，即使 q 是 0，也只会在运行时崩溃。D) p&& =q；
有没有写错了。。。。。。。。。。。
设有定义语句：int =0,*p=&你,*q；以下选项正确的是？p=...
使用了逗号操作符，实际上 等于 ： int
n = 0; int
*q ；所以，n是整型，p,q是整型指针。a错了，c也错了， *p 是解引用操作，得到
最佳答案:使用了逗号操作符，实际上 等于 ： int
n = 0; int
*q ；所以，n是整型，p,q是整型指针。a错了，c也错了， *p 是解引用操作，得到的是p所指向的内存区域的值。它不能作为一个&左值&（left value，也即location value，就是地址值）。只有b是对的，使p指向q所指向的内存区域。啥意思啊？b
14） 若有以下定义和语句
问： 若有以下定义和语句 #include &lt...
a=4 , b=3 , *p , *q , *w;
*q 就是访问q所指向的地址里面的值； 但是此时的q已经为空了。所以这样访问取值为非法。程序会崩溃。 选A
最佳答案: *q 就是访问q所指向的地址里面的值； 但是此时的q已经为空了。所以这样访问取值为非法。程序会崩溃。 选Aq最后被赋值为NULL也就是空指针，对空地址解引用会造成内存segment fault，所以选A答案：A 因为q现在是空指针，不能接受赋值操作。
若有说明：int n=2,*p=&n,*q=p；则以下非法的赋值语句是 a) ...
问：这道题应该怎么解
若有 说明： int
n=2, *p =则 以下 非法的赋值 语句 是 a)
p= n；说明的意思是n是整型数p所指空间为n的地址而q所指空间为指针p...
最佳答案:说明的意思是n是整型数p所指空间为n的地址而q所指空间为指针p的指答案很明显a）对，把q这个地址值赋给p的指向空间b）错，首先类型不匹配这两个赋值 语句 在合适的编译环境下可以视为合法，只不过赋值期间编译器会进行类型值的隐式转换。当前大多32位cpu编译器环境中...b) p=n；应改为 p=& n;
C语言 main() {int a[5]={1,2,3,4,5},b[4]={6,7,8,9},*p=a,*q=b}
问：main() { int
a [5]={1,2,3,4,5},b[4]={6,7,8,9}, *p =a, *q =b p+=2;q+ =3 ;
main() { int
a [5]={1,2,3,4,5},b[4]={6,7,8,9}, *p =a, *q =b//p指向a的首地址，即1,q指向b，即6 p+=2;q+ =3 ;//p地址后移2位，指向3,q
最佳答案:main() { int
a [5]={1,2,3,4,5},b[4]={6,7,8,9}, *p =a, *q =b//p指向a的首地址，即1,q指向b，即6 p+=2;q+ =3 ;//p地址后移2位，指向3,q同理指向9
*p =*(q)+3；//赋值 语句 ，将q指向的内容加3赋给p，则p指向的值3变成12,q依旧为9 q--;//q地址前移1位，即8 *(q-1)=*(p+1)-5；//将p指向位置的下一位的内容即4减去5得-1，赋给q的前一位，则q的前一位变成-1，但q的指向位置没有改...p+=2;q+ =3 ;p指针指向a[2],q指针指向b[ 3 ] *p =*(q)+3；把a[2]换成12q--;q指针指向b[2]*(q-1)=*(p+1)-5;b[1]换成-1printf(＂%d\n＂, *p )；输出... *p =a 表示指针p指向数组a的首地址即第一个元素； *q =b指针q指向数组b的首地址即第一个元素；p+=2表示数组a的第三个元素，q+ =3 ...你应该自己推导，哪里挡住了你的思路，再提问，这样对你理解知识有帮助！想知道你写的这个程序的意义是什么。
若有声明＂int a[3][4],*p=a[0],(*q)[4]=a；＂,则下列叙述中错...
问：C.a[2][3]与*（p+11）等价 D.a[2][3]与 P= P+11, *P 等价详细解释一下...
void main(){
a [3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
*p =a[0];// p = &a[1][0]
( *q )[4]=a; //
最佳答案:void main(){
a [3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
*p =a[0];// p = &a[1][0]
( *q )[4]=a; // q[0]是一个数组指针，且指向的是一个大小为4的数组-&&a[0][0] // q[1]是一个数组指针，且指向的是一个大小为4的数组-&&a[1][0] // q[2]是一个数组指针，且指向的是一个大小为4的数组-&&a[2][0]
i = 0; for(i=0; i&4; i++) { printf(＂%d ＂, p[i]); } printf(＂\n\n＂); for(i=0; i&3; ...A C D
main() { int a=3,b=4,*p,*q,r; p=&a; q=&b; r=*p; *p=*q; *q=r; ...
问：程序中，a和b的值是否交换了？为什么？
a= 3, b= 4, *p , *q ,r;
*q =r; printf(＂%d,%d,%d,%d\n＂, *p , *q ,a,b)； }交换了将a地址赋值给p，将b地址赋值给...
最佳答案:交换了将a地址赋值给p，将b地址赋值给qr= *p 将指针p指向的值赋值给r *p = *q ；将指针q指向的值赋值给 *p
*q =r将r的值赋值 *q 那么 *p
*q 等于3交换了，一定交换了，因为你是在一个 语句 块里面对变量的值进行交换的，就算你不用指针也一样可以交换他们的值的交换了，他是通过指针访问a,b，然后交换他们的值
设有如下数据定义语句： int a[10],*p=a,*q=a+9； 则在下列...
问：A.p++B.q-=1C.q-pD.p+ =q
D 因为越界了。A
*p =a，代表p指针指向了数组的第一个元素的地址。p++指针偏移，没错。B
*p =a+9 。a是数组，作
最佳答案:D 因为越界了。A
*p =a，代表p指针指向了数组的第一个元素的地址。p++指针偏移，没错。B
*p =a+9 。a是数组，作为 等号 左值时，等同于a[0],a+9就是a[9]。没错C q指向了a[9] p指向了a[0].相减等同于--q;D p+ =q
p= p+q。一共才10个元素。q指向了a[9] 再偏移一个就是a[10].越界。建议看看基础。选D。A，指针p自加1B，指针q自减1C，指针q-p ，可以做减法的，结果是9。D，加法就不能做了，一个地址加另外一个地址，是什么...答案是D乍一看，给人的感觉是C和D都不对，再分析就不是了：你看，p是一个指针，它的值是a，也就是a[ ]的首地址，等价于a[0]。...
此文由 考试与招生资讯网整理和发布，内容全部来源于网络，如有侵权请联系管理员删除
答：{ int a=5,b=4,c=3,d=2; if(a&b& C. ...(29) 若有以下定义和语句 #include int a=4,b...p=&a; q=&b; w=q; q=NULL; 则以下选项中错误... 问：一、单选题（共 20 道试题，共 60 分。） V 1. 若有定义int a[]={10,20,...
答：1. 若有定义int a[]={10,20,30},*p=a;则当执行p++后,下列说法错误的...B. satC. friD. thu 满分:3 分7. 若有以下说明和语句,int c[4][5],... 问：1. 以下说法正确的是( ) (2分) A. C语言程序总是从第一个定义的函数开始...
答：若有一些定义和语句 #include int a=4,b=3,*p,*q,*w; p=&a; q=&b; w=q; q=NULL;则以下选项中错误的语句是___。 (2分) A. *q... 问：int *p[4]中定义的p是二级指针吗，int（*p）[4]是不是既可以表示一级指...
答：int *p[4]中定义的p是有4整型指针的数组 int（*q）[4] q是指向具有4个整型元素的数组的指针! 用法 int f[10]; int x[4],y[4],z[4],w[4]; int a,b,c,d; int *p[4] ={&a,&b,&c,&d}; p[0]= &a;p[1]=b;p[2]=&c;p[3]=&d; 和 int *p[4] ={x,y,z,w}; p[... 答：(15)若有定义语句:inta=3,b=2,c=1;,以下选项...C)scanf(&%lf&,p+6); D)scanf(&%lf&,p[6...{ int a=4,b=5,c=6; printf(&%d\n&,fun(...
考试与招生资讯网|ICP备案号：浙ICP备号-1
声明：本站内容全部来源于网络，并不代表本网观点或证实其内容的真实性本网不对信息的真实性和有效性负法律责任,希望访问者慎重考虑，风险由用户自己承担,如有侵权请联系管理员删除。> c++学习笔记(4.c++中新的关键字)
c++学习笔记(4.c++中新的关键字)
上传者：shalou2004
我也要“”
& & 本节知识点：& & 1.关键字new与delete：& & a.c++中通过new关键字进行动态内存分配，new是一种基于类型进行的内存分配，同时c++使用delete进行内存释放& & 单个变量内存申请与释放：Type* p = new T&&&&&delete&p;& & 一段内存空间的申请与释放：Type* p = new Type [N];&&&&&delete&[]&p;& & 示例代码如下：& & [cpp]& & #include & & #include & & int main()& & {& & /*使用new申请单个变量*/& & double* p =& & *p = 7.2;& & printf("%f\n",*p);& && & int *p1 = (int*)malloc(sizeof(int)*10);& & for(int i = 0; i < 10; i++)& & {& & *(p1+i) =& & }& & for(int i = 0; i < 10; i++)& & {& & printf("%d\n",p1[i]);& & }& & free(p1);& & /*使用new申请一段连续的内存空间*/& & //new出来的这个空间看着像数组 但它跟数组有本质区别&这是在堆区的& & int *p2 = new int[10];& & for(int i = 10; i > 0; i--)& & {& & p2[10-i] =& & }& & for(int i = 0; i < 10; i++)& & {& & printf("%d\n",*(p2+i));& & }& & delete [] p2;& & return 0;& & }& & b.new关键字与malloc函数的区别：& & 第一：new关键字是c++的一部分，而malloc是由c库提供的函数& & 第二：new是以具体类型为单位进行内存分配，malloc只能以字节为单位进行内存分配& & 第三：new在申请单个类型变量时可进行初始化，malloc不具备内存初始化的特性，代码如下：& & [cpp]& & #include & & int main()& & {& & int* p = new int(6);& & printf("%d\n",*p);& & double* fp = new double(7.2);& & printf("%f\n",*fp);& & char* cp = new char(&#39;d&#39;);& & printf("%c\n",*cp);& & return 0;& & }& & 2.c++中的命名空间：& & a.命名空间产生的原因：在c语言中只有一个全局作用区，所有的全局标识符(包括全局变量、函数)共享同一个全局作用区。尽管有static关键字的限制，但是在工程中依然存在接口函数名之间，或与库函数名冲突的现象。所以c++中提出了命名空间的概念，命名空间将全局作用区分成了若干的命名空间和无名空间(即默认空间，也就是兼容c语言的全局作用区的空间)。& & b.命名空间的有效作用域：在c语言中没有命名空间的概念，导致所有在全局作用区的全局标识符的作用域都是，从这个变量或者函数定义声明开始一直有效到程序结束(从始至终贯穿着整个程序，所有很容易就冲突了)。而c++中有了命名空间的概念后，一旦在一个函数中使用using namespace name1;&&using name1::a;这样的语句的时候，name1这个命名空间的作用域和name1中a变量的作用域，就是从using命令开始到这个函数结束(也就是说可以通过命名空间来控制全局变量的作用域了)。如果是在一个命名空间name2中使用using命令的话，那name1和a的作用域就属于name2了(即与name2属于相同作用域)。如果在默认命名空间(无名空间)中使用using命令，name1和a的作用域就变化与c语言一样的那个全局作用区了。如果使用name1::a这样方法直接去控制变量的话，那作用域就是使用瞬间。& & c.命名空间的语法：& & 定义命名空间(要在函数外面定义)：& & [cpp]& & namespace name2&//这个是命名空间的嵌套& & {& & int c = 2;& & int f = 5;& & namespace name3& & {& & int d = 3;& & int e = 4;& & }& & }& & 使用命名空间(有三种方式)：& & 第一：using spacename name1;&开启name1这个命名空间，可以使用这个命名空间中的所有变量了。& & 第二：using name1::a;&可以使用name1命名空间中的a变量了。& & 第三：name1::a = 10;&直接使用name1命名空间的a变量& & 第四：::a = 10; 或者&a = 10;&&直接使用默认命名空间中的变量& & d.使用命名空间要注意：& & 第一：命名空间是可以相互嵌套的，且有一个嵌套顺序的问题，不同嵌套顺序的命名空间，即使名称相同，也是不同的命名空间。因为using的时候，是有顺序的。& & 第二：相同名称的命名空间，在using的时候，两个命名空间都会被打开。只要相同名称的命名空间中没有同名变量就可以！否则在使用这个变量的时候，就会出现二义性，编译会出问题。& & 第三：不同命名空间中，标识符可以同名而不会发生冲突！因为在使用的时候，不一定会同时using这两个命名空间，所以不一定会产生二义性！但是如果同时打开这两个命名空间，还去使用了这个同名变量，编译也会出错，因为产生二义性！但是当using spacename name1;(name1中有变量a)&并且using name2::a的时候，再使用a变量的时候就没有二义性了，编译器默认选择name2中的a变量使用。代码如下：& & [cpp]& & #include& & namespace name1& & {& & int a = 9;& & namespace name1& & {& & int a = 10;& & }& & }& & namespace name2& & {& & int p = 19;& & int a = 0;& & }& & int&main()& & {& & using namespace name1;& & using name2::a;& & printf("%d\n",a);& & return 0;& & }& & 3.c++中的强制类型转换：& & a.c语言中的强制类型转换：有两种方式，(Type) name&&和&Type (name)&注意第二种方式不是很常用。& & b.c语言中强制类型转换存在的问题：& & 第一：过于粗暴，任何类型之间都可以进行转换，编译器很难判断其正确性。& & 第二：难于定位，在源码中无法快速定位所有使用强制类型转换的语句。& & 补充：在程序设计理论中强制类型转换不被推荐，与goto语句一样，应该进行避免，因为在程序设计过程中，定义变量就应该清楚变量的使用环境，直接定义成有效的类型，避免强制类型转换。还有就是现代的软件产品里面有三个问题是bug的源泉：有运算符的优先级问题、多线程编程中各个线程的交互、强制类型转换。& & c.c++中将强制类型转换分成四个类型：& & static_cast类型：用于基本类型间的转换，但不能用于指针类型间的转换。用于有继承关系对象之间的转换和类指针之间的转换。但是static_cast是编译期进行的转换，无法在运行时检测类型，所以类类型之间的转换可能存在风险。代码如下：& & [cpp]& & #include & & int main()& & {& & int a = 99;& & double b = static_cast(a);& & printf("%f\n",b);& & printf("%c\n",static_cast(b));& & getchar();& & return 0;& & }& & const_cast类型：用于去除变量的const属性，注意，它只能去除const int* p或者const int& p这两种类型中的const属性。比如int* const p类型中的const属性是去不掉的，其实不管用什么手段这个const的属性都是去不掉的，int* const p = &a;&p一旦指向就不能再改变指向，这其实就是引用的实质！！！& & const_cast类型有三个常用环境：第一，去除const int &j;的const只读属性、第二，去除const int *的const只读属性、第三，去除的const只读属性。代码如下：& & [cpp]& & #include & & int main()& & {& & /*const int &j&去除const属性*/& & const int& j = 4;& & const_cast(j) = 6;&//其实实际上j就是一个只读变量 利用指针也可以改变j的值的& & //&&*(int*)(&j) = 6;&//这步的强制类型转换与上面那句代码等效& & printf("j is %d\n",j);& & int& i = const_cast(j);& & i = 12;& & printf("j is %d\n",i);& & /*const int* p 去除const属性*/& & int a = 1;& & const int* p = &a;& & *const_cast(p) = 2;& & //&&*(int* )p = 2; //与上面代码等效的强制类型转换& & printf("*p is %d\n",*p);& & /*const int l = 6*/& & const int l = 16;& & const_cast(l) = 17;& & //&&(int&)l = 17;&//与上面语句等效的强制类型转换& & //&&*const_cast(&l) = 17;& & //&&*(int*)&l = 17;& & printf("l is %d\n",l);& & return 0;& & }& & 对于上面代码有两点要说明：& & 第一：const_cast其实只读const指针和const引用起作用了，对const常量没有起作用，因为const常量是保存在符号表中的。& & 第二：对于引用的强制类型转换，int a = 10;&(char)a这是将a变量中的值强制类型转换成char类型，切记此时(char)a不是变量不能当做左值使用。但是(char&)a是将a强制类型转换成char类型的引用，其实是一个变量可以当做左值使用！对于const_cast(l) = 17; 来说l常量是存放在符号表中的，而const_cast(l)其实是个有内存空间的变量，其实相当于对l取地址的时候，编译器分配了一个内存空间，这个空间不是用来存放l常量的，而是强制类型转换后这个引用的内存空间，所以说这个17就存放在这个引用的内存空间了！！！& & reinterpret_cast类型：用于指针类型间的强制类型转换，用于整数和指针间的强制类型转换，还用于引用间的强制类型转换。(注：此处指针引用的强制类型转换都是没有const属性去除过程的，否则优先使用const_cast)& & 引用间的强制类型转换(代码如下)：& & [cpp]& & #include & & int main()& & {& & int a = 10;& & int &b =& & char &c = reinterpret_cast(b);& & printf("%d\n",reinterpret_cast(b));& & a = 129;& & printf("a is %d\n",a);& & printf("b is %d\n",b);& & printf("c is %d\n",c);& & return 0;& & }& & 我们仔细说说代码中c引用与b引用的关系，不可否定的是abc三个变量，有其中任何一个变量改变了，都会对另外的两个起到改变的作用！a与b仅仅是名字不同的问题(其余完全相同)，但是c引用是与b引用变成char类型引用变量后完全相同的。& & reinterpret_cast类型用法，代码如下：& & [cpp]& & #include & & int main()& & {& & int a = 10;& & *reinterpret_cast(&a) = 12;& & printf("a is %d\n",a);& & int* b = &a;& & char* c = reinterpret_cast(b);& & *c = 14;& & printf("a is %d\n",*c);& & return 0;& & }& & reinterpret_cast是直接从二进制位进行复制，是一种极其不安全的转换。& & dynamic_cast类型：主要用于类层次间的转换，还可以用于类之间的交叉转换。dymanic_cast具有类型检查的功能，比static_cast更安全。这个问题等对类有了理解再回来补充。
声明：该文章系网友上传分享，此内容仅代表网友个人经验或观点，不代表本网站立场和观点；若未进行原创声明，则表明该文章系转载自互联网；若该文章内容涉嫌侵权，请及时向
论文写作技巧
上一篇：下一篇：
相关经验教程数组名a，&a，&a[0]的关系【c语言吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：530,338贴子：
数组名a，&a，&a[0]的关系收藏
学习数组的时候经常被这三个货弄晕，后来查了很多资料，觉的自己明白了，在这说一下自己的理解，求各位大神指正。
首先说一下，当我们定义了一个变量的时候，比如int x；x的类型是int，那么当我们定义数组的时候比如 int a[3];a的类型是什么，int？No，int是数组元素的类型，不是数组的类型，觉的是int[3]，但C语言里没有这种类型，但我们可以用typedef int A[3]; A那么这个b和a完全一样都是包含三个整数的整型数组。所以说a的类型是A（int[3]，数组类型），所以当我们用sizeof（a）来测试a的空间的时候得到12个字节，当我们&a的时候得到数组a（整体）地址，&a+1会移动到数组后面。这和普通变量一样。所以数组名和普通变量名在这点上类似。这是我对数组的理解，不知道对不对。接下来说下a和&a[0]的关系
AutoTDS-V1型全自动热解吸仪是一款20位常温二次全自动热解吸仪，气路采....
接前文，我们知道数组是同类型元素的**，但数组不能整体存取，只能一个一个元素存取，所以凡是在（除&和sizieof）表达式里出现的数组名a都代表数组首元素地址，也就是&a[0],比如说*a就是a[0]，因为[]下标运算符就代表*（a+0），所以a[0]也可以写成0[a](这纯粹是语法上，不建议写这种怪摸样的东东)，在这里*a,也就是*(a+0)，也即a[0]；那么当我们定义了一个指针int *p; 可以p =因为在这个表达式里a就代表&a[0],&a[0]就是一个整型地址，自然可以赋值给p。p++会移动到4个字节，所以当p=a后p也可以做数组名用，比如说p[1]等价于*(p+1)。但p和数组名有根本上的不同，p是变量，可以更改，而且其只能指向一个整型变量，不代表整个数组，所以sizeof(p)是4,&p表示p的地址而不是整个数组的地址，&p+1往后移动4字节。而数组名a代表有两层语义：
1. a表示一个数组，sizeof（a）等于数组长度*4,&a代表整个数组的地址，&a+1移动到数组后面。
2.在存取数组元素的时候a表示数组首元素的地址，所以a[2]表示*(a+2)表示数组第三个元素至于说数组名是常指针或是常量，我觉的都不靠谱，没有说明数组名的本质。其表现为常量是因为数组不能整体赋值，常指针就更不靠谱，因为数组名并没有本身的地址。
欢迎各位大神指正
楼主，你好：你的以上说法不够准确。1.int b[3];变量a占用4个字节的存储空间，而变量名a本身并不占用存储空间，数组名b也是如此，它也不占用存储空间，不确切的说，数组名b是对12个存储空间的统称（变量名、数组名在C语言编译时起作用，编译完成后就不存在了）。
2.直接对数组名进行引用（如：int *p = a)时，数组名的数据类型是int*类型，而非a[3]类型（注意：数组名本身并不占用存储空间）。3.C语言非常强调数据的类型！！其实你所研究的问题的区别就是数据类型不同而已。C语言认为，对数组名取地址和直接引用数组名不是一回事儿。他们区别如下：对数组名取地址，数据类型：int (*)[3]直接引用数组名，数据类型：
int*&a[0]的数据类型：int *OK,解答完毕！
觉的是int[3]，但C语言里没有这种类型，///////////////////////////////////////明显 c语言里面有这个数据类型 你才可以用typedef 给数组类型起一个名字
sizeof是C语言的关键字，sizeof()不是函数，请不要用函数的思想来看待sizeof运算符噢！sizeof(a)，其中a指整个数组，求整个数组的大小，该运算结果在C源程序编译时由编译器求出，不是在程序运行时动态求解出来的，它的运算结果理所当然是12，请不要用神马a的类型来解释，再说一便，sizeof不是函数，它是C语言的一个操作符。
记得好像：C语言上有这么个历史：很久以前，直接使用变量名a是可以的，而对&a取地址是非法的。后来，C语言专家们认为&a也应该是合法的，于是修改了C语言标准，认为&a合法。不过这样的话，就出问题了，a和&a含义一样还是不一样？？专家们最终一拍即合，认为，直接引用a时，a的类型为指向数组成员的指针类型，对a取地址时，&a是指向整个数组的指针（也就是网上所谓的指向二维数组的指针）
不拿编译的原话出来还让你蒙混过去了？int a[3];int b =warning: incompatible pointer to integer conversion initializing 'int' with an expression of type 'int [3]' [-Wint-conversion]
tester.c: In function 'int main()':tester.c:4:13: error: invalid conversion from 'int*' to 'int' [-fpermissive]
爆满是一种常态，排队是一种习惯！开一家火一家的面，您还在犹豫？
数组类型的表达式在除了作为&和sizeof的操作数或是一个字符串字面量初始化数组时都会转换成指向其首元素的指针.
@RichSelianint a[10] = {1,2,3,4};struct s
= {1,2,3,4};以上代码右边是一样的，那你如何用类型解释相同的代码初始化不同类型的变量呢？原因只有一个，就是这个过程在编译时由编译器确定，编译器能很好的识别的。
在二维数组里他们表示同一个地址，对吧。？
1.区分变量名和变量，变量名本身只是标识符，所以它没有内存，也不存在对变量名的操作，更谈不上对变量名取地址2.数组是一种type，就叫array type，或者叫array of T, T是元素的Type，C语言当然有这种Type3.Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression with type "pointer to type" that points to the initial element of the array object and is not an lvalue.The unary & operator returns the address of its operand. If the operand has type "type",the result has type "pointer to type".简单说，对于一个数组，比如int a[3]; 直接写表达式a，会被转换成指向int[3]的指针。而操作符&的语义是啥？返回pointer to operand's type所以a和&a是一样的。
int a[3];那么：a是int [3]类型的。
我是lz，a和&a的不同源于一个数组的两种语义，一般情况下，我们引用数组名是为了得到数组里的元素，这是侯数组名a被编译器用数组首元素地址替换或叫转换；在sizeof（a），a表示的是整个数组，所以是12，&a得到是整个数组的地址，这就像int b=10；int *p=&b;&b代表的变量的地址。int （*q)[3]=&a;所以q和&a是对等的，这是后&a代表的不是某个元素的地址。待会讨论一下二维数组和指针的关系
如果有定义 int c[3][3]; 那么c、c[0]、&c[0][0]关系又如何呢？各位有何高见？
int a[5]; &a和a的类型是不一样的，前者是数组指针，其类型为int(*)[5]，它是对象(数组)首地址，&a+1是下一对象的地址，即a[5]
1.C语言有int[3]这种数组类型可以作为type name。出现并不违反语义规则的上下文如sizeof以及c0mpound literal。2.
C语言里的二维数组，其实是数组的数组，也就是说二维数组其实是一个一维数组，不过这个一维数组的元素还是一个一维数组。例如可以这样定义二维数组：typedef int A[3]; A aa[3];在这里aa[3]就是二维数组（和b[3][3]一样）,所以二维数组的数组名和一维数组一样除sizeof和&外，其他表达式里都表示二维数组第一个元素（也即第一行，是个一位数组）的地址，第一个元素是一维数组，所以二维数组数组名是一个数组指针，指向整个数组（第一个元素），所以数组名aa+1，会移动到下一个元素，也即下一行。那么aa[0]和aa有什么区别呢？
aa[0]和a有什么区别呢？aa[0]==*(aa+0). aa是数组指针，和int (*p)[3]相当，当我们给 p赋值时，需要这样 int a[3];
p= &a;如果我用数学上的等价替换的概念的话，就像： p= ==&aa[0]==&*(p+0)==&*(&a+0)==&*(&a)==&a;所以在这里aa[0]和一维数组的数组名一样。
printf("%u",sizeof(aa[0]));输出12，和一维数组的数组名一样。所以二维数组的下标运算可以解释为*(*(aa+i)+j)。
有数组数据类型，&a就是数组数据类型，吧里还是有大神的，
大家好，问一个问题，求大神解答，a=2 b=3 a%b=？
大家好，问一个问题，求大神解答，a=2 b=3 a%b=？
a是数组的名字，
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或}