指针进阶（下）指针实操

已于 2024-03-08 21:14:26 修改
阅读量825 收藏 29
点赞数 40
分类专栏： 初始c语言 文章标签： c语言
于 2024-03-08 20:36:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liwuqianhzc/article/details/136571549
版权

sizeof 和 strlen

       首先我们来复习一下sizeof 和 strlen 的区别。
sizeof 是操作符，只关注内存中存放的数据的大小，并不会参与sizeof 括号内部的计算。注意它的单位是字节

#include <stdio.h>

int main()
{
	int a = 10;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof a);
	printf("%d\n", sizeof(int));

	return 0;
}

由于a 是 int 类型的数据，需要的参数为指针（地址），并且 int 占四个字节的空间大小，所以上面三行的 sizeof 计算出来都是 4
我们来看一下运行的结果吧：

strlen 是 string.h 的库函数，主要是计算字符串的长度，当遇到 \0 的时候会停止计算长度。计算出来的是字符个数。

#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[3] = { 'a', 'b', 'c' };
	char arr2[] = "abc";
	printf("%d\n", strlen(arr1));
	printf("%d\n", strlen(arr2));
	return 0;
}

由于 strlen 遇到 \0 才会停止计算，所以计算 arr1 的长度时，由于不知道什么时候遇到 \0 所以结果是一个不确定的数（也就是随机数）
而计算 arr2 的时候，我们发现 arr2 存放的时一个字符串，也就是说 arr2 实际存储的内容为 a b c \0 这四个字符，由于 strlen 遇到 \0 就会停止计算，也就是说明最后的结果为 3

我们来看一下运行的结果吧：

数组名再深入理解

       我们知道数组名一般来说是指数组的首元素的地址，但是也有两个特殊情况：一个是 sizeof (arr) ，就是一个数组名单独放在sizeof 里面，要注意了，这里是取出的是整个数组，计算的是整个数组的大小；另外一个就是 &arr ,它取出的是整个数组的地址，那么数据类型是什么呢？举个例子：int arr [10] ,我们&arr 取出整个数组的地址，数据类型就是 int (*) [10]

#include <stdio.h>
int main()
{
	char arr1[3] = { 'a', 'b', 'c' };
	char arr2[] = "abc";
	
	printf("%d\n", sizeof(arr1));
	printf("%d\n", sizeof(arr2));
	return 0;
}

由于sizeof(数组名)计算的是整个数组的大小，也就是说我们只需要看数组占多大空间即可，arr1[3]有三个元素，每个元素的大小为 char (1个字节)，总大小为 3 * 1 = 3 （字节）

arr2 没有明确说明大小，那我们需要看一下其保存的字符串的大小，也就是 a b c \0 一共有4个元素，每个元素的是 char (1个字节）总大小为 4 * 1 = 4 （字节）

我们来验证一下：

题目剖析

       这里我们通过一些题目来进一步地深入理解数组名与指针地关系。大家可以尝试自己分析一下下面代码的运行结果，然后再看一下解析。

一维数组

#include <stdio.h>

int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a + 0));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(a[1]));
	printf("%d\n", sizeof(&a));
  printf("%d\n", sizeof(*&a));

	return 0;
}

首先sizeof(a),数组名单独放在 sizeof 内部，计算的是整个数组的大小，也就是 4 * 4 = 16 个字节

sizeof(a+0), a+0说明数组名不是单独放在 sizeof 内部，也就是 arr 指数组首元素的地址，a+0表示跳过0个元素，还是数组首元素的地址，地址就是 4/8 个字节（64位机器地址占8个字节，32位机器地址占4个字节）

sizeof(*a) ，数组名没有单独放在sizeof 内部，就是说 a 代表的是数组首元素的地址，*a数组首元素地址的解引用操作，取出的是数组第一个元素，sizeof 计算的就是数组第一个元素的大小，也就是 4 个字节

