c语言指针和数组都有

㈠ c语言中怎样理解数组和指针

数组和指针的关系

一、数组的数组名其实可以看作一个指针。看下例：

例1：

int array[10]={0,1,2,3,4,5,6,7,8,9},value;

value=array[0];//也可写成：value=*array;

value=array[3];//也可写成：value=*(array+3);

value=array[4];//也可写成：value=*(array+4);

上例中，一般而言数组名array代表数组本身，类型是int [10]，但如果把array看做指针的话，它指向数组的第0个单元，类型是int *，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。

二、指针数组的定义及使用

例2：

char *str[3]={ //注意指针数组的定义及初始化格式

"Hello,this is a sample!",

"Hi,good morning.",

"Hello world"

};

char s[80]；

strcpy(s,str[0]);//也可写成strcpy(s,*str);

strcpy(s,str[1]);//也可写成strcpy(s,*(str+1));

strcpy(s,str[2]);//也可写成strcpy(s,*(str+2));

上例中，str是一个三单元的数组，该数组的每个单元都是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0号单元，它的类型是char**，它指向的类型是char *。
*str也是一个指针，它的类型是char*，它所指向的类型是char，它指向的地址是字符串"Hello,this is a sample!"的第一个字符的地址，即'H'的地址。 str+1也是一个指针，它指向数组的第1号单元，它的类型是char**，它指向的类型是char *。

*(str+1)也是一个指针，它的类型是char*，它所指向的类型是char，它指向"Hi,good morning."的第一个字符'H'，等等。

三、数组名小结：
声明了一个数组TYPE array[n]，则数组名称array就有了两重含义：第一，它代表整个数组，它的类型是TYPE [n]；第二，它是一个指针，该指针的类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不能修改的，即类似array++的表达式是错误的。

在不同的表达式中数组名array可以扮演不同的角色。

（1）在表达式sizeof(array)中，数组名array代表数组本身，故这时sizeof函数测出的是整个数组的大小。

（2）在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof(*array)测出的是数组单元的大小。

（3）表达式array+n（其中n=0，1，2，....。）中，array扮演的是指针，故array+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故sizeof(array+n)测出的是指针类型的大小。

四、数组指针的定义及使用：

例3：

int array[10];

int (*ptr)[10]; //数组指针ptr，指向一个数组int[10]

ptr=&array;

上例中ptr是一个指针，它的类型是int (*)[10]，他指向的类型是int [10]，我们用整个数组的首地址来初始化它。在语句ptr=&array中，array代表数组本身。

五、对指针和数组执行sizeof操作的结果：
sizeof(指针名称)测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者。例如：

int (*ptr)[10];

则在32位程序中，有：

sizeof(int(*)[10])==4

sizeof(int [10])==40

sizeof(ptr)==4

实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小。

㈡ c语言中关于指针和数组的问题

你这个等于说就是p1依次被赋值为“you failed”和 “you passed”中的字符。你这应该是51单片机吧。
数组和指针关系：
其实数组的名就是一个指针，只不过是一个常量指针比如pass可以当做指针，因为他指向了一个地址×pass就是m1这个指针的地址

㈢ C语言指针和数组的关系

指针和数组是两种不同的数据结构:
指针:逻辑结构是:长整型的类型,表示的是内存地址,它只能存放内存字节的编号,它的意义是表示某个字节在内存中的编号.物理结构是:占四个字节的一个长整型内存空间.特点是:它保存内存地址的编号.
数组:逻辑结构是:由多个并列关系的元素构成,各数组元素之间的地位是平等的.物理结构是:存储在一块连续的内存空间,逻辑相邻的元素存放在相邻的物理单元内.特点是:数组名称同时表示该块内存空间的起始地址,数组元素可以定义为任何数据类型.

㈣ C语言：简述一下“数组和指针的关系”

一、概念

• 数组：数组是用于储存多个相同类型数据的集合。

• 指针：指针相当于一个变量，但是它和不同变量不一样，它存放的是其它变量在内存中的地址。

二、赋值、存储方式、求sizeof、初始化等

1.赋值

同类型指针变量可以相互赋值，数组不行，只能一个一个元素的赋值或拷贝

2.存储方式

• 数组：数组在内存中是连续存放的，开辟一块连续的内存空间。数组是根据数组的下进行访问的，多维数组在内存中是按照一维数组存储的，只是在逻辑上是多维的。

数组的存储空间，不是在静态区就是在栈上。

• 指针：指针很灵活，它可以指向任意类型的数据。指针的类型说明了它所指向地址空间的内存。

指针：由于指针本身就是一个变量，再加上它所存放的也是变量，所以指针的存储空间不能确定。

3.求sizeof

• 数组：

数组所占存储空间的内存：sizeof（数组名）
数组的大小：sizeof（数组名）/sizeof（数据类型）

• 指针：

