指针和数组的重难点解析

最新推荐文章于 2024-03-13 20:09:01 发布
最新推荐文章于 2024-03-13 20:09:01 发布
阅读量293 收藏
点赞数
分类专栏： c++ 文章标签： c++ 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wade1010/article/details/128605099
版权 
#include <iostream>

void test()
{
    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = (int *)(&a + 1);
    printf("%d,%d", *(a + 1), *(ptr - 1));
}
int main()
{
    test();
    return 0;
}

输出结果：2，5

对于数组而言，是一段连续存储的物理地址，里面的内容分别是1 2 3 4 5

 

1

2

3

4

5

&a+1

a指向的是首地址

&a也是指向首地址，但是对于&a而言，无论几维数组，&a+1之后，一定是整个数组的一个跨度.

所以*(ptr-1) ，就是&a+1的位置往左移一位，也就是5

*(a+1)就很简单了，就首地址往右移一位，也就是2

二、三维数组的偏移

void test2()
{
    int a[2][2][3] = {{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}};
    int *ptr = (int *)(&a + 1);
    printf("%d,%d", *(int *)(a + 1), *(ptr - 1));
}

输出结果

7,12
4,2
0x7ffeed1384b0
0x7ffeed1384b0
0x7ffeed1384b0
0x7ffeed1384b0

道理同上，差不多

不论几维数组，都可以等效为一个一维数组

{1,2,3},{4,5,6}

{7,8,9}

{10,11,12}

&a+1

可以看作是一个数组，有两个元素，每个元素又是一个2行3列的二维数组

*(int *)(a + 1) 其实就是把

{7,8,9}

{10,11,12}

转成一个int *数组，然后取第一个，也就是7

a是一个三级指针，是一个三维数组，a指向的是首地址

&a也是指向这个首地址

*a，取内容后降级为二维数组，也是二级指针，它指向的也是这个首地址

**a,取内容再取内容，降级为一级指针， 它指向的也是这个首地址

a+1可以看成a[2]后面跨度[2][3]也就是6个元素

*a+1可以看成a[2][2]后面跨度[3]也就是3个元素

**a+1可以看成a[2][2][3]后面跨度[1]也就是1个元素

三、指针偏移

void test3()
{
    static const char *s[] = {"black", "white", "pink", "violet"};
    const char **ptr[] = {s + 3, s + 2, s + 1, s}, ***p;
    p = ptr;
    ++p;
    printf("%s\n", **p + 1);
}

输出结果：ink

解析：

static const char *s[] = {"black", "white", "pink", "violet"};
const char **ptr[] = {s + 3, s + 2, s + 1, s}, ***p;
p = ptr;

上面3句对象下面的表格

三级指针

二级指针

一级指针

内容

P+3

s

s[0]

black

p+2

s+1

s[1]

white

p+1

s+2

s[2]

pink

p

s+3

s[3]

violet

++p;

也就是指向了下面这一行

p+1 p

s+2

s[2]

pink

**p + 1

这一行业就是降为1级指针，也就是pink这个字符数组第二个位置开始，也就是ink

四、三维数组和二维数组指针的结合

void test4()
{
    int a[3][4] = {{1, 2, 3, 4},
                   {2, 3, 4, 5},
                   {3, 4, 5, 6}};

    int b[3][4] = {
        {10, 11, 12, 13},
        {11, 12, 13, 14},
        {12, 13, 14, 15}};

    int(*aa[2])[4] = {a, b};         // 三级指针  一个*两个[]
    int *p1[3] = {a[0], a[1], a[2]}; // 二级指针 一个*一个[]
    int *p2[3] = {b[0], b[1], b[2]}; // 二级指针 一个*一个[]
    int **pp[2] = {p1, p2};          // 三级指针 两个*一个[]
    int ***p = pp;                   // 三级指针 三个*
    printf("%d\n", (*(*p + 2))[1]);
    printf("%ld\n", aa[1][2] - aa[1][0]); // aa是三级，[1][2]就是降两级变成一级，一级减一级，其实就是指针减指针，肯定是数据元素的一个偏移
}

输出

4 8

pp/p/aa

a/p1

a[0]

1

2

3

4

a+1

a[1]

2

3

4

5

a+2

a[2]

3

4

5

6

pp+1/aa+1

b/p2

b[0]

10

11

12

13

b+1

b[1]

11

12

13

14

b+2

b[2]

12

13

14

15

通过上图，printf("%d\n", (*(*p + 2))[1]);相当于就是a[2][1]=4

printf("%ld\n", aa[1][2] - aa[1][0]);