sizeof(a+1), 数组名没有单独放在sizeof 内部，就是说 a 代表的是数组首元素的地址，a+1表示跳过一个元素，表示第二个元素的地址，既然是地址，就是 4/8 个字节的大小

sizeof(a[1]), 这个a[1] 表示数组第二个元素，也就是 4 个字节

sizeof(&a), &a 表示取出整个数组的地址，数据类型是 int (*) [4] ,既然是地址，也就是 4/8 个字节了。

我们来看一下运行结果（这里以 64 位机器为例，也就是地址大小为 8 个字节，下面的运行示例也以 64 位机器演示，就不做提醒了）

字符数组

代码一：

#include <stdio.h>

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

	return 0;
}

sizeof(arr), sizeof 内部单独存放数组名，计算的是整个数组的大小，数组有 6 个元素，分别为a b c d e f ;类型是 char 类型（一个字节），一共就是 6 * 1 = 6 （字节）

sizeof(arr+0), arr + 0 显而易见数组名不是单独存放再sizeof 内部，arr 表示首元素的数组名，arr + 0表示跳过0个元素，表示第一个元素的地址，既然是地址，也就是 4/8 个字节

sizeof(*arr), 数组名没有单独存放在 sizeof 内部，arr则表示为数组首元素的地址，*arr 解引用取出数组第一个元素，数据类型为 char ，即一个字节

sizeof(arr[1]),显而易见，arr[1] 取出数组第二个元素，大小为 1 个字节

sizeof(&arr), &arr表示取出整个数组的地址，地址占 4/8 个字节

sizeof(&arr+1),&arr 取出整个数组的地址，数据类型是char (*) [6] , &arr+1跳过一个数组，还是一个地址，就是 4/8 个字节

sizeof(&arr[0]+1), &arr[0] 取出的是数组首元素的地址，+1 表明跳过一个元素，指向数组第二个元素，还是一个地址， 4/8 个字节

我们来看一下运行结果：

代码二：

#include <stdio.h>
#include <string.h>

int main()
{
	char arr[] = { 'a','b','c','d','e','f' };
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));

	return 0;
}

strlen(arr),arr 表示首元素的地址，遇到 \0 才停止计算，是个随机数

strlen(arr+0),arr 表示首元素地址， arr+0表示跳过 0个元素，指向第二个元素，还是一个随机数

strlen(*arr), *arr 取出数组的首元素，strlen 需要传入地址，否则系统会报错，无法运行，硬要访问，a的ascll码值是97，访问的是地址编号为97，这是属于操作系统的是不允许访问的

strlen(arr[1]), arr[1] 取出数组第二个元素，系统报错，硬要访问，a的ascll码值是97，访问的是地址编号为97，这是属于操作系统的是不允许访问的

strlen(&arr)，&arr 取出整个数组的地址，，不知道什么时候遇到 \0 ,是个随机数

strlen(&arr+1),&arr +1 取出整个数组的地址，并跳过一个数组，是个随机数

strlen(&arr[0]+1), &arr[0]+1 取出首元素的地址，跳过一个元素，指向第二个元素，是个随机数

代码三

#include <stdio.h>

int main()
{
	char arr[] = "abcdef";
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(arr + 0));
	printf("%d\n", sizeof(*arr));
	printf("%d\n", sizeof(arr[1]));
	printf("%d\n", sizeof(&arr));
	printf("%d\n", sizeof(&arr + 1));
	printf("%d\n", sizeof(&arr[0] + 1));

	return 0;
}

arr 存放着 a b c d e f \0 这 7 个元素

sizeof(arr),取出整个数组的大小， 7 * 1 = 7 个字节

sizeof(arr+0), arr + 0 跳过 0 个元素，指向数组第一个元素，是个地址，4/8 个字节

sizeof(*arr), *arr 表示数组首元素的解引用，取出第一个元素，1 个字节

sizeof(arr[1]), arr[1] 取出第二个元素，大小为 1 个字节

sizeof(&arr), &arr 取出整个数组的地址，数据类型是 char (*) [7] ,地址为 4/8 个字节

