逛奔的蜗牛

我不聪明,但我会很努力

   ::  :: 新随笔 ::  ::  :: 管理 ::

再次看这篇文章,感觉说的好多都是废话,在文章最前面补充一句话:
[]的优先级高于*”,大家可以带着这句话看下面的~~~
========================
再一次的见证了自己的基础不牢靠。。。幸好发现得早,看见网上说,华为的一个面试题就考了这个方面的。

借那道华为的面试题引出问题,题目:

char **p, a[16][8];  问:p=a是否会导致程序在以后出现问题?为什么?

可能有一部分朋友会回答正确,这里他们认为,a[]是一级指针,a[][]就是二级指针。那这个到底对不对呢?

OK,用事实说话:

1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            17
            
// Author: Tanky Woo
            // Blog:    www.WuTianQi.com
            // Note:   验证二维数组与二级指针的传递问题
            #include <iostream> 
            using namespace std;
             
            void Test(char **p)
            {
            cout << p[0][0] << endl;
            }
             
            int main()
            {
            char a[2][3];
            Test(a);
            return 0;
            }

结果报错:

1
            2
            
// error C2664: “Test”: 不能将参数 1 从“char [2][3]”转换为“char  **”
            //                          与指向的类型无关;转换要求 reinterpret_cast、C  样式转换或函数样式转换

于是乎,我看了下《C专家编程》里10.5节—使用指针向函数传递一个多维数组

方法一:

函数是:

1
            
void fun1(int arr[2][3]);

这种方法导致只能处理2行3列的int型数组。

方法二:

可以省略第一维的长度。

函数是:

1
            
void fun2(int arr[][3]);

这种方法的限制略微宽松了一些,但是还是只能处理每行是3个整数长度的数组。

函数也可以写成:

1
            
void fun2_2(int (*arrr)[3]);

方法三:

创建一个一维数组,数组中的元素是指向其他东西的指针。也可以说是二级指针。

函数是:

1
            
int fun3(int **arr);

注意:只有把二维数组改为一个指向向量的指针数组的前提下才可以这么做!

比如:

1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            
#include <iostream> 
            using namespace std;
             
            void test(char **ptr)
            {
            cout << *ptr << endl;
            }
             
            int main()
            {
            char *p[3] = {"abc", "def", "ghi"};
            test(p);
            return 0;
            }

在《C专家编程》10.3节的小启发里讲的很透彻:(以下这段文字及对比一定要认真分析!)

数组和指针参数是如何被编译器修改的?

数组名被改写成一个指针参数”规则并不是递归定义的。数组的数组会被改写成“数组的指针”,而不是“指针的指针”:

实参                                                     所匹配的形参

数组的数组          char c[8][10];                  char (*)[10];          数组指针

指针数组             char *c[10];                     char **c;               指针的指针

数组指针(行指针)  char (*c)[10];                  char (*c)[10];        不改变

指针的指针           char **c;                         char **c;               不改变

我在CSDN上专门为这个问题提问过:

http://topic.csdn.net/u/20101221/12/da817bda-4e88-44df-bdf8-40e8f44aacb8.html?2076366575

最后我总结下讨论结果:

只要实参的类型与形参的类型一致(或可转换)就行。

为什么这么说呢?

piaojun_pj朋友给了一段代码,分析得很给力:

1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            15
            16
            17
            18
            19
            20
            21
            22
            23
            24
            25
            26
            27
            28
            
// VectorTest.cpp : 定义控制台应用程序的入口点。 
            // 
             
            #include "stdafx.h" 
            #include <iostream> 
            using namespace std;
             
            int _tmain(int argc, _TCHAR* argv[])
            {
            int arr1[3];
            int arr2[3];
            int arr3[3];
            int * ptr;
            // ptr1是一个指向 int [3] 的指针,即ptr的类型和&arr1的类型是一样的,注意:arr1指向的内存区域定长 
            int ptr1[3][3]={{1,2,3},{1,2,3},{1,2,3}};
            // ptr2是一个指向 int * 的指针,即ptr2的类型和&ptr是一样的,注意:ptr指向的内存区域不定长 
            int * ptr2[3]={arr1,arr2,arr3};
            // ptr3是一个指向 int [3] 的指针,即ptr3的类型和&arr1的类型是一样的,注意:arr1指向的内存区域定长 
            int(* ptr3)[3]=&arr1;
            ptr3=ptr1; // 没错,他们的类型相同 
            // ptr3=ptr2;//error 无法从“int *[3]”转换为“int (*)[3] 
            // ptr4是一个指向 int * 的指针,即ptr4的类型和&ptr是一样的,注意:ptr指向的内存区域不定长 
            int ** ptr4;
            //ptr4=&arr1; //error 无法从“int (*)[3]”转换为“int ** 
            ptr4=ptr2; // 没错,他们的类型相同 
            //ptr4=ptr3; // error 无法从“int (*)[3]”转换为“int ** 
            return 0;
            }
From: http://www.wutianqi.com/?p=1822


posted on 2012-01-12 09:30 逛奔的蜗牛 阅读(5082) 评论(2)  编辑 收藏 引用 所属分类: C/C++

评论

# re: C++:二维数组和二级指针的传递问题 2013-07-24 15:04 leafcloudsky
想问楼主一个问题,关于何时用delete[]:
Point是个自定义的类,GetX获取x坐标值。

int len = 3;
Point (*arr2)[5] = new Point[len][5];

for (int i=0; i<len; i++)
{
for (int j=0; j<5; j++)
{
cout <<arr2[i][j].GetX()<<" ";
}
cout<<endl;
}

delete arr2; // 发现这里和delete []arr2效果一样的。为什么?

但如果是以下方式:
Point **arr1 = new Point*[3];
for (int i=0; i<3; i++) arr1[i] = new Point[5];
必须用delete[]p才能正确释放,正确的调用析构函数,不明白到底什么区别?

请赐教~   回复  更多评论
  

# re: C++:二维数组和二级指针的传递问题 2014-02-18 15:25 vstar
可以看看effective C++这本书关于new与delete成对使用这章,原因大概如下:
定义Point (*arr2)[5] = new Point[len][5];时已经指明了new的arr2是指向数组的,对编译器而言,会在管理的时候加上这个信息,调用delete会把arr2当作delete []掉,而Point **arr1 = new Point*[3]; 定义arr1只告诉编译器这是一个二级指针,没有其他附加信息,如果要正确的释放arr1指向的内存,就必须使用delete[]告诉编译器。  回复  更多评论
  


只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理