aa[1][2],期中aa[1]相当于b，最终就是b[2]-b[0]=个元素

五、赋值之后指针指向内容突变

void test5()
{
    const char *ptr[] = {"Welcome", "To", "Beautiful", "Beijing"};
    const char **p = ptr + 1;

    ptr[0] = (*p++) + 2; //
    ptr[1] = *(p + 1);   //
    ptr[2] = p[1] + 3;   //
    ptr[3] = p[0] + (ptr[2] - ptr[1]);

    printf("%s\n", ptr[0]);
    printf("%s\n", ptr[1]);
    printf("%s\n", ptr[2]);
    printf("%s\n", ptr[3]);
}
    const char *ptr[] = {"Welcome", "To", "Beautiful", "Beijing"};
    const char **p = ptr + 1;

对应如下

二级

一级

原值

新值

ptr

ptr[0]

Welcome

空值

ptr+1/p

ptr[1]

To

Beijing

ptr+2/p++后新的p

ptr[2]

Beautiful

jing

ptr+3

ptr[3]

Beijing

g

ptr[0] = (*p++) + 2;// 后置++  限执行再自加，对于ptr[0]而言，其实就是*p+2,也就是 To 取o后面的，也就是空
ptr[1] = *(p + 1);//由于上面p++，这里的p其实指向ptr[2],*(p+1)也就是ptr[3]的值 Beijing
ptr[2] = p[1] + 3;//jing
ptr[3] = p[0] + (ptr[2] - ptr[1]); // p[0] +（jing的地址-Beijing的地址） = p[0]+3=jing的地址+3=g

 六、多级指针多维数组指针偏移运算

void test6()
{
    const char *c[] = {"Welcome", "To", "Beautiful", "Beijing"};
    const char **cp[] = {c + 3, c + 2, c + 1, c};
    const char ***cpp = cp;

    printf("%s\n", **++cpp);
    printf("%s\n", *--*++cpp + 3);
    printf("%s\n", *cpp[-2] + 3);
    printf("%s\n", cpp[-1][-1] + 1);
}

由

const char *c[] = {"Welcome", "To", "Beautiful", "Beijing"};

const char **cp[] = {c + 3, c + 2, c + 1, c};

const char ***cpp = cp;

可以得出如下表：

三级

二级

一级

原值

cp+3

c

c[0]

Welcome

cp+2

c+1

c[1]

To

cp+1

c+2

c[2]

Beautiful

cp/cpp

c+3

c[3]

Beijing

这样就很简单了 **++cpp=**(cp+1)=*(c+2)=c[2]=Beautiful

之后的表为：

三级

二级

一级

原值

cp+3

c

c[0]

Welcome

cp+2

c+1

c[1]

To

cp+1/cpp

c+2

c[2]

Beautiful

cp

c+3

c[3]

Beijing

*--*++cpp + 3 = *--*(cp+2)+3 = *--(c+1)+3 = *c +3 =c[3]+3=come

之后的表为：

三级

二级

一级

原值

cp+3

c

c[0]

Welcome

cp+2/cpp

c+1

c[1]

To

cp+1

c+2

c[2]

Beautiful

cp

c+3

c[3]

Beijing

printf("%s\n", *cpp[-2] + 3); 注意上面一行*--*++cpp对于cpp来，做的前置++才改变了cpp的指向，最终结果也就是上表

*cpp[-2]+3 = *(c+3)+3 =c[3]+3=jing

printf("%s\n", cpp[-1][-1] + 1); 也就很简单了，cpp[-1][-1]+1 = (c+2)[-1]+1=c[1]+1=o

#include <iostream>

using namespace std;

void test()
{
    int a[5] = {1, 2, 3, 4, 5};
    int *ptr = (int *)(&a + 1);
    printf("%d,%d\n", *(a + 1), *(ptr - 1));
}
/*
输出结果：2，5

对于数组而言，是一段连续存储的物理地址，里面的内容分别是1 2 3 4 5
12345&a+1
a指向的是首地址
&a也是指向首地址，但是对于&a而言，无论几维数组，&a+1之后，一定是整个数组的一个跨度.
所以*(ptr-1) ，就是&a+1的位置往左移一位，也就是5
*(a+1)就很简单了，就首地址往右移一位，也就是2
 */

