多维数组的指针类型转换和参数传递

原创 2015年07月10日 11:05:15

总结:
一维和多维数组的数组名,是一个指针,这个指针指向的是该数组的第一个“元素”。

例1:
char *p0;
char buf0[2] = {1};
p0 = buf0;

char *p0; 表示定义一个指向char型的指针。便于理解可以写成char (*p0); *p0是指针,指向 char类型。

例2:
char (*p1)[4];
char buf1[2][4] = {1};
p1 = buf1;
printf(“%d:size(p1):%d\n”, LINE,(int)(p1+1) - (int)p1);
printf(“%d:size(buf1):%d\n”, LINE, (int)(buf1+1) - (int)buf1);

char (p1)[4];表示定义一个char ()[4]型的指针。
(int)(p1+1) - (int)p1的值为4;
(int)(buf1+1) - (int)buf1) 的值为4;
buf1指向它的第一个元素buf1[0], buf1[0]的类型是char (*)[4]。Buf1++就是指向它的第二个元素buf[1]。数组本身是没有多维的概念。只有一维的概念。

例3:
char (*p2)[2][4];
char buf2[2][2][4] = {1};
p2 = buf2;
p2 = &buf2[1];
printf(“%d:size(p2):%d\n”, LINE, (int)(p2+1) - (int)p2);
printf(“%d:size(buf2):%d\n”,LINE, (int)(buf2+1) - (int)buf2);
printf(“%d:size(buf2[1]):%d\n”, LINE, (int)(buf2[1]+1) - (int)buf2[1]);

同理分析,p2是指向char (*)[2][4]型的指针。(int)(p2+1) - (int)p2的值为8.
Buf2是指向它的第一个元素buf2[0], buf2[0]的类型是char (*)[2][4]。
(int)(buf2[1]+1) - (int)buf2[1]的值为4
buf2[1]的类型是char ()[4]. &buf2[1]类型是char ()[2][4].

要注意:char* a[4]; 和 char (a)[4]的区别, 一个类型是char , 一个类型是char (*)[4]

#include <stdio.h>
#include <unistd.h>

char buf[2][4][2] = {
    {{1,2},{3,4},{5,6},{7,8}},
    {{11,12},{13,14},{15,16},{17,18}}
};

/*函数返回数组的3种方式*/
//第一种方式,直接把数组指针强转void *返回,使用的时候再强转成真实的类型
void* fun()
{
    return &buf[1]; 
}
//第二种方式,利用typedef定义一个数组指针类型,作为函数的返回值类型
typedef char (*R)[4][2];

R fun1()
{
    return &buf[1]; 
}
//第三种方式,直接定义。
char (*fun2())[4][2]
{
    return &buf[1]; 
}

/*函数参数为数组的测试*/
//char (*buf)[4]是一个指针,它的类型char (*)[4]
 void fun3(char (*buf)[4])
{
    buf++; 
    printf("%d:size(buf):%d\n", __LINE__, (int)(buf+1) - (int)buf);
}
// char buf[4]是定义一个指针buf,类型就是char *,4这里没意义)
void fun4(char buf[4])
{
    char a[2][4];
    buf++;  
    //a = &buf; //buf因为是char *,取地址后为char **,不匹配报错
    printf("%d:size(buf):%d\n", __LINE__, (int)(buf+1) - (int)buf);
}
// char buf[4]是定义一个指针buf,类型就是char *
void fun5(char buf[])
{
    char a[2][4];
    //a = &buf; //buf因为是char *,取地址后为char **,不匹配报错
    buf++; 
    printf("%d:size(buf):%d\n", __LINE__, (int)(buf+1) - (int)buf);
}
//定义指针buf,类型char (*)[][4].  4在这里有意义
void fun6(char buf[2][4])
{
    printf("%d:buf[0][0]=%d\n", __LINE__, buf[0][0]);
    buf[0][0] = 5;
    printf("%d:buf[0][0]=%d\n",__LINE__, buf[0][0]);
    printf("%d:size(buf):%d\n", __LINE__, (int)(buf+1) - (int)buf);
}
//定义指针buf,类型char (*)[][4].  4在这里有意义
void fun7(char buf[][4])
{
    printf("%d:buf[0][0]=%d\n", __LINE__, buf[0][0]);
    buf[0][0] = 5;
    printf("%d:buf[0][0]=%d\n",__LINE__, buf[0][0]);
    printf("%d:size(buf):%d\n", __LINE__, (int)(buf+1) - (int)buf);
}
//定义指针buf,类型char (*)[2][4].  24在这里有意义
void fun8(char (*buf)[2][4])
{
    buf++;
    printf("%d:size(buf):%d\n", __LINE__, (int)(buf+1) - (int)buf);
}
int main(int argc, char *argv[])
{
    char (*p)[4][2];
    printf("%d:size(p):%d\n", __LINE__, (int)(p+1) - (int)p);
    printf("%d: %d,%d\n", __LINE__, buf[1][0][0], buf[1][0][1]);
    p = &buf[1];
    printf("%d: %d,%d\n", __LINE__, (*p)[0][0],(*p)[0][1]);
    p = fun();
    p = fun1();
    p = fun2();

    char *p0;
    char buf0[2] = {1};
    p0 = buf0;

    char (*p1)[4];
    char buf1[2][4] = {1};
    p1 = buf1;
    printf("%d:size(p1):%d\n", __LINE__,(int)(p1+1) - (int)p1);
    printf("%d:size(buf1):%d\n", __LINE__, (int)(buf1+1) - (int)buf1);  

    char (*p2)[2][4];
    char buf2[2][2][4] = {1};
    p2 = buf2;  
    p2 = &buf2[1];
    printf("%d:size(p2):%d\n", __LINE__, (int)(p2+1) - (int)p2);
    printf("%d:size(buf2):%d\n",__LINE__, (int)(buf2+1) - (int)buf2);
    printf("%d:size(buf2[1]):%d\n", __LINE__, (int)(buf2[1]+1) - (int)buf2[1]);

    char buf3[2][4] = {3};
    fun3(buf3);
    fun4(buf3[0]);


    fun5(buf3[0]);
    fun6(buf3);
    fun7(buf3);
    fun8(&buf3);

    return 0;   
}
运行结果:
gjt@ubuntu:~/test$ ./a.out 
72:size(p):8
73: 11,12
75: 11,12
87:size(p1):4
88:size(buf1):4
94:size(p2):8
95:size(buf2):8
96:size(buf2[1]):4
32:size(buf):4
39:size(buf):1
46:size(buf):1
51:buf[0][0]=3
53:buf[0][0]=5
54:size(buf):4
58:buf[0][0]=5
60:buf[0][0]=5
61:size(buf):4
66:size(buf):8
gjt@ubuntu:~/test$
版权声明:本文为博主原创文章,未经博主允许不得转载。