sizeof(&arr+1), 取出整个数组的地址，并跳过一个数组，还是一个地址，4/8 个字节

sizeof(&arr[0]+1), 取出数组首元素的地址，并跳过一个元素，指向数组的第二个元素，还是一个地址，4/8 个字节

下面是代码运行结果：

代码四

#include <stdio.h>
#include <string.h>

int main()
{
	char arr[] = "abcdef";
	printf("%d\n", strlen(arr));
	printf("%d\n", strlen(arr + 0));
	printf("%d\n", strlen(*arr));
	printf("%d\n", strlen(arr[1]));
	printf("%d\n", strlen(&arr));
	printf("%d\n", strlen(&arr + 1));
	printf("%d\n", strlen(&arr[0] + 1));

	return 0;
}

arr 存放着 a b c d e f \0 这 7 个元素

strlen(arr),传入数组首元素的地址，遇到 \0 停下，一共就是 6

strlen(arr+0),传入数组首元素的地址，并跳过 0 个元素，还是指向数组首元素，一共是 6

strlen(*arr), *arr 取出数组首元素，不是一个地址，系统报错，硬要访问，a的ascll码值是97，访问的是地址编号为97，这是属于操作系统的是不允许访问的

strlen(arr[1]),arr[1] 取出数组第二个元素，不是一个地址，系统报错，硬要访问，b的ascll码值是98，访问的是地址编号为98，这是属于操作系统的是不允许访问的

strlen(&arr), &arr 取出整个数组的地址，还是以数组首元素的地址表示，也就是 6

strlen(&arr+1), &arr + 1 取出整个数组的地址，&arr 的数据类型是 char (*) [7] ,并跳过一个数组，也就是指向一个未知的空间，无法知道什么时候遇到 \0 ,是个随机数

strlen(&arr[0]+1),&arr[0]表示数组首元素的地址，+1 跳过一个元素，也就是从第二个元素开始计算，则为 5

代码五

#include <stdio.h>

int main()
{
	char* p = "abcdef";
	printf("%d\n", sizeof(p));
	printf("%d\n", sizeof(p + 1));
	printf("%d\n", sizeof(*p));
	printf("%d\n", sizeof(p[0]));
	printf("%d\n", sizeof(&p));
	printf("%d\n", sizeof(&p + 1));
	printf("%d\n", sizeof(&p[0] + 1));

	return 0;
}

p 是一个字符指针，指向的是一个常量字符串

sizeof§, p 是一个指针变量，也就是地址，4/8 个字节

sizeof(p+1), p + 1 跳过一个元素，指向第二个元素，还是一个地址，4/8 个字节

sizeof(*p), *p 字符串首元素解引用，取出 a，a 是 char 类型，1 个字节

sizeof(p[0]), p[0] 取出字符‘a’，大小为 1 个字节

sizeof(&p), &p 取出的是 p 的地址，是一个二级指针，数据类型为 char** ，也就是 4/8 个字节

sizeof(&p+1), &p + 1,取出 p 的地址，是个二级指针，数据类型为 char** ，再跳过一个数组 ，还是一个地址， 4/8 个字节

sizeof(&p[0]+1), &p[0] 表明取出首元素的地址，跳过一个元素，指向第二个元素的地址，也就是 ‘b’ 的地址，还是一个地址，4/8 个字节

看一下运行结果：

代码六

#include <stdio.h>
#include <string.h>

int main()
{
	char* p = "abcdef";
	printf("%d\n", strlen(p));
	printf("%d\n", strlen(p + 1));
	printf("%d\n", strlen(*p));
	printf("%d\n", strlen(p[0]));
	printf("%d\n", strlen(&p));
	printf("%d\n", strlen(&p + 1));
	printf("%d\n", strlen(&p[0] + 1));

	return 0;
}

strlen（p) 从第一个元素开始，到 \0 结束，就是6