void test2()
{
    int a[2][2][3] = {{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}};
    int *ptr = (int *)(&a + 1);
    printf("%d,%d\n", *(int *)(a + 1), *(ptr - 1));
    printf("%d,%d\n", *(int *)(*a + 1), *(int *)(**a + 1));
    cout << a << endl;
    cout << &a << endl;
    cout << *a << endl;
    cout << **a << endl;
}
/*
7,12
4,2
0x7ffeed1384b0
0x7ffeed1384b0
0x7ffeed1384b0
0x7ffeed1384b0

道理同上，差不多
不论几维数组，都可以等效为一个一维数组
{1,2,3},{4,5,6} | {7,8,9}{10,11,12} | &a+1

可以看作是一个数组，有两个元素，每个元素又是一个2行3列的二维数组
*(int *)(a + 1) 其实就是把
{7,8,9}{10,11,12}
转成一个int *数组，然后取第一个，也就是7

a是一个三级指针，是一个三维数组，a指向的是首地址
&a也是指向这个首地址
*a，取内容后降级为二维数组，也是二级指针，它指向的也是这个首地址
**a,取内容再取内容，降级为一级指针， 它指向的也是这个首地址

a+1可以看成a[2]后面跨度[2][3]也就是6个元素
*a+1可以看成a[2][2]后面跨度[3]也就是3个元素
**a+1可以看成a[2][2][3]后面跨度[1]也就是1个元素
 */

void test3()
{
    static const char *s[] = {"black", "white", "pink", "violet"};
    const char **ptr[] = {s + 3, s + 2, s + 1, s}, ***p;
    p = ptr;
    ++p;
    printf("%s\n", *(*p + 1)); // violet
    printf("%s\n", **p + 1);   // ink
}

/*
输出结果:
violet
ink

上面3句对象下面的表格
三级指针二级指针一级指针内容P+3ss[0]blackp+2s+1s[1]whitep+1s+2s[2]pinkps+3s[3]violet

++p;
也就是指向了下面这一行
p+1   ps+2s[2]pink

**p + 1
这一行业就是降为1级指针，也就是pink这个字符数组第二个位置开始，也就是ink

*/

void test4()
{
    int a[3][4] = {{1, 2, 3, 4},
                   {2, 3, 4, 5},
                   {3, 4, 5, 6}};

    int b[3][4] = {
        {10, 11, 12, 13},
        {11, 12, 13, 14},
        {12, 13, 14, 15}};

    int(*aa[2])[4] = {a, b};         // 三级指针  一个*两个[]
    int *p1[3] = {a[0], a[1], a[2]}; // 二级指针 一个*一个[]
    int *p2[3] = {b[0], b[1], b[2]}; // 二级指针 一个*一个[]
    int **pp[2] = {p1, p2};          // 三级指针 两个*一个[]
    int ***p = pp;                   // 三级指针 三个*
    printf("%d\n", (*(*p + 2))[1]);
    printf("%ld\n", aa[1][2] - aa[1][0]); // aa是三级，[1][2]就是降两级变成一级，一级减一级，其实就是指针减指针，肯定是数据元素的一个偏移
}
/*
输出
4
8

pp/p/aaa/p1a[0]1234a+1a[1]2345a+2a[2]3456pp+1/aa+1b/p2b[0]10111213b+1b[1]11121314b+2b[2]12131415
通过上图，printf("%d\n", (*(*p + 2))[1]);相当于就是a[2][1]=4

printf("%ld\n", aa[1][2] - aa[1][0]);
aa[1][2],期中aa[1]相当于b，最终就是b[2]-b[0]=个元素

 */

void test5()
{
    const char *ptr[] = {"Welcome", "To", "Beautiful", "Beijing"};
    const char **p = ptr + 1;

    ptr[0] = (*p++) + 2; // 空
    ptr[1] = *(p + 1);   // Beijing
    ptr[2] = p[1] + 3;   // jing
    printf("ptr[2]的地址:%p,ptr[1]的地址:%p,相减的结果为:%ld\n", ptr[2], ptr[1], ptr[2] - ptr[1]);
    ptr[3] = p[0] + (ptr[2] - ptr[1]); // p[0] +（jing的地址-Beijing的地址） = p[0]+3=jing的地址+3=g

    printf("ptr[0]=%s\n", ptr[0]);
    printf("ptr[1]=%s\n", ptr[1]);
    printf("ptr[2]=%s\n", ptr[2]);
    printf("ptr[3]=%s\n", ptr[3]);
}
/*
ptr[0] = (*p++) + 2;// 后置++  限执行再自加，对于ptr[0]而言，其实就是*p+2,也就是 To 取o后面的，也就是空
ptr[1] = *(p + 1);//由于上面p++，这里的p其实指向ptr[2],*(p+1)也就是ptr[3]的值 Beijing
ptr[2] = p[1] + 3;//jing
ptr[3] = p[0] + (ptr[2] - ptr[1]); // p[0] +（jing的地址-Beijing的地址） = p[0]+3=jing的地址+3=g

 */

