C语言学习----指针和数组

2023-12-15 17:28:06

🌈这篇blog记录一下指针学习~ 主要是关于指针和数组之间的关系,还有指针的使用等~

🍎指针变量是一个变量 其本身也有一个地址 也需要存放,就和int char等类型一样的,也需要有一个地址来存放它

🍌而指针变量 是用于存储其他变量的地址 int char 等类型存储的是对应的值,比如 1 2 3 ‘a’ ‘b’等,但是指针变量存储的就是地址

🍅 可以通过解引用“ * ”来获取指针变量地址的变量对应的值

比如 ptr1是指向utn[0]的指针,那么 ptr1存放的就是utn[0]的地址,我通过解引用就可获取 utn[0]存储的值是多少。

指针和数组

flizny == &flizny[0]; // 数组名是该数组首元素的地址

flizny 和&flizny[0]都表示数组首元素的内存地址(&是地址运算符)。两者都是常量,在程序的运行过程中,不会改变。

但是,可以把它们赋值给指针变量,然后可以修改指针变量的值。注意指针加上一个数时,它的值发生了什么变化(转换说明%p通常以十六进制显示指针的值)。

我们的系统中,地址按字节编址,short类型占用2字节,double类型占用8字节。在C中,指针加1指的是增加一个存储单元。对数组而言,这意味着把加1后的地址是下一个元素的地址,而不是下一个字节的地址。只知道地址不够,因为计算机要知道储存对象需要多少字节(即使指针指向的是标量变量,也要知道变量的类型,否则*pt 就无法正确地取回地址上的值)

int dates[y], *pti;
pti = dates; // or(pti = & dates [0];)

指针的值是它所指向对象的地址。地址的表示方式依赖于计算机内部的硬件。 许多计算机(包括PC和Macintosh)都是按字节编址,意思是内存中的每个字节都按顺序编号。这里,一个较大对象的地址(如double类型的变量)通常是该对象第一个字节的地址。

在指针前面使用*运算符可以得到该指针所指向对象的值。
指针加1,指针的值递增它所指向类型的大小(以字节为单位)。
下面的等式体现了C语言的灵活性:

dates + 2 == &date[2]    // 相同的地址

* (dates + 2) == dates[2]  // 相同的值

以上关系表明了数组和指针的关系十分密切,可以使用指针标识数组的元素和获得元素的值。 从本质上看,同一个对象有两种表示法。实际上,C语言标准在描述数组表示法时确实借助了指针。也就是说,定义ar[n]的意思是 * (ar + n)。可以认为 *(ar + n)的意思是“到内存的ar位置,然后移动n个单元,检索储存在那里的值”。

*(dates + 2) // dates第3个元素的值
*dates + 2  // dates第1个元素的值加2
#include <stdio.h>
#define MONTHS 12
int main(void)
{
    int days[MONTHS] = { 31, 28, 31, 30, 31, 30, 31, 31, 
    30, 31, 30, 31 };
    int index;
    for (index = 0; index < MONTHS; index++)
    printf("Month %2d has %d days.\n", index + 1,
    *(days + index)); //与 days[index]相同
    return 0;
}

这里,days是数组首元素的地址,days + index是元素days[index]的地址 ,而 * (days + index)则是该元素的值,相当于days[index]。for循环依次引用数组中的每个元素,并打印各元素的内容。

这样编写程序是否有优势?不一定。编译器编译这两种写法生成的代码相同。要注意的是,指针表示法和数组表示法是两种等效的方法。该例演示了可以用指针表示数组,反过来,也可以用数组表示指针。 在使用以数组为参数的函数时要注意这点。

函数 数组和指针

关于函数的形参,还有一点要注意。只有在函数原型或函数定义头中,才可以用int ar[]代替int * ar:

int sum (int ar[], int n);

*int ar形式和int ar[]形式都表示ar是一个指向int的指针。但是,int ar[]只能用于声明形式参数。第2种形式(int ar[])提醒读者指针ar指向的不仅仅一个int类型值,还是一个int类型数组的元素。

因为数组名是该数组首元素的地址,作为实际参数的数组名要求形式参数是一个与之匹配的指针。只有在这种情况下,C才会把int ar[]和int * ar解释成一样。也就是说,ar是指向int的指针。由于函数原型可以省略参数名,所以下面4种原型都是等价的:

int sum(int *ar, int n);
int sum(int *, int);
int sum(int ar[], int n);
int sum(int [], int);

但是,在函数定义中不能省略参数名

关于sizeof 的占位符符号 %zd

如果编译器不支持 %zd,用 %u 或 %lu 替换它

printf("The size of marbles is %zd bytes.\n",
sizeof marbles);

关于指针和数组byte的问题

/ sum_arr1.c -- 数组元素之和
// 如果编译器不支持 %zd,用 %u 或 %lu 替换它
#include <stdio.h>
#define SIZE 10
int sum(int ar[], int n);
int main(void)
{
    int marbles[SIZE] = { 20, 10, 5, 39, 4, 16, 19, 26, 31, 20 };
    long answer;
    answer = sum(marbles, SIZE);
    printf("The total number of marbles is %ld.\n", answer);
    printf("The size of marbles is %zd bytes.\n",
    sizeof marbles);
    return 0;
}

int sum(int ar[], int n)   // 这个数组的大小是?
{
    int i;
    int total = 0;
    for (i = 0; i < n; i++)
    total += ar[i];
    printf("The size of ar is %zd bytes.\n", sizeof ar);
    return total;
}

/*该程序的输出如下:
The size of ar is 8 bytes.
The total number of marbles is 190.
The size of marbles is 40 bytes.

注意,marbles的大小是40字节。这没问题,因为marbles内含10个int类型的值,每个值占4字节,所以整个marbles的大小是40字节。

但是,ar才8字节。这是因为ar并不是数组本身,它是一个指向 marbles 数组首元素的指针。我们的系统中用 8 字节储存地址,所以指针变量的大小是 8字节(其他系统中地址的大小可能不是8字节)。简而言之,在程序中,marbles是一个数组, ar是一个指向marbles数组首元素的指针,利用C中数组和指针的特殊关系,可以用数组表示法来表示指针ar。

使用指针形参

/* 使用指针算法 */
int sump(int * start, int * end)
{
    int total = 0;
    while (start < end)
    {
        total += *start;  // 把数组元素的值加起来
        start++;      // 让指针指向下一个元素
        }
    return total;
}
//也可以
total += *start++;

指针start开始指向marbles数组的首元素,所以赋值表达式total += *start把首元素(20)加给total。然后,表达式start++递增指针变量start,使其指向数组的下一个元素。因为start是指向int的指针,start递增1相当于其值递增int类型的大小。

total += *start++;
一元运算符 * 和++的优先级相同,但结合律是从右往左所以start++先求值,然后才是 * start。 也就是说,指针start先递增后指向。

使用后缀形式(即start++而不是++start)意味着先把指针指向位置上的值加到total上,然后再递增指针。如果使用 * ++start,顺序则反过来,先递增指针,再使用指针指向位置上的值。 如果使用(* start)++,则先使用start指向的值,再递增该值,而不是递增指针。这样,指针将一直指向同一个位置,但是该位置上的值发生了变化。 虽然 * start++的写法比较常用,但是*(start++)这样写更清楚

/* order.c -- 指针运算中的优先级 */
#include <stdio.h>
int data[2] = { 100, 200 };

int moredata[2] = { 300, 400 };
int main(void)
{
    int * p1, *p2, *p3;
    p1 = p2 = data;
    p3 = moredata;
    printf(" *p1 = %d,  *p2 = %d,  *p3 = %d\n",*p1, *p2, *p3);
    printf("*p1++ = %d, *++p2 = %d, (*p3)++ = %d\n",*p1++, *++p2, (*p3)++);
    printf(" *p1 = %d,  *p2 = %d,  *p3 = %d\n",*p1, *p2, *p3);
    return 0;
}

想想打印出来最终结果是什么?


下面是该程序的输出:
*p1 = 100,  *p2 = 100,   *p3 = 300
*p1++ = 100, *++p2 = 200, (*p3)++ = 300
*p1 = 200,  *p2 = 200,   *p3 = 301

只有(*p3)++改变了数组元素的值,其他两个操作分别把p1和p2指向数
组的下一个元素。

🌴首先p1 他是直接指向我们数组的首地址,解引用之后自然是数组的第一个数据 p2 p3也是一样的