strlen(p+1), 从第一个元素开始，+1 跳过一个元素，从第二个元素计算，也就是 5

strlen(*p), *p 取出第一个元素，不是地址，系统报错，硬要访问，a的ascll码值是97，访问的是地址编号为97，这是属于操作系统的是不允许访问的

strlen(p[0]), p[0] 取出第一个元素，不是地址，系统报错，硬要访问，a的ascll码值是97，访问的是地址编号为97，这是属于操作系统的是不允许访问的

strlen(&p), &p 指向 p 的地址，未知空间，不知道何时遇到 \0 , 随机值

strlen(&p+1), &p 取出 p 的地址， &p+1 跳过一个 char* , 未知空间，随机值

strlen(&p[0]+1), &p[0] 取出首元素的地址，+1 跳过一个元素，指向第二个元素，也就是 5

课外探讨：&p 和 &p + 1 有关系吗？实际没有，因为你不知道 p 内部是否有 \0 ，如果有，他们的大小就是差 1

二维数组

首先我们来回顾一下二维数组，二维数组可以看出一个个一维数组组成的，举个例子：
int arr [3][3] = {1,2,3,4,5,6,7,8,9};

我们可以将二位数组看成由一个又一个的一维数组组成，则二维数组的首元素地址就是第一行的地址。

arr [0], arr[1], arr[2], 如果单独放在sizeof 内部的话分别表示 数组的第一行 ，第二行，第三行的数组名，否则就是代表数组第一行、第二行、第三行的首元素地址。

我们来看一下下面的题目：

#include <stdio.h>
#include <string.h>

int main()
{
	int a[3][4] = { 0 };
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(a[0][0]));
	printf("%d\n", sizeof(a[0]));
	printf("%d\n", sizeof(a[0] + 1));
	printf("%d\n", sizeof(*(a[0] + 1)));
	printf("%d\n", sizeof(a + 1));
	printf("%d\n", sizeof(*(a + 1)));
	printf("%d\n", sizeof(&a[0] + 1));
	printf("%d\n", sizeof(*(&a[0] + 1)));
	printf("%d\n", sizeof(*a));
	printf("%d\n", sizeof(a[3]));

	return 0;
}

sizeof(a), a 单独放在sizeof 内部, 表示整个数组的大小，3 * 4 * （sizeof(int)) = 48

sizeof(a[0][0]), a[0][0] 大小为 4 个字节

sizeof(a[0]), a[0] 单独放在 sizeof 内部，表示第一行的数组大小， 4 * 4 = 16

sizeof(a[0]+1), a[0] 不是单独放在 sizeof 内部，则表示的是第一行的首元素 ，也就是 &a[0][0] ，+1 跳过一个元素，指向 a[0][1] 的地址，4/8 个字节

sizeof(*(a[0]+1)) , a[0] + 1 == &a[0][1], 解引用之后就是a[0][1], 也就是 4 个字节

sizeof(a+1), a 再这里表示数组的首元素也就是第一行的地址，+1跳过一行，就是第二行的地址，地址就是 4/8 个字节

sizeof(*(a+1)), a+1 指向第二行的地址，解引用后就是取出第二行的数组，大小就是 4 * 4 =16

sizeof(&a[0]+1), &a[0] 取出第一行的地址，+ 1 表示跳过一行，指向第二行的地址，4/8 个字节

sizeof(*（&a[0]+1）) , 解引用取出第二行，也就是 4 * 4 = 16 个字节

sizeof(*a), a 表示数组首元素的地址（第一行的地址），解引用取出第一行，大小为 4 * 4 = 16

sizeof(a[3]), a[3] 大小为 4 * 4 = 16 个字节，为什么不会有越界的问题，因为 sizeof 不参与计算，a[3]无需真实存在，仅仅通过类型的推断就能算出长度，a[3] 表示第四行的数组名，单独放在 sizeof 内部，计算的是第四行的大小，4 * 4 = 16

我们来看一下运行结果：

指针运算笔试题解析

题目一

