动态二维数组new，typedef的几个陷阱，数组名与指针

二维数组new小结 


1. 
A (*ga)[n] = new A[m][n]; 
... 
delete []ga; 
缺点：n必须是已知 
优点：调用直观，连续储存，程序简洁(经过测试，析构函数能正确调用) 

2. A** ga = new A*[m]; 
for(int i = 0; i < m; i++) 
ga[i] = new A[n]; 
... 
for(int i = 0; i < m; i++) 
delete []ga[i]; 
delete []ga; 
缺点：非连续储存，程序烦琐，ga为A**类型 
优点：调用直观，n可以不是已知 

3. A* ga = new A[m*n]; 
... 
delete []ga; 
缺点：调用不够直观 
优点：连续储存，n可以不是已知 

4. vector > ga; 
ga.resize(m); //这三行可用可不用 
for(int i = 1; i < n; i++) // 
ga[i].resize(n); // 
... 

缺点：非连续储存，调试不够方便，编译速度下降，程序膨胀(实际速度差别不大) 
优点：调用直观，自动析构与释放内存，可以调用stl相关函数，动态增长 

5. vector ga; 
ga.resize(m*n); 
方法3,4的结合 


6. 2的改进版
A** ga = new A*[m]; 
ga[0] = new A[m*n]; 
for(int i = 1; i < m; i++) 
ga[i] = ga[i-1]+n; 
优点:连续存储,n可以不是已知,析构方便,只需delete [] ga和delete ga[0];

7.typedef int array[COL];       //使用typedef定义一个具有COL个元素的数组类型

           array *a;  //定义二维数组,与一维数组相同

           a=new array[row]; //为该一维数组（实际上二维）申请空间

                   

      该方法定义的动态二维数组的释放只需以下语句即可：

           delete[] a;

           a=NULL; 

-------------------

指向数组的指针 int (*p)[3]

指针数组 int *p[3]

指向指针的指针 int **p

int ptr[4][4]中定义的ptr本身是一个常量．这个常量用来使编译器明白你所引用的是那个你已经为其分配过内存的数组，ptr这个引用的有效性依赖于 编译器，编译器会直接把它替换成某个常量——在运行时，根本没有任何内存空间来把这个值当作变量存放，它存在于代码中，是在连接时已经指定好的，一般的， 程序本身没有权利再去改变它。

函数指针  int (*P) ()          首先P与*结合,说明是一个指针,然后与()结合,说明该指针指向一个函数,然后与INT结合,说明函数的返回值为INT型

typedef int (*funcptr)();    // funcptr is synonym for "pointer
                                       // to function returning int"
funcptr table[10];            // Equivalent to "int (*table[10])();"

数组名大小与指针大小问题

当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。不论数组a的容量是多少，sizeof(a)始终等于sizeof(type  *)。 
if         数组名直接作为参数压栈
then     sizeof(数组名) = 一个指针所占字节数
else     sizeof(数组名) = 数组所占字节数

int *arr[6][3];                      //二维指针数组;  不等于数组指针 typedef int(*arr)[3] B;  B  b[6];

int e=(unsigned)&arr[5][0]-(unsigned)&arr[4][0]; //转换成数值后就不带类型信息了，整数加减运算

printf("%d\n",e);                  //12   3*sizeof(int *)=3*4

printf(“%d”,arr[5]);              //地址值与&arr[5][0]相同，0xbf97c27c，但arr[5]表示的是一个指向int(*)[3]的指针，

                                             &arr[5][0]表示的是第五行第一个元素的地址，两者地址相同，指向不同

printf(“%d”,arr[4]);              //地址值与&arr[4][0]相同，0xbf97c270，

printf(“%d\n”,arr[5]-arr[4]);  //3   带类型信息的加减， d=arr[5]-arr[4]，d为 int *类型

arr表示arr[0][0]的地址，&arr表示以整个数组作为一个整体的数组指针，指向int(*)[6][3]，&arr+1=&arr[19]

int a=1; &a此时应该是int* 类型

------------------

typedef

陷阱一：

记住，typedef是定义了一种类型的新别名，不同于宏，它不是简单的字符串替换。比如：
先定义：
typedef char* PSTR;
然后：
int mystrcmp(const PSTR, const PSTR);

const PSTR实际上相当于const char*吗？不是的，它实际上相当于char* const。
原因在于const给予了整个指针本身以常量性，也就是形成了常量指针char* const。
简单来说，记住当const和typedef一起出现时，typedef不会是简单的字符串替换就行。

陷阱二：

typedef在语法上是一个存储类的关键字（如auto、extern、mutable、static、register等一样），虽然它并不真正影响对象的存储特性，如：
typedef static int INT2; //不可行
编译将失败，会提示“指定了一个以上的存储类”。

陷进三：

通常讲，typedef要比#define要好，特别是在有指针的场合。请看例子：

typedef char *pStr1;

#define pStr2 char *;

pStr1 s1, s2;

pStr2 s3, s4;

在上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。

陷进四：

typedef char * pStr;

char string[4] = "abc";

const char *p1 = string;

const pStr p2 = string;

p1++;

p2++;

是p2++出错了。这个问题再一次提醒我们：typedef和#define不同，它不是简单的文本替换。上述代码中const pStr p2并不等于const char * p2。const pStr p2和const long x本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已。因此，const pStr p2的含义是：限定数据类型为char *的变量p2为只读，因此p2++错误。