?? 其次 * p1++ 也就是 先执行指针start先递增后指向。使用后缀形式(即p1++而不是++p1)所以此时还是100 等这条命令结束之后,* p1就是200了。而*++p2 他是前缀形式,所以不用等命令完成,直接解引用得到200 p3的例子和p1类似 先解引用得到300 然后后缀递增也就是加一,但是也是得等这条命令结束以后

🌿 最后一行 就是上面的p1 和p3结束以后得到的值,而p2保持不变

至于C语言,ar[i]和*(ar+1)这两个表达式都是等价的。无论ar是数组名还是指针变量,这两个表达式都没问题。但是,只有当ar是指针变量时,才能使用ar++这样的表达式。

指针的操作和野指针

下面的程序示例中演示了8种不同的操作。为了显示每种操作的结果,该程序打印了指针的值(该指针指向的地址)储存在指针指向地址上的值,以及指针自己的地址。 如果编译器不支持%p 转换说明,可以用%u 或%lu 代替%p;如果编译器不支持用%td转换说明打印地址的差值,可以用%d或%ld来代替

// ptr_ops.c -- 指针操作
#include <stdio.h>
int main(void)
{
    int urn[5] = { 100, 200, 300, 400, 500 };
    int * ptr1, *ptr2, *ptr3;
    ptr1 = urn;       // 把一个地址赋给指针
    ptr2 = &urn[2];     // 把一个地址赋给指针
    // 解引用指针,以及获得指针的地址
    printf("pointer value, dereferenced pointer, pointer address:\n");
    printf("ptr1 = %p, *ptr1 =%d, &ptr1 = %p\n", ptr1, *ptr1, &ptr1);
// 指针加法
	ptr3 = ptr1 + 4;
    printf("\nadding an int to a pointer:\n");
    printf("ptr1 + 4 = %p, *(ptr1 + 4) = %d\n", ptr1 + 4, *(ptr1 + 4));
    ptr1++;         // 递增指针
    printf("\nvalues after ptr1++:\n");
    printf("ptr1 = %p, *ptr1 =%d, &ptr1 = %p\n", ptr1, *ptr1, &ptr1);
    ptr2--;         // 递减指针
    printf("\nvalues after --ptr2:\n");
    printf("ptr2 = %p, *ptr2 = %d, &ptr2 = %p\n", ptr2, *ptr2, &ptr2);
    --ptr1;         // 恢复为初始值
    ++ptr2;         // 恢复为初始值
    printf("\nPointers reset to original values:\n");
    printf("ptr1 = %p, ptr2 = %p\n", ptr1, ptr2);
    // 一个指针减去另一个指针
    printf("\nsubtracting one pointer from another:\n");
    printf("ptr2 = %p, ptr1 = %p, ptr2 - ptr1 = %td\n", 
    ptr2, ptr1, ptr2 - ptr1);
    // 一个指针减去一个整数
    printf("\nsubtracting an int from a pointer:\n");
    printf("ptr3 = %p, ptr3 - 2 = %p\n", ptr3, ptr3 - 2);
	return 0;
}

对于以上的程序可以运行一下

指针的操作

赋值

可以把地址赋给指针。例如,用数组名、带地址运算符(&)的
变量名、另一个指针进行赋值。 在该例中,把urn数组的首地址赋给了ptr1,
该地址的编号恰好是0x7fff5fbff8d0。变量ptr2获得数组urn的第3个元素
(urn[2])的地址。注意,地址应该和指针类型兼容。也就是说,不能把
double类型的地址赋给指向int的指针,至少要避免不明智的类型转换。
C99/C11已经强制不允许这样做。

解引用

“ * ” 运算符**给出指针指向地址上储存的值。*因此, ptr1的初值是
100,该值储存在编号为0x7fff5fbff8d0的地址上。

取址

和所有变量一样,指针变量也有自己的地址和值。对指针而言,
&运算符给出指针本身的地址。本例中,ptr1 储存在内存编号为
0x7fff5fbff8c8 的地址上,该存储单元储存的内容是0x7fff5fbff8d0,即urn的地
址。因此&ptr1是 指向ptr1的指针,而ptr1是指向utn[0]的指针。

🍎指针变量是一个变量 其本身也有一个地址 也需要存放,就和int char等类型一样的,也需要有一个地址来存放它