#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表示数组首元素的地址，+1 跳过一个元素，* (a+1) 就是 取出 第二个元素（ 2 ）
&a 表示取出整个数组的元素，+ 1 跳过一个数组， int* prt = (int*)(&a+1)，将&a+1 原先的数据类型（int () [5]) 强制类型转化为 int ，ptr-1 要注意了是向后移动一个元素，为什么呢？因为 ptr 的类型是 int* , - 1 也就是向后移动 int，最终指向 5

来看一下运行结果：

题目二

//在X86环境下
//假设结构体的⼤⼩是20个字节
//程序输出的结构是啥？

#include <stdio.h>

struct Test
{
	int Num;
	char* pcName;
	short sDate;
	char cha[2];
	short sBa[4];
}*p = (struct Test*)0x100000;

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

这里的0x1就是表示1

p的类型是 struct Test * ，+1表示跳过一个结构体，也就是地址+20，由于0x是16进制，所以20换成16 进制就是 0x14, 0x100000 + 0x14 = 0x100014

(unsigned long) p将 p 强制类型转换为 无符号的长整型，+1就是0x100001

(unsigned int*)p 将p 强制类型转换为 unsigned int*,+1跳过 unsigned int 的字节大小，也就是0x100000 + 0x4 = 0x100004

运行结果如下：

题目三

#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;
}

要注意了，（，）这是一个逗号表达式，都好表达式的结果去最后一个值，所以{（0，1），（2，3），（4，5）} 的值应该为{1，3，5}

所以数组a[3][2]={1,3,5,0,0,0},p=a[0]表示数组第一行的地址，p[0]相当于a[0][0]也就是取出第一行的首元素，也就是 1

运行结果如下：

题目四

//假设环境是x86环境，程序输出的结果是啥？
#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;
}

int a[5][5],a 的类型是int()[5], 因为这是一个二维数组，二维数组的首元素是二维数组的第一行，所以a的类型是 int () [5]
int (p)[4],无需置疑，p的类型就是int ()[4]

那么&a[4][2]就无需多讲，p[4][2]其实就是*(*（p+4)+2), p+4表示跳过4个int [4],然后+2 表示跳过2个int ,指向图如下图所示。

然后我们要知道指针 - 指针代表就是两个指针之间的元素个数，所以&p[4][2]-&a[4][2] 之间有4个元素，由于是低地址减去高地址，所以是-4

%d打印有符号的整数，就是-4
%p打印的是地址，所以我们需要知道-4在内存中然后存储，那就要将-4的补码写出来(-4的原码是10000000000000000000000000000100，反码就是11111111111111111111111111111011，补码就是11111111111111111111111111111100）也由于是x86环境下，所以是32位的地址，于是将补码转换成16进制的数值（也就是FFFFFFFC）

运行结果：

题目五

#include <stdio.h>

int main()
{
	int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int* ptr1 = (int*)(&aa + 1);
	int* ptr2 = (int*)(*(aa + 1));
	printf("%d,%d", *(ptr1 - 1), *(ptr2 - 1));
	return 0;
}

&aa表示取出整个数组的地址，+1跳过一个数组，然后强制类型转换为int*, 赋给ptr1
aa表示数组的首元素，+1跳过一个元素，然后强制类型转换为int*, 赋给ptr2

ptr-1 由于ptr 是int*类型，所以跳过一个int ，同理ptr2-1也是跳过一个int

运行结果：

题目六

#include <stdio.h>

int main()
{
	char* a[] = { "work","at","alibaba" };
	char** pa = a;
	pa++;
	printf("%s\n", *pa);
	return 0;
}

a是个字符指针数组，存放的是work,at,alibaba的首元素的地址
pa = a意味着pa是a的首元素的地址，pa++跳过一个char*，也就是指向a 的第二个元素，*pa 取出a的第二个元素，也就是at的首元素的地址，所以打印at

运行结果：

题目七

#include <stdio.h>
int main()
{
	char* c[] = { "ENTER","NEW","POINT","FIRST" };
	char** cp[] = { c + 3,c + 2,c + 1,c };
	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);
	return 0;
}

