C语言 指针数组进阶详解

目录
  • 指针与数组中的sizeof与strlen
    • sizeof
    • strlen
    • 数组名
    • 1、一维数组
      • 整型数组
      • 字符数组
      • 指针数组
    • 2、二维数组
  • 指针笔试题
    • 笔试题1
    • 笔试题2
    • 笔试题3
    • 笔试题4
    • 笔试题5

前言:指针与数组的知识往往让我们无法给自己定位,似乎是懂了,但真的碰上了又一言难尽。接下来有一些关于指针与数组的知识和例题讲解,来看看你对指针和数组到底有多了解吧!

指针与数组中的sizeof与strlen

sizeof

sizeof值关注占用空间的大小,单位是字节,不关注元素的类型,是一个操作符。

strlen

strlen是计算字符串中\0之前出现了多少个字符,只针对字符串,是一个库函数。

数组名

数组名是数组首元素地址,但是在这里有两个例外:

(1)sizeof(数组名),这里的数组名表示的是整个数组,计算的是整个数组的大小,单位是字节。

(2)&数组名,这里的数组名也表示整个数组,取出的是数组的地址

除了上面两种情况外,所有的数组名表示的都是数组首元素地址。

下面我们就来看一看数组、指针的一些运用

1、一维数组

整型数组

#include<stdio.h>
int main()
{
    //一维数组
    int a[] = {1,2,3,4};

    printf("%d\n",sizeof(a));// 16
    printf("%d\n",sizeof(a+0));// 4/8
    printf("%d\n",sizeof(*a));// 4
    printf("%d\n",sizeof(a+1));// 4/8
    printf("%d\n",sizeof(a[1]));// 4
    printf("%d\n",sizeof(&a));// 4/8
    printf("%d\n",sizeof(*&a));// 16
    printf("%d\n",sizeof(&a+1));// 4/8
    printf("%d\n",sizeof(&a[0]));// 4/8
    printf("%d\n",sizeof(&a[0]+1));// 4/8

    return 0;
}

接下来我们就一句一句讲解:

sizeof(a)

数组名a单独放在sizeof内部,计算的是整个数组的大小,单位是字节,所以计算结果:4*4=16个字节。

sizeof(a+0)

a没有单独存放,所以表示的是首元素的地址,a+0还是数组首元素的地址,是地址的话大小就是4/8个字节。(在32位环境下为4,64位环境下为8)

sizeof(*a)

a表示的是首元素的地址,*a就是对首元素的地址解引用,所以就是首元素,大小为4个字节

sizeof(a+1)

a表示首元素地址,a+1就是第二个元素的地址,是地址的话大小就是4/8个字节。

sizeof(a[1])

a[1]表示数组的第二个元素,大小是4个字节。

sizeof(&a)

&a表示的是整个数组的地址,数组的地址也是地址,所以大小为4/8个字节。

sizeof(*&a)

&a是数组的地址,类型是int(*)[4],是一个数组指针,如果解引用,访问的就是4个int的数组,可以理解为*与&抵消效果,所以*&a相当于a,所以sizrof(a)是16。

sizeof(&a+1)

&a是数组地址,&a+1跳过整个数组后的地址,是地址就是4/8个字节大小。

sizeof(&a[0])

&a[0]取出的是数组第一个元素的地址,是地址就是4/8个字节大小。

sizeof(&a[0]+1)

&a[0]+1就是第二个元素的地址,是地址大小就是4/8个字节。

字符数组

#include<stdio.h>
int main()
{
    //字符数组
    char arr[] = {'a','b','c','d','e','f'};

    printf("%d\n", sizeof(arr));// 6
    printf("%d\n", sizeof(arr+0));// 4/8
    printf("%d\n", sizeof(*arr));// 1
    printf("%d\n", sizeof(arr[1]));// 1
    printf("%d\n", sizeof(&arr));// 4/8
    printf("%d\n", sizeof(&arr+1));// 4/8
    printf("%d\n", sizeof(&arr[0]+1));// 4/8

    printf("%d\n", strlen(arr));// 随机值
    printf("%d\n", strlen(arr+0));// 随机值
    printf("%d\n", strlen(*arr));// err
    printf("%d\n", strlen(arr[1]));// err
    printf("%d\n", strlen(&arr));// 随机值
    printf("%d\n", strlen(&arr+1));// 随机值
    printf("%d\n", strlen(&arr[0]+1));// 随机值

    return 0;
}

