指针数组及指向一维数组的指针讲解

第9章指针和数组——指针和一维数组之间的关系

一维数组元素的引用

⏹数组名代表数组的首地址&a[0]

⏹&a[i] ↔ (a + i)

⏹a+1不是加上1个字节，取决于a的基类型

⏹ a + 1→ a + sizeof(基类型)

⏹ a + i→ a + i*sizeof(基类型)

int a[5];

指向数组的指针

问题：为什么一个int 型指针能指向一个int 型的一维数组呢？

int *p = a; int a[5];

的基类型

指向数组的指针

的基类型 int *p = a; int a[5];

问题：*p++与(*p)++有何区别？ 当指针指向数组时，

小结

⏹指针与一维数组间的关系的关键

⏹牢记a[i]↔*(a+i)

⏹一维数组和指针做函数形参是等同的

⏹数组和指针并非在所有情况下都是等同的

●sizeof(数组名）和sizeof(指针变量名），不可互换

一维数组与指针

1 关于数组元素地址的说明：

一维数组在内存储单元中是连续存放的。

数组名a代表数组的首地址即a[0]的地址，&a[0]，是一个地址常量，是数组存储单元最开头第一个字节的地址。

既然是一个地址值就可以给指针变量

Int a[5],*pa=a; (数组名即数组首地址赋给指针变量，指针变量指向数组首个元素）

Int a[5],*pa=&a[0];（遇上面等价）。

Int a[5],*pa=&a[3];

2 数组元素的引用

(1)引用各个数组元素的地址值：

①通过使用数组名

定义一个数组a[5] 则a代表&a[0] a+1,a+2,a+3,a+4 依次代表&a[1],&a[2],&a[3],&a[4]。这里要注意，a的值为地址值，且a为一个地址常量，是一个常量，不能用来赋值，自加自减等。a+n的计算规则是地址值的计算规则，即当前地址值（可以用十进制表示）加上n乘以数组元素的数据类型所占的字节数,代表数组元素a[n]。

可以通过循环语句和scanf语句来将输入的数存放到一位数组中，即

Int a[5];

F0r(i=0;i<5;i++)

Scang(“%d”,a+i);

②通过指针

如int a[5],*pa=a; 等价于int a[5],*pa=&a[0];

Int a[5],*pa;

For（pa=a,i=0;i<5;i++)

Scanf(“%d”,pa++);

或者

For(pa=a,i=0;i<5;i++)

{Scanf(“%d”,pa);pa++;}

或者

For(pa=a;pa-a<5;pa++)

指针数组和数组指针释放

指针数组和数组指针是C语言中常见的概念，它们在内存管理和数据访问方面起着重要作用。本文将从人类视角出发，以真实的叙述方式介绍指针数组和数组指针的释放。

在C语言中，指针数组和数组指针都是指针的应用形式，它们与普通的数组有所不同。指针数组是一个数组，其元素是指针类型；而数组指针是一个指针，指向一个数组。两者在释放内存时需要注意不同的操作。

我们来看指针数组的释放。假设我们有一个指针数组ptrArray，其中包含了若干个指针。在释放内存之前，我们需要逐个释放数组中的指针指向的内存块。可以通过循环遍历数组的方式，依次释放每个指针指向的内存。释放完毕后，再使用free函数释放指针数组本身所占用的内存。这样，我们就完成了指针数组的释放过程。

接下来，我们来看数组指针的释放。假设我们有一个数组指针pArray，指向一个数组。在释放内存之前，我们只需使用一次free 函数即可释放整个数组所占用的内存。因为数组指针指向的是一个连续的内存块，只需释放一次即可。

需要注意的是，在释放指针数组和数组指针时，应确保内存的正确释放顺序。先释放指针数组中的指针，再释放指针数组本身；先释放数组指针指向的内存，再释放数组指针本身。这样可以避免内存

泄漏和悬空指针的问题。

总结一下，指针数组和数组指针的释放方法是不同的。对于指针数组，需要逐个释放数组中的指针，并最后释放指针数组本身；对于数组指针，只需一次释放即可。在释放内存时，需要注意释放的顺序，以确保内存的正确释放。

通过以上的叙述，希望读者能够更好地理解指针数组和数组指针的释放方法，并能够正确地应用于实际的程序开发中。同时也希望读者能够通过本文的描述，感受到指针数组和数组指针的重要性，以及在内存管理中的作用。让我们一起努力，深入理解指针数组和数组指针，提升自己在C语言中的编程能力。

C语言/C++学习联盟

&寻址运算符

*指针运算符

&寻址运算符与*指针运算符

具有相同的优先级，自右向左结合。

int a;

Int *p=&a;

*&a---->a

&*p---->p

int *p=&a;

指针的赋值：

声明的时候：赋值int *p=&a;

先声明再赋值：int a; int *p; p=&a;

*p单独出现的时候是数据。

int *p 前面带有数据类型。

一、一维数组和指针。

1、一维数组地址。

就是数组第一个元素的地址。

#include

int main()

{

int arr[5];

printf("%d\n", &arr[0]);

return 0;

}

定义一个指针，把一维数组的首地址&a[0]赋予这个指针ptr，就说ptr指向数组a[5]。一个数组的数组名就是这个数组的首地址。arr[5] &arr[0] == arr == ptr

2、对一维数组进行输入和输出。

A、指针不发生改变。

#include

int main()

{

//int arr[5];

//for (int i = 0; i < 5; i++)

//{

// arr[i] = i + 1;

//}

//for (int i = 0; i < 5; i++)

//{

// printf("arr[%d]=%d\n", i, arr[i]);

//}

int arr[5];

int *p = arr; // int *p=&arr[0];

for (int i = 0; i < 5; i++) //i 0-4

{

//只要指针变量声明完之后p就是地址*p就是陪这个地址指向的变量。

【转】指针与数组的区别和联系

⼀．指针与数组的联系：

指针与数组是C语⾔中很重要的两个概念，它们之间有着密切的关系，利⽤这种关系，可以增强处理数组的灵活性，加快运⾏速度，本⽂着重讨论指针与数组之间的联系及在编程中的应⽤。

1．指针与数组的关系

当⼀个指针变量被初始化成数组名时，就说该指针变量指向了数组。如：

1　char str[20], *ptr;

2

3 ptr=str;

ptr被置为数组str的第⼀个元素的地址，因为数组名就是该数组的⾸地址，也是数组第⼀个元素的地址。此时可以认为指针ptr就是数

组str（反之不成⽴），这样原来对数组的处理都可以⽤指针来实现。如对数组元素的访问，既可以⽤下标变量访问，也可以⽤指针访问。

2．指向数组元素的指针

若有如下定义：

　int a[10], *pa;

pa=a;

则p=&a[0]是将数组第1个元素的地址赋给了指针变量p。

实际上，C语⾔中数组名就是数组的⾸地址，所以第⼀个元素的地址可以⽤两种⽅法获得：p=&a[0]或p=a。

这两种⽅法在形式上相像，其区别在于：pa是指针变量，a是数组名。值得注意的是：pa是⼀个可以变化的指针变量，⽽a是⼀个常数。因为数组⼀经被说明，数组的地址也就是固定的，因此a是不能变化的，不允许使⽤a＋＋、＋＋a或语句a＋=10，⽽pa＋＋、＋

＋pa、pa＋=10则是正确的。由此可见，此时指针与数组融为⼀体。

3．指针与⼀维数组

理解指针与⼀维数组的关系，⾸先要了解在编译系统中，⼀维数组的存储组织形式和对数组元素的访问⽅法。

⼀维数组是⼀个线形表，它被存放在⼀⽚连续的内存单元中。C语⾔对数组的访问是通过数组名（数组的起始地址）加上相对于起始地址的相对量（由下标变量给出），得到要访问的数组元素的单元地址，然后再对计算出的单元地址的内容进⾏访问。通常把数据类型所占单元的字节个数称为扩⼤因⼦。

【C语⾔】-指向⼀维数组元素的指针

本⽂⽬录

说明：这个C语⾔专题，是学习iOS开发的前奏。也为了让有⾯向对象语⾔开发经验的程序员，能够快速上⼿C语⾔。如果你还没有编程经验，或者对C语⾔、iOS开发不感兴趣，请忽略

前⾯我们已经学习了指针，如果指针存储了某个变量的地址，我们就可以说指针指向这个变量。数组及其数组元素都占有存储空间，都有⾃⼰的地址，因此指针变量可以指向整个数组，也可以指向数组元素。

⼀、⽤指针指向⼀维数组的元素

1// 定义⼀个int类型的数组

2int a[2];

3

4// 定义⼀个int类型的指针

5int *p;

6

7// 让指针指向数组的第0个元素

8 p = &a[0];

9

10// 修改所指向元素的值

11 *p = 10;

12

13// 打印第⼀个元素的值

14 printf("a[0] = %d", a[0]);

输出结果：，说明已经通过指针间接修改了数组元素的值，跟指向⼀个普通int类型变量是⼀样的。

由于数组名代表着数组的⾸地址，即a == &a[0]，因此第8⾏代码等价于：

// 让指针指向数组的第0个元素

p = a;

内存分析图如下，⼀个指针变量占⽤2个字节，⼀个int类型的数组元素占⽤2个字节

⼆、⽤指针遍历数组元素

1.最普通的遍历⽅式是⽤数组下标来遍历元素

1// 定义⼀个int类型的数组

2int a[4] = {1, 2, 3, 4};

3

4int i;

5for (i = 0; i < 4; i++) {

6 printf("a[%d] = %d \n", i, a[i]);

数组指针——指向数组的指针（通过指针控制数组）

//⼀维数组

int arr1[5] = { 1,2,3,4,5 };

int(*arrP)[5] = &arr1; //定义数组指针必须⽤&arr1, arr1是数组⾸元素的地址；&arr1是代表数组地址虽然地址都⼀样但是当加1的时候就有区别了，说明还是代表的不同东西for (int i = 0; i < sizeof(arr1) / sizeof(arr1[0]); i++) //当遍历数组是⼀个⽅法时不⽤写死(得到数组的⾏列数)

{

printf("arr1[%d]=%d\n", i, (*arrP)[i]);

}

printf("--------------------------------\n");

//⼆维数组

int arr2[3][5] = { {1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15} };

arrP = arr2; //数组指针指向⼆维数组

for (int i = 0; i < sizeof(arr2) / sizeof(arr2[0]); i++)//当遍历数组是⼀个⽅法时不⽤写死(得到数组的⾏列数)

{

for (int j = 0; j < sizeof(arr2[0]) / sizeof(arr2[0][0]); j++)

{

printf("int[%d][%d]=%d\n", i, j, (*(arrP + i))[j]);// printf("int[%d][%d]=%d\n", i, j, arr2[i][j]);

C语言【指针】一维数组与指针概念

C语言学习笔记----指针【一】

虽然以前学过C语言，但是那个时候才大一，没有认真的学习，最近又回炉看了好久的指针，把我的经验心得写下来和大家一起分享，共同学习。

指针变量

（1）指针就是内存地址；

系统对变量的访问形式有两种：

直接访问：按变量地址存取变量值的方式间接访问：

如上所示，int i=3,然后特殊变量P存放的内容是变量i的地址，利用P来访问变量i。2000是变量i空间的地址。3是i的值。变量P指向变量i，P是指向变量i的指针变量。

（2）定义指针变量： int *P,*p1; float *P;

注意：（1） *号毫无意义，如果硬要说意义的话就是：C语言规定所有变量必须先定义后使用，指针变量也是这样，但是为了表示指针变量的特殊性，所以就加了一个*号。

（2）一个指针变量只能指向同一个数据类型，定义*P为int型，那就不能指向float。

（3）指针变量赋值：int i=3; int *P; P=&i; &是取地址运算符，取i的空间的地址给P。所以P里面存放的是i空间的地址。*P是i空间存放的值，即*P=3；

注意：&i是i空间的地址，是一个整型数据，这个数据赋值给P，但是不能直接给P赋值，如P=1000是不行的，因为变量的地址是由编译系统分配的，用户是不知道的，更不能随便给赋地址值。

（4）&和*辨析：

main()

{

int i=100; int *P;

p=&i;

printf("%d\n",i); 直接访问变量

printf("%d\n",*P); 间接访问变量

}

c语言指针通俗易懂讲解

摘要：

1.引言：指针的概念和作用

2.指针的基本操作：声明、赋值、取值、运算

3.指针与数组：指向数组元素的操作

4.指针与函数：参数传递、返回值

5.指针与字符串：指针操作字符串的方法

6.指针数组和多级指针：理解与使用

7.指针与内存管理：动态内存分配与释放

8.指针在C语言编程中的应用实例

9.指针使用注意事项与避免错误

10.总结：指针在C语言中的重要性

正文：

一、引言：指针的概念和作用

在C语言中，指针是一种特殊的变量，它的值是另一个变量的内存地址。指针可以用于访问和操作内存中的数据，它在C语言编程中具有广泛的应用。掌握指针的使用对于深入学习和应用C语言至关重要。

二、指针的基本操作：声明、赋值、取值、运算

1.声明：声明指针变量时，需要指定指针指向的类型，如int *p；

2.赋值：给指针变量赋值，即指定它指向的内存地址，如p = &a；

3.取值：通过指针访问它指向的变量值，如*p = a；

4.运算：指针之间可以进行加减运算，如p += 10；

三、指针与数组：指向数组元素的操作

1.声明：声明指针变量时，可以指定数组名作为指针的值，如int arr[]和int *p = arr；

2.访问数组元素：通过指针访问数组元素，如*p = arr[0]；

3.遍历数组：使用指针遍历数组，如for (p = arr; p < arr + n; p++)；

四、指针与函数：参数传递、返回值

1.参数传递：使用指针作为函数参数，实现数据在函数间的传递，如函数间传递数组；

2.返回值：使用指针作为函数返回值，如返回指向数组的指针。

C语言中的指针与数组的关系在C语言中，指针和数组是密切相关的概念。指针是一种变量，其存储的是内存地址，而数组是一种固定长度的数据结构，由相同类型的元素组成。本文将详细介绍指针与数组之间的关系，包括指针与数组的声明、访问数组元素的方式以及指针数组的概念。

1. 指针与数组的声明

指针变量和数组的声明方式有所不同。指针变量通过在变量名前添加"*"来声明，而数组则通过在变量名后添加方括号及长度来声明。例如，声明一个整型指针变量和一个包含5个整型元素的数组可以如下所示：

```c

int* ptr; // 声明一个指向整型数据的指针

int arr[5]; // 声明一个包含5个整型元素的数组

```

2. 指针与数组的关系

指针可以通过与数组相关的操作来访问和操作数组元素。可以使用指针来获取数组的首个元素的地址，并通过指针递增来访问数组中的其他元素。例如，下面的示例演示了如何使用指针访问数组元素：```c

int arr[5] = {1, 2, 3, 4, 5};

int* ptr = arr; // 将数组的首个元素的地址赋值给指针

// 通过指针递增访问数组元素

for (int i = 0; i < 5; i++) {

printf("%d ", *(ptr + i));

}

```

输出结果为：1 2 3 4 5。可以看到，通过指针访问数组元素的方式

与直接使用数组名是等效的。

3. 数组名与指针的差异

数组名实际上是数组首元素的地址，因此可以使用数组名来表示指

向数组的指针。数组名在大多数情况下会自动转换为指针类型。例如，下面的代码演示了数组名与指针的等效性：

专题9 指针

9.1 指针变量

9.2 指针与一维数组9.3 指针与二维数组9.4 指针与函数

9.5 指针与动态内存管理

9.2 指针与一维数组

☐数组的地址

☐指向数组元素的指针变量☐通过指针引用数组元素

a

a+99

a+1数组元素的地址a+i ......数组元素a[0]

a[1]...

a[99]

a[i]...

...*a *(a+1)

*(a+99)

*(a+i)......例如：

int a[100];

1 数组的地址a[i]与*(a+i)等价

int a[100],*p=a;int a[100],*p;

p=&a[0];

int a[100],*p;

p=a;

2 指向数组元素的指针变量（1）定义与赋值a[0]

a[1]

a[i]

a[99]

p

☐若指针变量p 指向某个数组元素，则p+i 就指向后面的第i 个元素。☐相当于指针往后移动i 个数组元素的存储空间，实际移动的字节数是每个数组元素所占字节数乘以i 。

a[0]

a[1]

a[i]

a[99]

p p+1

p+i

例如：

int a[100],*p=a;p++;（2）指针的移动思考：设有定义：

int a[100], *p=&a[1];则p+i 指向哪个数组元素？

2 指向数组元素的指针变量

2 指向数组元素的指针变量

（3）两个同类型的指针相减

☐若p1与p2指向同一数组，p1-p2等于两指针间元素的个数。

☐p1+p2 无意义。

例1 分析程序的输出结果。

#include <stdio.h>

int main()

{

int a[10],*p1=&a[2],*p2=&a[5];

深⼊解析C++中的指针数组与指向指针的指针

如果⼀个数组，其元素均为指针型数据，该数组为指针数组，也就是说，指针数组中的每⼀个元素相当于⼀个指针变量，它的值都是地址。

⼀维指针数组的定义形式为：

int【类型名】 *p【数组名】 [4]【数组长度】;

由于[ ]⽐*优先级⾼，因此p先与[4]结合，形成p[4]的数组的形式。然后与p前⾯的“ * ”结合，“ * ”表⽰此数组是指针类型的，每个数组元素都相当于⼀个指针变量，都可以指向整形变量。

注意：不能写成int (*p)[4]的形式，这是指的⼀个指向⼀维数组的指针变量。

使⽤指针数组中各元素分别指向若⼲个字符串，使字符串的处理更加灵活。

复制代码代码如下:

#include<iostream>

using namespace std;

int main(){

void sort(char *p[],int n);

void print(char *p[],int n);

char *name[]={"C","C++","PHP","ASP","","C#","JAVA","BASIC","PASCAL","COBOL"};

int n=10;

sort(name,n);

print(name,n);

return 0;

}

void sort(char *p[],int n){

char *temp;

int i,j,k;

for(i=0;i<n;i++){

k=i;

for(j=i;j<n;j++){

if(strcmp(p[j],p[k])<0){

10.3 数组指针和指向数组的指针变量

一个变量有一个地址，一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。所谓数组的指针是指数组的起始地址，数组元素的指针是数组元素的地址。

10.3.1 指向数组元素的指针

一个数组是由连续的一块内存单元组成的。数组名就是这块连续内存单元的首地址。一个数组也是由各个数组元素(下标变量)组成的。每个数组元素按其类型不同占有几个连续的内存单元。一个数组元素的首地址也是指它所占有的几个内存单元的首地址。

定义一个指向数组元素的指针变量的方法，与以前介绍的指针变量相同。

例如：

int a[10]； /*定义a为包含10个整型数据的数组*/

int *p； /*定义p为指向整型变量的指针*/

应当注意，因为数组为int型，所以指针变量也应为指向int型的指针变量。下面是对指针变量赋值：

p=&a[0];

把a[0]元素的地址赋给指针变量p。也就是说，p指向a数组的第0号元素。

C语言规定，数组名代表数组的首地址，也就是第0号元素的地址。因此，下面两个语句等价：p=&a[0]; p=a;

在定义指针变量时可以赋给初值：

int *p=&a[0];

它等效于：int *p; p=&a[0];

当然定义时也可以写成：

int *p=a;

从图中我们可以看出有以下关系：

p,a,&a[0]均指向同一单元，它们是数组a的首地址，也是0 号元素a[0]的首地址。应该说明的是p是变量，而a,&a[0]都是常量。在编程时应予以注意。

数组指针变量说明的一般形式为：

类型说明符 *指针变量名；