C/C++二维数组的参数传递与二维指针

在进行函数参数传递的时候,常常需要把一组数据传递给函数,我们知道一维数组在进行函数参数传递的时候,以数组名作为形参就可以,因为数组名就表示该数组的首地址,在函数内部也直接可以用[]符号访问。 那么二维...
  • u013752202
  • u013752202
  • 2015年11月06日 23:06
  • 5454

Go语言的传参和传引用[转]

目录[-] 传参和传引用的问题传slice不是传引用!什么叫传引用?为什么传slice不是传引用?为什么很多人误以为slice是传引用呢?传指针和传引用是等价的吗?所有类型的函数参数都是传值的!那...
  • future_challenger
  • future_challenger
  • 2015年09月14日 13:29
  • 5540

指针数组数组传参、指针引用传参

指针和数组作为参数传入函数时,传入的是地址,即指向变量的地址和数组的首地址,可以在函数中改变指针或数组的值,但本质上它们还是值的传递(区别于变量的值传递的是:变量值传递不会改变实参原来的值。),我们无...
  • dongchongyang
  • dongchongyang
  • 2016年09月17日 23:47
  • 1480

C/C++中多维数组指针作为函数参数传递程序

  • 2009年04月22日 17:38
  • 26KB
  • 下载

C/C++学习之C提高----C数组的定义、类型、定义数组指针变量、多维数组的本质、多维数组做函数参数、将两个数组中的字符串copy到第三个数组

1.数组的基本概念(1)数组的定义 int a[] = {1, 2}; int b[100] = {1, 3}; int c[200] = {0}; //编译的时候 就已经确定 所有的值 为零 对一维...
  • Daycym
  • Daycym
  • 2017年11月02日 17:41
  • 56

C提高——数组、数组数据类型、数组数据类型指针、多维数组本质等

数组int main() { int a[200] = { 0 }; printf("a=%d\n", a); printf("&a=%d\n", &a); printf...
  • wuseyukui
  • wuseyukui
  • 2016年03月08日 23:26
  • 375

C++ 中复合类型声明的理解(尤其是指针数组/数组指针/多维数组的问题)

这几天看《C++ Primer》第五版感觉还是颇有收获的,澄清了之前很多不是很理解的概念,也知道了好多新用法 首先,先澄清一个误解,就是数组的定义问题,在C中C99标准之后数组定义时...
  • haolexiao
  • haolexiao
  • 2016年12月05日 18:23
  • 461

数组的顺序存储表示和实现:利用可变参数列表实现多维数组的创建,元素赋值等操作

  • 2014年06月09日 09:33
  • 168KB
  • 下载

C/C++指针与多维数组的关系

从二维数组切入分析int a[3][4];我们都知道,数组名就是数组的首地址,那么具体这个首地址(指针)是怎样的类型呢? 我们可以做一个实验,让编译器来告诉我们。#include int main(...
  • u012662905
  • u012662905
  • 2016年02月21日 09:18
  • 308

深入浅出C指针(三)多维数组

1.概念 如果某个数组的维数不止1个,它就被称为多维数组。例如,下面这个声明: int matrix[6][10]; 创建了一个包含60个元素的矩阵。但是,它是6行每行10个元素,还是10行每行...
  • aksnzhy
  • aksnzhy
  • 2012年03月23日 10:26
  • 4395
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:多维数组的指针类型转换和参数传递
举报原因:
原因补充:

(最多只允许输入30个字)