我们先将图画出来：

在这里+的优先级最低

** ++ cpp ，cpp先++，指向c+2的地址，解引用取出c+2，再解引用取出POINT的地址，

*--*++cpp+3

首先cpp在上面已经自增过一次，再++之后cpp就指向c+1的地址，解引用取出c+1，然后c+1再–，变成c，再解引用就会取出ENTER的地址，然后+3，跳过三个元素，也就是指向E的地址，打印出ER

现在cpp是指向cp第三个元素的地址！

cpp[-2]+3,我们先来解读cpp[-2],cpp[-2]表示(cpp-2),也就是取出c+3的地址，*cpp[-2]解引用取出FIRST的地址，+3跳过三个元素，也就是指向S的地址，打印出ST

cpp[-1][-1],我们来分解一下*( *( cpp-1 )-1 ),cpp-1指向cp第二个元素的地址，解引用取出c+2, c+2-1=c+1, 解引用一下就取出NEW的地址，最后cpp[-1][-1] + 1 之后就是指向E的地址，也就是打印出EW

运行结果：

熵减玩家
关注
  • 40
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 12
    评论
专栏目录
11.2 Python 文件指针与文件模式
在路上的专栏
08-09 777
在这篇文章中，我们将深入探讨 Python 中的文件指针与文件模式，通过通俗易懂的语言和幽默感，让您轻松掌握文件操作的核心技能。文章将通过故事性情节来解释文件指针的工作原理，以及如何利用不同的文件模式进行高效的文件操作。通过具体的代码示例和图示，您将学习如何在日常开发中运用这些概念。
2024年Python最全C语言篇+ 指针进阶(上)(1)
2301_82243700的博客
04-30 373
重点来了，先看操作符的优先级，()的优先级是最高的，所以先看()里的内容，其次是[ ]优先级是第二，arr3先和[ ] 结合就是一个数组，数组里面存放着10个元素，每一个元素的类型是 int( * )[5]，所以每一个元素都是一个数组指针，该数组指针指向的数组是【5】个元素，每一个元素是int类型，根据前面的逻辑我们知道&arr取出的是数组的地址，int (*arr)[10] 是个数组指针，本质上还是一个指针，访问的是整个数组的地址，而数组的地址 + 1会偏移40个字节，随后访问的都是随机值。
【C语言进阶】指针的进阶【中篇】
你我皆为凡人的博客
06-03 688
本篇既上篇后续又讲解了新的知识，关于函数指针，函数指针数组，指向函数指针数组的指针与回调函数这些一看就比较令人头疼的知识点，一些比较高的知识点分别举了不同的例子让大家可以知道这些知识的运用，还讲解了关于转移表是什么与库函数qsort的模拟实现，一步一步的提升，如果觉得博主讲解的还不错的话，希望大家多多支持，感谢大家观看...
指针进阶（3）
Elon_520的博客
01-10 629
学习小结
python3入门与进阶笔记_【基础】学习笔记5-python3 Turtle库_实操进阶2
weixin_39684052的博客
02-09 133
fromturtleimport*importdatetimedefSkip(step):#绘制短线penup()forward(step)pendown()defDialPlate(radius):#表盘外框reset()width(7)foriinrange(60):#小刻度角度为6,360/6Skip(radius)ifi%5==0:#小时的刻...
指针和数组心得
weixin_45512458的博客
08-28 1251
最近做完了关于指针和数组的功课，总是感觉自己学得不够扎实，对于深层次的东西没有挖掘到，深怕自己理解过于浅薄而误导大家，被真正了解它的前辈耻笑。 一直在思考在学习C的进阶的时候，为何要从C数据的存储开始讲起，这几天三句话离不开内存，来回踌躇了许久，鹏哥推荐了《C的深度剖析》，读了几页指针和数组的章节，终于顿开茅塞！对C这门学问终于有了一点实质性的理解，也终于可以有一些拿得出手的东西了。 提刀而立，为...
最新C语言篇+ 指针进阶(上)
2301_82242082的博客
05-03 515
在上一篇博客中作者已将指针的基础知识归纳在这篇博客中，《指针和结构体(初级)》，而今天我们要进入指针的下一个环节，指针进阶！！为了怕大家忘记之前讲过的知识，本人再次梳理出一些知识，请各位耐心观看，以下又是老调重弹指针就是个变量，用来存放地址，地址唯一标识一块内存空间。指针的大小是固定的4/8个字节（32位平台/64位平台）。指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。指针的运算。
Python语言进阶
m0_72154565的博客
09-15 545
进程、线程、携程傻傻分不清，来这里交流解决你的疑惑
android进阶
MR CUI的专栏
02-15 1080
进阶 想必也有很多朋友对阿里推出的X-Deep Learning提不起特别大的兴致。之前就有腾讯发布的开源框架QMUI_Android ，最近又有很热门的谷歌开源的flutter框架喊着大家去学，难免会产生疲劳感。尤其是现在行业不景气，很多初级开发甚至都很难找到工作。 其实现在的社会，技术分工越来越细，越细就意味着大部分企业（小作坊除外）需要专精的人才（最好是精通一门通多门）。你会发现身边脱颖而出...
指针进阶之指针数组和数组指针
01-04
"指针进阶之指针数组和数组指针" 指针数组和数组指针是C语言中两个重要的概念，理解它们对指针的使用非常重要。下面将对指针数组和数组指针进行详细的解释和分析。 一、指针数组 指针数组是数组，用于存放指针的...
指针进阶之数组参数和指针参数
01-05
"指针进阶之数组参数和指针参数" 指针在编程语言中是一个非常重要的概念，了解指针的概念和使用方法是编程语言的基础。今天我们将深入探讨指针在数组参数和指针参数中的应用。 一、回顾 在学习指针之前，我们需要...
C语言指针进阶第1课.pdf
06-16
C语言指针进阶 一、C语言中的对象概念 C语言中确实有对象（Object）这个概念。对象是指程序中可以被操作的实体，例如变量、数组、结构体等。理解对象是理解C语言的核心基础概念。 二、指针的概念 指针是C语言中...
指针进阶之函数指针和函数指针数组
01-07
函数指针和函数指针数组 函数指针是一种特殊的指针，它是指向函数的指针。函数指针可以用来存放函数的地址，并且可以通过函数指针来调用函数。 1. 简单介绍 函数指针是指向函数的指针，它可以用来存放函数的地址...
指针进阶之字符指针（超详细）
01-02
在C语言中，指针是一种强大的工具，它允许程序员直接操作内存地址。本篇文章将深入探讨字符指针（char*），它是C语言中处理字符串的一种常见方式。字符指针实际上是一个存储字符内存地址的变量，通过它可以访问和...
CSP-CCF 202112-1 序列查询
2301_79705447的博客
08-17 204
【代码】CSP-CCF 202112-1 序列查询。
C语言基础（一）
最新发布
wehpd的博客
08-17 819
基本数据类型
【网络编程】组播的实现（C语言，linux，Ubuntu）
m0_62859255的博客
08-14 373
1> 组播也是实现一对多的通信方式，对于广播而言，网络需要对每个消息进行复制转发，会占用大量的带宽，导致网络拥塞2> 组播可以实现小范围的数据传播：将需要接收数据的接收端加入多播组，发送端向多播组中发送消息，每个组内成员都能接收到消息3> 需要对接收端进行设置，将接收端加入多播组1、需要使用setsockopt函数实现2、需要对网络层设置：IPPROTO_IP3、需要对加入多播组属性设置：IP_ADD_MEMBERSHIP4、属性值的类型。
C语言之“顺序表”
2402_83250773的博客
08-16 930
顺序表的数据增加，删除，查找
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值