在32位平台下，无论指针的类型是什么，sizeof（指针名）都是4，在64位平台下，无论指针的类型是什么，sizeof（指针名）都是8。

关于指针和数组求sizeof，我在之前的博客中写过，现将连接贴上：
https://blog.csdn.net/cherrydreamsover/article/details/81589838

4.初始化

• 数组：

• （1）char a[]={"Hello"};//按字符串初始化，大小为6.（2）char b[]={'H','e','l','l'};//按字符初始化（错误，输出时将会乱码，没有结束符）（3）char c[]={'H','e','l','l','o',''};//按字符初始化1234



这里补充一个大家的误区，就是关于数组的创建和销毁，尤其是多维数组的创建与销毁。
（1）一维数组：
int* arr = new int[n];//创建一维数组
delete[] arr;//销毁
（2）二维数组：
int** arr = new int*[row];//这样相当于创建了数组有多少行
for(int i=0;i<row;i++)
{
arr[i] = new int[col];//到这里才算创建好了
}
//释放
for(int i=0;i<row;i++)
{
delete[] arr[i];
}
delete[] arr;

• 指针：

• //（1）指向对象的指针：（()里面的值是初始化值）int *p=new int(0) ; delete p;//（2）指向数组的指针：(n表示数组的大小，值不必再编译时确定，可以在运行时确定)int *p=new int[n]; delete[] p;//（3）指向类的指针：(若构造函数有参数，则new Class后面有参数，否则调用默认构造函数，delete调用析构函数)Class *p=new Class; delete p;//（4）指针的指针：（二级指针）int **pp=new (int*)[1];


• pp[0]=new int[6];delete[] pp[0];12345678910



这里我们区分两个重要的概念：指针数组、数组指针。

（1）指针数组：它实际上是一个数组，数组的每个元素存放的是一个指针类型的元素。

• int* arr[8];//优先级问题：[]的优先级比*高//说明arr是一个数组，而int*是数组里面的内容//这句话的意思就是：arr是一个含有8和int*的数组1234





三、传参

• 数组：

数组传参时，会退化为指针，所以我们先来看看什么是退化！
（1）退化的意义：C语言只会以值拷贝的方式传递参数，参数传递时，如果只拷贝整个数组，效率会大大降低，并且在参数位于栈上，太大的数组拷贝将会导致栈溢出。
（2）因此，C语言将数组的传参进行了退化。将整个数组拷贝一份传入函数时，将数组名看做常量指针，传数组首元素的地址。

1.一维数组的传参

• #include <stdio.h>//传参方式正确//用数组的形式传递参数，不需要指定参数的大小，因为在一维数组传参时，形参不会真实的创建数组，传的只是数组首元素的地址。（如果是变量的值传递，那么形参就是实参的一份拷贝）void test(int arr[])


• {}//传参方式正确//不传参数可以，传递参数当然也可以void test(int arr[10])


• {}//传参方式正确//一维数组传参退化，用指针进行接收，传的是数组首元素的地址void test(int *arr)


• {}//传参方式正确//*arr[20]是指针数组，传过去的是数组名void test2(int *arr[20])


• {}//传参方式正确//传过去是指针数组的数组名，代表首元素地址，首元素是个指针向数组的指针，再取地址，就表示二级指针，用二级指针接收void test2(int **arr)


• {}int main()


• {int arr[10] = {0};int *arr2[20] = {0};


• test(arr);


• test2(arr2);


• }



2.二维数组的传参

• //传参正确//表明二维数组的大小，三行五列void test(int arr[3][5])


• {}//传参不正确//二维数组的两个方括号，不能全部为空，也不能第二个为空，只能第一个为空void test(int arr[][])


• {}//传参正确//可以写成如下这样传参形式，但是不能写int arr[3][]void test(int arr[][5])


• {}//传参不正确//arr是一级指针，可以传给二维数组，但是不能正确读取void test(int *arr)


• {}//传参不正确//这里的形参是指针数组，是一维的，可以传参，但是读取的数据不正确void test(int* arr[5])


• {}//传参正确//传过去的是二维数组的数组名，即数组首元素的地址，也就是第一行的地址，第一行也是个数组，用一个数组指针接收void test(int (*arr)[5])


• {}//传参不正确//可以传参，但是在读取的时候会有级别不同的问题void test(int **arr)


• {}int main()


• {int arr[3][5] = {0};


• test(arr);


• }



• 指针：

1.一级指针传参

当函数参数部分是一级指针时，可以接受什么参数例如：test（int*p）

（1）可以是一个整形指针
（2）可以是整型变量地址
（3）可以是一维整型数组数组名

• #include <stdio.h>void print(int *p, int sz)


• {int i = 0;for(i=0; i<sz; i++)


• {printf("%d ", *(p+i));


• }


• }int main()


• {int arr[10] = {1,2,3,4,5,6,7,8,9};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一级指针p，传给函数print(p, sz);return 0;


• }



2.二级指针传参