void test6()
{
    const char *c[] = {"Welcome", "To", "Beautiful", "Beijing"};
    const char **cp[] = {c + 3, c + 2, c + 1, c};
    const char ***cpp = cp;

    printf("%s\n", **++cpp);
    printf("%s\n", *--*++cpp + 3);
    printf("%s\n", *cpp[-2] + 3);
    printf("%s\n", cpp[-1][-1] + 1);
}
int main()
{
    test();
    cout << "------------------------分隔符------------------------" << endl;
    test2();
    cout << "------------------------分隔符------------------------" << endl;
    test3();
    cout << "------------------------分隔符------------------------" << endl;
    test4();
    cout << "------------------------分隔符------------------------" << endl;
    test5();
    cout << "------------------------分隔符------------------------" << endl;
    test6();
    return 0;
}
/*
2,5
------------------------分隔符------------------------
7,12
4,2
0x7ffee1618450
0x7ffee1618450
0x7ffee1618450
0x7ffee1618450
------------------------分隔符------------------------
violet
ink
------------------------分隔符------------------------
4
8
------------------------分隔符------------------------
ptr[2]的地址:0x10e5e8eb4,ptr[1]的地址:0x10e5e8eb1,相减的结果为:3
ptr[0]=
ptr[1]=Beijing
ptr[2]=jing
ptr[3]=g
------------------------分隔符------------------------
Beautiful
come
jing
o
 */