🍌而指针变量 是用于存储其他变量的地址 int char 等类型存储的是对应的值,比如 1 2 3 ‘a’ ‘b’等,但是指针变量存储的就是地址

🍅 可以通过解引用“ * ”来获取指针变量地址的变量对应的值

比如 ptr1是指向utn[0]的指针,那么 ptr1存放的就是utn[0]的地址,我通过解引用就可获取 utn[0]存储的值是多少。

相加

指针与整数相加:可以使用+运算符把指针与整数相加,或整数与指针
相加。无论哪种情况,整数都会和指针所指向类型的大小(以字节为单位)
相乘,然后把结果与初始地址相加。因此ptr1 +4与&urn[4]等价。如果相加
的结果超出了初始指针指向的数组范围,计算结果则是未定义的。除非正好
超过数组末尾第一个位置,C保证该指针有效。

递增指针

递增指向数组元素的指针可以让该指针移动至数组的下一个
元素。因此,ptr1++相当于把ptr1的值加上4(我们的系统中int为4字节),
ptr1指向urn[1](见图10.4,该图中使用了简化的地址)。现在ptr1的值是
0x7fff5fbff8d4(数组的下一个元素的地址),*ptr的值为200(即urn[1]的
值)。注意,ptr1本身的地址仍是 0x7fff5fbff8c8。毕竟,变量不会因为值发
生变化就移动位置。

指针减去一个整数

可以使用-运算符从一个指针中减去一个整数。指针必须是第1个运算对象,整数是第 2 个运算对象。该整数将乘以指针指向类型的大小(以字节为单位),然后用初始地址减去乘积。所以ptr3 - 2与&urn[2]等价,因为ptr3指向的是&arn[4]。如果相减的结果超出了初始指针所指向数组的范围,计算结果则是未定义的。除非正好超过数组末尾第一个位置,C保证该指针有效。

递减指针

当然,除了递增指针还可以递减指针。在本例中,递减ptr3使其指向数组的第2个元素而不是第3个元素。前缀或后缀的递增和递减运算符都可以使用。注意,在重置ptr1和ptr2前,它们都指向相同的元素urn[1]。

指针求差

可以计算两个指针的差值。通常,求差的两个指针分别指向同一个数组的不同元素,通过计算求出两元素之间的距离。 差值的单位与数组类型的单位相同。例如,ptr2 - ptr1得2,意思是这两个指针所指向的两个元素相隔两个int,而不是2字节。只要两个指针都指向相同的数组(或者其中一个指针指向数组后面的第 1 个地址),C 都能保证相减运算有效。如果指向两个不同数组的指针进行求差运算可能会得出一个值,或者导致运行时错误。

比较

使用关系运算符可以比较两个指针的值,前提是两个指针都指向相同类型的对象。

在递增或递减指针时还要注意一些问题。编译器不会检查指针是否仍指
向数组元素。C 只能保证指向数组任意元素的指针和指向数组后面第 1 个位
置的指针有效。但是,如果递增或递减一个指针后超出了这个范围,则是未
定义的。 另外,可以解引用指向数组任意元素的指针。但是,即使指针指向
数组后面一个位置是有效的,也能解引用这样的越界指针。

关于野指针

说到注意事项,一定要牢记一点:千万不要解引用未初始化的指针。例
如,考虑下面的例子:

int * pt;// 未初始化的指针
*pt = 5;   // 严重的错误

为何不行?第2行的意思是把5储存在pt指向的位置。但是pt未被初始化,其值是一个随机值,所以不知道5将储存在何处。这可能不会出什么错,也可能会擦写数据或代码,或者导致程序崩溃。

切记:创建一个指针时,系统只分配了储存指针本身的内存,并未分配储存数据的内存。因此,在使用指针之前,必须先用已分配的地址初始化它。 例如,可以用一个现有变量的地址初始化该指针(使用带指针形参的函数时,就属于这种情况)。
无论如何,使用指针时一定要注意,不要解引用未初始化的指针!

在这里插入图片描述

??笔记源于 C Primer Pluse 第六版
🌈 有帮助的话,(●ˇ?ˇ●) 点个赞~

文章来源:https://blog.csdn.net/qq_53131867/article/details/134937138
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。