1、sizeof

sizeof(arr)

arr作为数组名单独存放在sizeof内部,计算的是整个数组的大小,所以是6个字节。

sizeof(arr+0)

arr没有单独存放,所以这里的arr表示的是首元素地址,arr+0还是首元素地址,是地址就是4/8个字节大小。

sizeof(*arr)

arr表示数组的首元素地址,*arr表示的就是首元素,由于是char类型,所以是1字节。

sizeof(arr[1])

arr[1]就是数组中的第二个元素,大小是1字节。

sizeof(&arr)

&arr取出的是数组的地址,地址大小为4/8个字节。

sizeof(&arr+1)

&arr+1跳过了整个数组,还是地址,所以大小为4/8个字节。

sizeof(&arr[0]+1)

&arr[0]是第一个元素的地址,&arr[0]+1就是第二个元素的地址,地址就是4/8个字节。

2、strlen

strlen(arr)

arr是首元素地址,但是arr数组中没有\0,计算的时候不知道什么时候停止,所以结果是随机值。

strlen(arr+0)

arr+0还是首元素地址,同上

strlen(*arr)、strlen(arr[1])

strlen需要的是一个地址,从这个地址开始向后计算字符,直到碰上\0停止,统计字符的个数,而*arr是首元素'a',也就是传给strlen的是'a'的ASCII码值97,strlen会把97作为起始地址,统计字符串,会形成内存访问冲突,所以会报错!arr[1]也一样,是第二个元素'b'。

strlen(&arr)

&arr是arr数组的地址,虽然类型和strlen的参数类型有所差异,但是传参过去后,还是从第一个字符的位置向后数字符,而arr数组中没有\0,所以结果还是随机值。

strlen(&arr+1)

跳过整个数组,但还是不知道哪里会出现\0,所以结果还是随机值。

strlen(&arr[0]+1)

&arr[0]表示首元素的地址,&arr[0]+1表示第二个元素的地址,也就是从第二个字符还是往后数,但由于\0不能确定所以还是随机值。

下面这个就用来自测吧!

#include<stdio.h>
int main()
{
    char arr[] = "abcdef";

    printf("%d\n", sizeof(arr));// 7 整个数组的大小,包括\0
    printf("%d\n", sizeof(arr+0));// 4/8
    printf("%d\n", sizeof(*arr));// 1
    printf("%d\n", sizeof(arr[1]));// 1
    printf("%d\n", sizeof(&arr));// 4/8
    printf("%d\n", sizeof(&arr+1));// 4/8
    printf("%d\n", sizeof(&arr[0]+1));// 4/8

    printf("%d\n", strlen(arr));// 6
    printf("%d\n", strlen(arr+0));// 6
    printf("%d\n", strlen(*arr));// err
    printf("%d\n", strlen(arr[1]));// err
    printf("%d\n", strlen(&arr));// 6
    printf("%d\n", strlen(&arr+1));// 随机值
    printf("%d\n", strlen(&arr[0]+1));// 5

    return 0;
}

指针数组

#include<stdio.h>
int main()
{
    char *p = "abcdef";

    printf("%d\n", sizeof(p));// 4/8
    printf("%d\n", sizeof(p+1));// 4/8
    printf("%d\n", sizeof(*p));// 1
    printf("%d\n", sizeof(p[0]));// 1
    printf("%d\n", sizeof(&p));// 4/8
    printf("%d\n", sizeof(&p+1));// 4/8
    printf("%d\n", sizeof(&p[0]+1));// 4/8

    printf("%d\n", strlen(p));// 6
    printf("%d\n", strlen(p+1));// 5
    printf("%d\n", strlen(*p));// err
    printf("%d\n", strlen(p[0]));// err
    printf("%d\n", strlen(&p));// 随机值
    printf("%d\n", strlen(&p+1));// 随机值
    printf("%d\n", strlen(&p[0]+1));// 5

    return 0;
}

1、sizeof

sizeof(p)

p是一个指针变量,sizeof(p)计算的是指针变量大小,4/8个字节。

sizeof(p+1)

p是指针变量,用来存放地址的,p+1也是地址,地址大小就是4/8个字节。

sizeof(*p)

*p访问的是字符a,大小1字节。

sizeof(p[0])

p[0]相当于*(p+0),相当于*p,同上。

sizeof(&p)

&p也是地址,是地址就是4/8个字节。

sizeof(&p+1)