3333333_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言二维数组中的指针问题
m0_46550452的博客
10-07 913
以一个二维数组a[3][2]为例简单介绍二维数组中关于指j针的问题 一.基本含义 1.a[3][2]表示的一个三行二列的二维数组，a[0]、a[1]、a[2]分别代表第零行、第一行、第二行首元素的地址。 2.数组名a本质上是一个指向一维数组的指针（数组指针）,在本例中指向a数组的第零行。 注意：数组名a代表的含义也等价于&a[0] 二.&a[0]和a[0]的区别： 两者所代表的地址值都是相同的，但是它们的类型和含义是不同的。 &a[0]和a[0]都指向a数组的第零行第零列元素的首.
指针难点——数组指针、指针数组、函数指针、指针函数详解
weixin_57154303的博客
09-28 647
- 回调函数 函数指针的一个非常典型的应用就是回调函数。回调函数就是一个通过指针函数调用的函数。其将函数指针作为一个参数，传递给另一个函数。回调函数并不是由实现方直接调用，而是在特定的事件或条件发生时由另外一方来调用的。 常用于区分指针数组和数组指针，用法如下 1. 首先找到变量名，将变量名与右边内容结合，判断是指针还是数组，如果变量名带有括号，先算括号里的。 2. 右边的看一个，再向左看一个，将内容往前写，直至左右一方没有了，再一次写下另一方
指针的偏移
abbr_is_hbc的博客
07-02 4219
基本数据类型指针偏移 //方便演示，先初始化一个指针为空。 int* a = nullptr; a = a+1;//+1就偏移一个单位，而a定义的是指向int型数据的指针，int型有4个字节，所以输出就是00000004 //假设我们定义一个一维数组 int arr[5]={1,2,3,4,5}; int* p= &arr[0];//这里也可以直接写成arr p = p+1;//相当于p = &arr[0+1] *p; //所以*p = 2； /* 如果我们再定义一...
C++动态内存分配指针遍历一至三维数组详解(含源码)
执念斩长河
04-27 1698
本博文源于自学C++过程中的一些心得，旨在讲述如何用指针访问多维数组，中间数组全部使用内存分配。从动态内存分配开始讲起，先一维数组简单遍历，然后瞬间推至多维。最u后得出结论，不管多少维度动态内存分配，n-1维指针数组可以有效遍历！
三维数组指针定义和初始化例子
最新发布
文石_2009的博客
03-13 579
三维数组使用
Linux C编程进阶之指针与数组解析
06-09
数组与指针是C语言的难点和重点，如果不懂指针和数组，就谈不上会C语言，更谈不上精通，本教程凝结了多年讲授C语言编程的心血，总结出了容易理解、简单使用的指针数组分析技巧，通过该技巧分析出数组名、多维数组、...
C语言指针教学难点解析.pdf
09-19
C语言中的指针是编程中的核心概念，也是学习难度较高的部分。指针是内存地址的表示，它存储了变量在内存中的...在教学中，应着重解析指针的概念、操作和在实际编程中的应用，以帮助学生克服学习难点，提高编程能力。
c以及c++总结的重难点.doc
07-21
【C/C++编程语言重难点解析】 在C和C++编程中，理解并掌握全局变量、指针、联合体（Union）、静态变量以及二维数组等概念是至关重要的。以下是对这些知识点的详细解释： 1. **全局变量和指针**： 全局变量在程序...
C语言指针教学重点和难点问题浅析.pdf
09-19
6. **指针数组**：指针数组是一组指针，每个元素都可以指向不同类型的变量。这种结构常用于实现命令行参数解析或配置文件处理。 在教学过程中，以下几点是理解指针的重点和难点： - **指针与地址的关系**：理解...
指针重点难点的解析，教你如何认识指针
01-14
指针可以被用作数组和函数的间接访问工具。例如，通过一个指向数组首元素的指针，我们可以遍历整个数组。同样，函数可以接收指针作为参数，从而允许函数修改调用者提供的变量。这种机制对于处理大量数据或实现回调...
C语言---指针　& 指针数组偏移 const（C++的常量折叠）
qq_42024067的博客
07-22 516
数组指针和指针数组 指针数组：储存指针的数组 int *p1[10] 数组指针：指向数组的指针 int (*p2)[10] “[]”的优先级比“*”要高 int *p1[10];理解为int* p1[10] 【内容是int*的数组p1[10]】 指针数组 int (*p2)[10]; 理解为指针*p2→int[10] 指向数组的指针*p2→→数组指针 int ...
C语言之数组与指针偏移
orz13096968113的博客
02-05 1192
通过指针操作数组内的元素顺序 #include <stdio.h> void change_arr(int *parr,int se) //交换函数 { int i=0; int temp=0; for(i=0;i<3;i++) //指针偏移定位元素并交换 { temp= *(parr+i); *(parr+i)=*(parr+se-i-1);
C语言数组中的地址偏移问题
流水mpc
06-24 1480
本文讨论在C/C++中，一维数组和二维数组中的地址偏移问题。 一维数组 int a[3]; 二维数组 int a[3][3]; 1、先看一维数组的情况： [cpp] view plaincopy #include       using namespace std;      int main()   {
C语言笔记-数组地址偏移与指向数组指针偏移的关系
已是悬崖百丈冰
01-11 2690
数组地址偏移与指向数组指针偏移的关系 引言： 在学习C语言过程中，使用数组的情况比较多，那么这里简单描述一下比较容易踩坑的数组地址的问题。 一、数组地址偏移与指向数组指针偏移 例如，定义一个数组，如下： unsigned char Data[3]={1,2,3}; 那么有： A、Data或者&Data[0] 都是表示这个数组的起始地址。 其关系有： 1.地址关系：&Data[0] = Data 、&Data[1] = Data+1、&Data
关于三维数组和指针的测试
asty008的博客
11-06 2009
#include int main(void) { int i = 0; int j = 0; int k = 0; //int a[2][3][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24}; //用下面的表示看起来比较直接对得上 int a[2][3][4
【C深入】多维数组和多维指针
zjy900507的博客
07-02 1945
指向指针的指针：多级指针的分析与使用（重置动态空间的大小）#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; int reset(char** s,int a_size,int new_size) { char *pp = *s; int len = 0; char *bt = NULL; ...
指针和多维数组
qq_44031303的博客
05-23 239
我们在前面使用const创建过变量 const double PI =3.14159; #define可以创建类似功能的符号常量，但是const的用法更加灵活，可以创建const 数组 const指针和指向const 的指针。 我们使用最小的数组，假设有下面的声明 int zippo[4][2];//内涵int 数组的数组 然后数组名zippo是该数组首元素的地址，在本列中，zippo...
详解多维数组与指针之间的关系
热门推荐
17岁boy的博客
04-16 1万+
先介绍一下简单的一维数组：列如：int a[3] = {0,1,2};[3]和类型int则明确表示编译器应该为这个栈分配多大的内存，也就是三个int大小！在内存中示意图是：在CPU看来内存是一组连续的地址空间，所以当我们对一维数组进行操作时只需要知道数组首地址，就可以通过地址偏移加减运算方式来求得每个元素位于内存中的文件映射出来的数据段虚拟地址！不过要注意不要越界，其实你在自己的地址空间内访问超出...
C语言数组试题.doc
11-15
2. 难点：区分字符串与字符数组，理解和运用指针数组和数组元素的指针法引用。 六、典型题解析 - 【例4.1】选择题：考查数组定义的语法，正确答案C，因为其他选项要么缺少常量表达式，要么使用了变量。 - 【例4.2】...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值