即当函数参数部分是二级指针时，可以接受什么参数例如：test（int**p）

（1）二级指针变量
（2）一级指针变量地址
（3）一维指针数组的数组名

• #include <stdio.h>void test(int** ptr)


• {printf("num = %d ", **ptr);


• }int main()


• {int num = 10;int*p = &num;int **pp = &p;


• test(pp);


• test(&p);return 0;


• }



四、函数指针、函数指针数组、函数指针数组的指针

1.函数指针

• void test()


• {printf("hehe ");


• }//pfun能存放test函数的地址void (*pfun)();



函数指针的形式：类型(*)( )，例如：int (*p)( ).它可以存放函数的地址，在平时的应用中也很常见。

2.函数指针数组

形式：例如int (*p[10])( );
因为p先和[ ]结合，说明p是数组，数组的内容是一个int (*)( )类型的指针
函数指针数组在转换表中应用广泛

3.函数指针数组的指针

指向函数指针数组的一个指针，也就是说，指针指向一个数组，数组的元素都是函数指针

• void test(const char* str)


• {printf("%s ", str);


• }int main()


• {//函数指针pfunvoid (*pfun)(const char*) = test;//函数指针的数组pfunArrvoid (*pfunArr[5])(const char* str);


• pfunArr[0] = test;//指向函数指针数组pfunArr的指针ppfunArrvoid (*(*ppfunArr)[10])(const char*) = &pfunArr;return 0;


• }

㈤ C语言里数组和指针有什么关系

C里面数组名字就是数组这一块内存空间的指针。
比如 int a[10], 你可以通过a[0]来访问数组里面的第一个元素，也可以使用*a，这类似于 int *a类型的数组。

㈥ C语言数组与指针

structord*p=dt//这里p是structord*类型指针，赋值后指向dt，相当于操作的是dt[0]，起作用的就是第一和第二个数：1,2

structSp=data[1]//这里是重新定义了一个structS类型的变量，会分配一个结构体的内存空间，保存data[1]的拷贝，操作在这个拷贝上进行，起作用的第三和第四个数。初始化时个数不足的话，默认是0

㈦ C语言中，指针和数组的区别和联系

区别：C语言把内存划分成四个区，它把一般的变量和数组等存在于内存中的栈区，所以数组在C语言的定义中只是一组同类型的普通变量，即使这个变量有可能是指针。所以他的作用比指针小的很多，而指针可以指向任何区的任何数据，所以就会觉得指针和数组名很像，但是必须要注意的是，数组名只是指针中的一种，它是指针中只指向栈区的且指针的移动范围是有限的，即数组长度。而且数组在定义之初就已经有了自己的内存，一般的指针如果未指向某一个内存块时，它是没有自己的内存的，即所谓的野指针。
联系：如上面所说，数组只是定义在栈区的一个连续变量，它的首地址就是一个指针。
总结：不仅数组有指针，所有变量都有指针，指针说白了就是内存中的地址，就像一个房间必须有一个房间号。在C/C++语言中定义一个指针，就是在栈区开辟一个内存空间用来存放它指向的内存地址，然后给指针赋值，就是把地址值赋值给刚才开辟的内存空间，然后通过访问该内存中的地址值来间接访问该地址下存放的数据。如果该地址值指向的是一块静态存储区，如字符串常量等，当然就不可以修改指向的内容啦。

经验之谈，楼楼加分啊

㈧ c语言指针和数组

C的多维数组与指针确实是一个比较令人迷惑的问题。数组名是一个地址，实际上，a、a[0]以及&a[0][0]的值是一样的，但这并不是说它们三者是一样的。我们知道指针是有类型的，int *p和int (*p)[4]是不一样的，同样，我们可以认为地址也是有类型的(虽然这样说可能有点不恰当)，只有相应类型的地址和指针才可以匹配，我们可以把二维数组a看成一个一维数组，它的每一个元素是一个int〔4〕的一维数组，因此a的“类型”是int〔4〕*,所以只能与int (*p)[4]匹配。而a[0]是一个一维数组，它的元素类型是int，因此a〔0〕的“类型”是int*,和int *p匹配。换句话说，值相等并能说明二者相同。可以参考谭浩强<<C程序设计>>多维数组与指针一节

如果定义int *p=&a[0][0],int (*q)[4]=a，我们如果用printf输出p和q的值，可以看到二者的值是相等的，但是显然p和q不是一样的，直接体现在我们进行p++和q++操作时指针移动的字节数是不一样的

㈨ 关于C语言指针和数组

执行了两次pa++后，指针pa由原来指向胡a[0]改为指向a[2];而pa[-1]代表2-1=1，即pa指向了a[1];
引入指针变量后，就可以用两种方法来访问数组元素了。
第一种方法为下标法，即用a[i]形式访问数组元素。
第二种方法为指针法，即采用*(pa+i)形式，用间接访问的方法来访问数组元素。
望采纳