&p是地址,+1是在内存中跳过p变量后的地址,还是地址,所以为4/8字节。

sizeof(&p[0]+1)

p[0]就是a,&p[0]就是a的地址,&p[0]+1就是b的地址,是地址就是4/8个字节。

2、strlen

strlen(p)

这里的p是首元素地址,也就是'a'的地址,strlen(p)就是从'a'的位置向后求字符串的长度,长度是6。

strlen(p+1)

p是首元素地址,p+1就是第二个元素的地址,也就是'b',从b开始数直到\0,所以长度是5。

strlen(*p)、strlen(p[0])

*p、p[0]都是首元素'a',传的是a的ASCII码值,会有警报。

strlen(&p)、strlen(&p+1)

&p是指针p的地址,也就是算p的地址的字符串长度,由于不知道什么时候碰到\0,所以是随机值;&p+1就是跳过p的地址访问字符,\0未知,所以也是随机值。如图:

strlen(&p[0]+1)

&p[0]就是首元素地址,+1就是从第二个元素开始计算,长度为5;p[0]也可以看做*(p+0),也就是*p。

2、二维数组

#include<stdio.h>
int main()
{
    //二维数组
    int a[3][4] = {0};

    printf("%d\n",sizeof(a)); // 48
    printf("%d\n",sizeof(a[0][0])); // 4
    printf("%d\n",sizeof(a[0])); // 16
    printf("%d\n",sizeof(a[0]+1)); // 4/8
    printf("%d\n",sizeof(*(a[0]+1)));// 4
    printf("%d\n",sizeof(a+1)); // 4/8
    printf("%d\n",sizeof(*(a+1))); // 16
    printf("%d\n",sizeof(&a[0]+1)); // 4/8
    printf("%d\n",sizeof(*(&a[0]+1))); // 16
    printf("%d\n",sizeof(*a)); // 16
    printf("%d\n",sizeof(a[3])); // 16

    return 0;
}

sizeof(a)

这里的a表示的是整个数组,所以大小为4*(3*4)=48。

sizeof(a[0][0])

a[0][0]表示第一行第一列的元素,由于数组是int型,所以一个元素的字节大小为4.

sizeof(a[0])

a[0]表示第一行的数组名,a[0]作为数组名单独放在sizeof内部,计算的是整个数组大小,即第一行的大小,4*4=16。

sizeof(a[0]+1)

这里的a[0]作为第一行的数组名,没有&,没有单独放在sizeof内部,所以a[0]表示的就是首元素的地址,即a[0][0]的地址,a[0]+1就是第一行第二个元素的地址,是地址就是4/8。

sizeof (*(a[0]+1))

a[0]+1就是第一行第二个元素的地址,对其解引用,就是第一行第二个元素,大小为4。

sizeof(a+1)

a是二维数组的数组名,是类型为 int(*)[4] 的数组指针,没有&,没有单独存放在sizeof内部,a表示首元素的地址,即第一行的地址,a+1就是第二行地址,是地址,大小就为4/8个字节。

sizeof (*(a+1))

(a+1)就是第二行元素的地址,解引用就是第二行的数组名,计算的是第二行的大小,所以大小为16个字节。( *(a+1) --> a[1] )

sizeof(&a[0]+1)

a[0]是第一行,&a[0]是地址,&a[0]+1就是第二行的地址,是地址大小就为4/8字节。

sizeof (*(&a[0]+1))

对第二行的地址解引用,也就是a[1],大小为16字节。

sizeof(*a)

a是二维数组的数组名,没有&,没有单独放在sizeof内部,a表示首元素地址,*a就是二维数组的首元素,也就是第一行,大小为16字节。( *a --> *(a+0) --> a[0] )

sizeof(a[3])

a[3]看起来是越界了,但是计算的时候它会去推导要计算的类型,例如:

int a=10; sizeof(int)和 sizeof(a)计算的大小一样,它会去推导a的类型是int型。同理,它也会去推导a[3]的类型,a[3]的类型是 int [4],所以大小为16。

通过上面的一些讲解,接下来我们看一些实战题:

指针笔试题

笔试题1

#include<stdio.h>
int main()
{
  int a[5] = { 1, 2, 3, 4, 5 };
  int *ptr = (int *)(&a + 1);
  printf( "%d,%d", *(a + 1), *(ptr - 1));
  return 0;
}
//程序的结果是什么?

讲解 :

如图,a是数组名,也就是首元素的地址,a+1就是第二个元素的地址,对(a+1)解引用就是第二个元素2,打印出来2;

ptr是一个指针,指向的是数组的末尾,且被强制转换成int *类型,所以ptr-1跳过的是一个int,对其解引用就是数组的最后一个元素5。

笔试题2

#include<stdio.h>
struct Test
{
    int Num;
    char *pcName;
    short sDate;
    char cha[2];
    short sBa[4];
}*p;

//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节

int main()
{
    p = (struct Test*)0x100000;
    printf("%p\n", p + 0x1);
    printf("%p\n", (unsigned long)p + 0x1);
    printf("%p\n", (unsigned int*)p + 0x1);
    return 0;
}

讲解:

已知这里的p是一个结构体指针,p+0x1就相当于结构体指针+1,而这个结构体类型的变量大小是20个字节,也就是加了20个字节,化为十六进制为0x100014;

(unsigned long) p把p强制转换成unsigned long型,这里的p就相当于是一个无符号类型的数,内存里面就默认为存的就是一个普普通通的整形数字,整型数字加1就是加1,所以结果为0x100001;

(unsigned int *)p把p强制转换成unsigned int *,这里的p就是整型指针,而整型指针加1就是加4个字节,所以结果为0x100004。

笔试题3

#include<stdio.h>
int main()
{
  int a[4] = { 1, 2, 3, 4 };
  int *ptr1 = (int *)(&a + 1);
  int *ptr2 = (int *)((int)a + 1);
  printf( "%x,%x", ptr1[-1], *ptr2);
  return 0;
}

如图,ptr1就是&a+1,跳过整个数组,再强制转换成int * 型,而ptr1[-1]相当于 *(ptr1-1),也就是跳过一个int * 型,所以ptr1[-1]==4,用%x打印出来也是4;

(int *)((int)a + 1),a是首元素地址,强转换为int型,也就是把这个地址看成普普通通的整型数字,一个整型数字加1就是简简单单的加1,是地址这个数字+1,而不是地址+1,所以跳过的是一个字节。而我们知道数据在内存中的存储分大小端,这里我们以小端为例,如图ptr2指向的是一个整型中的第二个字节,从第二个字节开始取出一个整型,以小端输出,所以结果为02000000。

笔试题4

#include <stdio.h>
int main()
{
    int a[3][2] = { (0, 1), (2, 3), (4, 5) };
    int *p;
    p = a[0];
    printf( "%d", p[0]);
    return 0;
}

讲解:

这里要看清楚题目,数组里面的是圆括号,所以是逗号表达式,数组其实就是

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

p = a[0] 即p指向的是数组的第一行,p[0]就是数组第一行一个元素,所以打印出来是1。

笔试题5

#include<stdio.h>
int main()
{
  int a[5][5];
  int(*p)[4];
  p = a;
  printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
  return 0;
}

这里p是一个数组指针,p指向的数组是4个元素,而a是一个5行5列的数组,如下图:

好了,今天就讲到这里!这些是否让你对数组和指针有了新的看法呢?

到此这篇关于C语言 指针数组进阶详解的文章就介绍到这了,更多相关C语言 指针数组 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C语言指针引用数组案例讲解

    前言:C语言中指针玩的是什么,是内存,要想学好指针的小伙伴们要先对数据在内存中是怎么玩的做一番了解~       当在程序中定义一个变量时,系统会根据其数据类型为其开辟内存空间,例如Visual C++为整型变量分配四个字节的空间,为单精度浮点型变量分配四个字节,为字符型变量分配一个字节,内存中每个字节都有自己独立且唯一的一个编号,这就是地址 ,如下图,系统为变量i分配了2000~2004的存储单元. _访问变量的方式_有如下图两种: 第一种直接访问方式,直接通过变量名访问,变量名与地址有一一对

  • C语言运用函数指针数组实现计算器功能

    本文实例为大家分享了C语言运用函数指针数组制作计算器的具体代码,供大家参考,具体内容如下 先来回顾一下概念: 指针数组 -- 存放指针的数组 函数指针 -- 存放函数地址的指针 函数指针数组 -- 存放函数指针的数组 接下来说说这次要制作的计算器的功能: 1.add -- 加法 2.sub -- 减法 3.mul -- 乘法 4.div -- 除法 0.exit -- 退出 具体来通过代码讲解: (1)首先写一个菜单程序,在运行程序时首先打印一次菜单. void menu() { printf(

  • 从头学习C语言之指针和数组

    目录 指针和数组: 示例: 总结 指针和数组: 数组名其实是数组第一个元素的地址. %p用来打印地址,为十六进制 &:取址操作符 如果用一个指针指向数组,应该怎么做呢? char *p; p=a;//语句1 p=&a[0];//语句2 指针的运算: 当指针指向数组元素的时候,我们可以对指针变量进行加减运算,这样做的意义相当于只想距离指针所在位置向前或向后第n个元素. 对比标准的下标法访问数组元素,这种使用指针进行间接访问的方法叫做指针法. 需要郑重强调的是:p+1并不是简单的将地址加1,二

  • C语言的数组与指针你了解吗

    目录 前言 一.数组的定义 二.数组空间的初始化 1. char数组赋值 2.char数组硬件开发规范 二.数组与指针 总结 前言 自学笔记,没有历史知识铺垫(省略百度部分)C语言数组的概念及使用 一.数组的定义 char a[n]; 注意:数组与指针非常相似 二者的区别: 数组为常量,约定禁止二次赋值,即数组不应该出现在=左侧,如:a="HelloWorld";数组在声明时,会申请一段连续的内存空间,指针不会数组元素为变量,标记可以修改指向任意内存(实际上会copy右侧变量/常量到左

  • 详解C语言中的指针与数组的定义与使用

    指针的特点 他就是内存中的一个地址 指针本身运算 指针所指向的内容是可以操作的 操作系统是如何管理内存的 栈空间 4M~8m的大小 当进入函数的时候会进行压栈数据 堆空间 4g的大小 1g是操作系统 全局变量 内存映射 可以对内存的内容修改修改硬盘的内容 一般在数据库中经常使用 内存的分配与释放 c语言分配内存的方法 // malloc(需要分配的大小): 这里的分配的大小需要对齐的2的指数 void *mem = malloc(size); 释放内存 // 一般分配的内容都是在堆空间中的 //

  • c语言的指针数组详解

    指针如何指向数组,并读取数组中的元素: #include <stdio.h> int main() { int arr[3] = {1,2,3}; int *p; p = &arr[0];//此句也可以写成 p = arr: for(int i=0;i<3;i++) { printf("第%d个元素值为:%d\n",i,*(p+i)); /*应注意这里指针的定义类型:p+i并不是指p的地址+1, 而是偏移一个类型的字节数,这里的类型是int,所以偏移4个字节*

  • C语言中指针和数组试题详解分析

    目录 数组题: 程序一(一维数组): 字符数组 程序二(字符数组): 程序三(字符数组): 程序四(字符数组): 程序五(字符数组): 二维数组 程序六( 二维数组): 指针题 程序七( 指针): 程序八( 指针): 程序九( 指针): 程序十( 指针): 程序十( 图): 程序十一( 指针): 程序十二( 指针): 程序十三( 指针): 指针 和 数组 试题解析 小编,在这里想说一下,c语言的最后一节 C预处理,可能还需要一些时间,因为小编,昨天才下载了虚拟机 和 linux 系统,还没开始安

  • C语言指针数组案例详解

    指针与数组是 C 语言中很重要的两个概念,它们之间有着密切的关系,利用这种 关系,可以增强处理数组的灵活性,加快运行速度,本文着重讨论指针与数组之 间的联系及在编程中的应用. 1.指针与数组的关系 当一个指针变量被初始化成数组名时,就说该指针变量指向了数组.如: char str[20], *ptr; ptr=str; ptr 被置为数组 str 的第一个元素的地址,因为数组名就是该数组的首地址, 也是数组第一个元素的地址.此时可以认为指针 ptr 就是数组 str(反之不成立), 这样原来对数

  • C语言 指针数组进阶详解

    目录 指针与数组中的sizeof与strlen sizeof strlen 数组名 1.一维数组 整型数组 字符数组 指针数组 2.二维数组 指针笔试题 笔试题1 笔试题2 笔试题3 笔试题4 笔试题5 前言:指针与数组的知识往往让我们无法给自己定位,似乎是懂了,但真的碰上了又一言难尽.接下来有一些关于指针与数组的知识和例题讲解,来看看你对指针和数组到底有多了解吧! 指针与数组中的sizeof与strlen sizeof sizeof值关注占用空间的大小,单位是字节,不关注元素的类型,是一个操作

  • C语言 动态分配数组案例详解

    目录 一维动态数组的创建: 二维数组的创建: 很多人在编写C语言代码的时候很少使用动态数组,不管什么情况下通通使用静态数组的方法来解决,在当初学习C语言的时候我就是一个典型的例子,但是现在发现这是一个相当不好的习惯,甚至可能导致编写的程序出现一些致命的错误.尤其对于搞嵌入式的人来所,嵌入式系统的内存是宝贵的,内存是否高效率的使用往往意味着嵌入式设备是否高质量和高性能,所以高效的使用内存对我们来说是很重要的.那么我们在自己编写C语言代码的时候就应该学会使用动态数组,这也就是我这篇博客要给大家讲的,

  • C语言指针教程示例详解

    目录 指针 内存 指针类型 指针运算 二级指针 指针数组 指针 指针提供了对地址操作的一种方法,因此,使用指针可使得 C 语言能够更高效地实现对计算机底层硬件的操作.另外,通过指针可以更便捷地操作数组.在一定意义上可以说,指针是 C 语言的精髓. 概念解释就不去搬原定义了,又臭又长不好理解,精炼两点就是: 1.指针是内存中的一个最小单元的编号,也就是地址: 2.平时我们说的指针,通常是指指针变量,用来存储内存地址的变量 也就是说:指针就是地址,口语中指针通常是指针变量 内存 要搞明白指针首先要搞

  • C语言柔性数组实例详解

    本文实例分析了C语言柔性数组的概念及用法,对于进一步学习C程序设计有一定的借鉴价值.分享给大家供大家参考.具体如下: 一般来说,结构中最后一个元素允许是未知大小的数组,这个数组就是柔性数组.但结构中的柔性数组前面必须至少一个其他成员,柔性数组成员允许结构中包含一个大小可变的数组,sizeof返回的这种结构大小不包括柔性数组的内存.包含柔数组成员的结构用malloc函数进行内存的动态分配,且分配的内存应该大于结构的大小以适应柔性数组的预期大小.柔性数组到底如何使用? 不完整类型 C和C++对于不完

  • C语言指针的图文详解

    目录 指针是什么? 指针和指针变量 1. 指针类型决定了指针进行解引用操作的时候,能访问空间的大小 2. 指针加减整数 野指针 野指针的成因 指针和数组 二级指针 指针数组.数组指针 总结 指针是什么? 指针(Pointer)是一个特殊的变量,它里面存储的数值被解释成为内存里的一个地址. 换句话说就是可以通过指针找到以它为地址的内存单元. 理解:内存图解. 指针是个变量,存放内存单元的地址(编号). int main(){ int a = 10;//在内存中开辟空间存储 int* p = &a;

  • 易语言一维数组用法详解

    在易语言中,一维数组的用法灵活性较强,所以实际应用起来也能够解决很多问题.我们本次来说明下易语言一维数组的成员操作方法及技巧. 1.首先,我们打开易语言编程工具,新建一个文件,如图所示 2.接着,我们选择要新建的类型,选择windows窗口程序,点击确认.如图所示 3.我们进入窗口界面中,从组件库中选择编辑框.按钮.树型框等放入窗口中,如图所示 4.我们选中树型框,在左侧属性事件中,选择列表项被选择事件,如图所示.在该事件中,我们只需要获取到被选中项的序号即可,如图所示 5.点击进入程序,我们在

  • C 语言指针概念的详解

    计算机中所有的数据都必须放在内存中,不同类型的数据占用的字节数不一样,例如 int 占用4个字节,char 占用1个字节.为了正确地访问这些数据,必须为每个字节都编上号码,就像门牌号.身份证号一样,每个字节的编号是唯一的,根据编号可以准确地找到某个字节. 下图是 4G 内存中每个字节的编号(以十六进制表示): 我们将内存中字节的编号称为地址(Address)或指针(Pointer).地址从 0 开始依次增加,对于 32 位环境,程序能够使用的内存为 4GB,最小的地址为 0,最大的地址为 0XF

  • C语言 指针与数组的详解及区别

    C语言 指针与数组的详解及对比 通俗理解数组指针和指针数组 数组指针: eg:int( *arr)[10]; 数组指针通俗理解就是这个数组作为指针,指向某一个变量. 指针数组: eg:int*arr[10]; 指针数组简言之就是存放指针的数组: --数组并非指针&&指针并非数组 (1)定义一个外部变量: eg:int value=10; int *p=&value; 举例:当需要在一个函数中用这个变量时:externa int*p;而非extern int p[]; 分析:当用:e

随机推荐