指针

已于 2024-07-24 19:32:02 修改
阅读量1.7k 收藏 24
点赞数 42
文章标签： c语言
于 2024-02-07 19:48:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79941274/article/details/135908537
版权

目录

初识指针

一.指针变量

1.取地址操作符（&） 

2.解引用操作符(*)

3.指针变量的大小

4.指针变量类型

a.解引用操作的字节

b.指针+-整数

二.void*指针

三.const修饰指针

1.const修饰变量

2.const修饰指针变量

a.int const *p  或者const int* p

b.int* const p

c.const int* const p

三.指针运算

1.指针+-整数

2.指针-指针

3.指针的关系运算

四.野指针

成因和解决

a.指针未初始化

规避：指针初始化

b.指针越界访问

规避：⼩⼼指针越界

c.指针指向的空间释放

规避：避免返回局部变量的地址规避:指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性a​编辑

五.assert断言

六.strlen模拟实现

​编辑​编辑七.传值调用和传址调用

1.传值调用

2.传址调用

八.数组名理解

特例：

九.指针访问数组

十.  一维数组传参

十一.冒泡排序

十二.  二级指针

十三.指针数组

指针数组模拟实现二维数组

十四.字符指针变量

 扩展：

十五.数组指针

初始化

应用：二维数组传参本质

十六.函数指针

1.函数指针数组

转移表

2.回调函数

十七.typedef关键词

十八.qsort

十九.sizeof和strlen

初识指针

内存单元编号==地址==指针

一.指针变量

1.取地址操作符（&） 

一个整型占4个字节，取出的地址为a所占4个字节中较小字节的地址（16进制的形式） 

2.解引用操作符(*)

int *p --> p:指针变量（存放a的地址）int:存放的地址所指向的内容为int型

*p -->对p存放的地址解引用的到a的内容（20）

 

可以通过解引用操作符(*)修改指向的内容

3.指针变量的大小

指针变量的大小与类型无关，只要是指针类型，在相同平台下指针变量的大小相同

32位平台下地址是32个bit位，指针变量⼤⼩是4个字节       
64位平台下地址是64个bit位，指针变量⼤⼩是8个字节       

4.指针变量类型

a.解引用操作的字节

char* （一个字节）

int*       (四个字节）

short*  (两个字节）

double*(八个字节）

b.指针+-整数

char* 类型的指针变量+1跳过1个字节

int*   类型的指针变量+1跳过了4个字节

二.void*指针

1.泛指型指针，可接受任意类型的指针

2.不能直接进行指针的+-整数和解引用运算

三.const修饰指针

1.const修饰变量

可通过地址改变n的值

2.const修饰指针变量

a.int const *p  或者const int* p

（当const放在*左边时，不能修改a的值，限制的是*p，不能通过指针变量p来修改p指向空间的内容，p不受限）

b.int* const p

(p被限制，但*p可被修改，可修改a的值）

c.const int* const p

(p和*p均被限制）

三.指针运算

1.指针+-整数

数组在内存中连续存放

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = &arr[0];
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));//加的是i*sizeof(int)
	}
	return 0;
}

2.指针-指针

指针-指针的绝对值=指针与指针间的元素个数（前提条件：两个指针指向同一个空间）

类比于：地址-地址（日期-日期)

3.指针的关系运算

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	while (p < arr + sz)//数组名为首元素地址
	{
		printf("%d ", *p);
		p++;
	}
	return 0;
}

四.野指针

指针指向的位置是未知的

成因和解决

a.指针未初始化

规避：指针初始化

1.知道p指向a，所以a的地址初始化

2.不知道指针初始化为谁的地址，直接初始化为NULL(NULL为常量标识符，值为0，0为地址，该地址无法使用，读写该地址均会报错，如：*p)

b.指针越界访问

规避：⼩⼼指针越界

程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问，超出了就是
越界访问
 

c.指针指向的空间释放

局部变量a出函数之后无法将地址传递给*p

规避：避免返回局部变量的地址
规避:指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性a

五.assert断言

⽤于在运⾏时确保程序符合指定条件，如果不符合，就报错终⽌运⾏

头文件 #include<assert.h>

Debug中使用，在Release版本中选择禁用assert

好处：⾃动标识⽂件和出问题的⾏号
        ⼀种⽆需更改代码就能开启或关闭 assert() 的机制

缺点：引⼊了额外的检查，增加了程序的运⾏时间

当确定没有问题不再断言时，就在头文件前定义NDEBUG

#define NDEBUG
#include<assert.h>

六.strlen模拟实现

统计字符串中\0之前的字符个数




七.传值调用和传址调用

1.传值调用

把变量本⾝直接传递给了函数,x的地址和a的地址不⼀样，y的地址和b的地址不⼀样，相当于x和y是独⽴的空间，那么在Swap函数内部交换x和y的值，不会影响a和b

实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实
参
 

2.传址调用

传址调⽤，可以让函数和主调函数之间建⽴真正的联系，在函数内部可以修改主调函数中的变量

八.数组名理解

数组名为数组首元素的地址

特例：

1.sizeof(数组名）此时数组名表示整个数组，计算的是整个数组的大小（单位：字节）

2.&数组名  表示整个数组，取出整个数组的地址

九.指针访问数组

十.  一维数组传参

⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式

数组传参传递的只是数组首元素的地址，形参部分不会创建数组，数组名即数组首元素的地址

十一.冒泡排序

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Scan(int* s,int sz1)
{
	for (int i = 0; i < sz1; i++)
	{
		scanf("%d", &s[i]);
	}
}
void The_Bubble(int* s,int sz2)
{
	int count = 0;
	for (int i = 0; i < sz2 - 1; i++)
	{
		//int flag = 1;
		for (int j = 0; j < sz2 - 1 - i; j++)
		{
			
			count++;
			if (s[j] > s[j + 1])
			{
				//flag = 0;
				int tmp = s[j + 1];
				s[j + 1] = s[j];
				s[j] = tmp;
			}
			//if (flag == 1) break;
		}
	}
	printf("%d\n", count);
}
int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Scan(arr,sz);
	The_Bubble(arr,sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

 

提高交换效率的代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Scan(int* s,int sz1)
{
	for (int i = 0; i < sz1; i++)
	{
		scanf("%d", &s[i]);
	}
}
void The_Bubble(int* s,int sz2)
{
	int count = 0;
	for (int i = 0; i < sz2 - 1; i++)
	{
		int flag = 1;
		for (int j = 0; j < sz2 - 1 - i; j++)
		{
			
			count++;
			if (s[j] > s[j + 1])
			{
				flag = 0;
				int tmp = s[j + 1];
				s[j + 1] = s[j];
				s[j] = tmp;
			}
			if (flag == 1) break;
		}
	}
	printf("%d\n", count);
}
int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Scan(arr,sz);
	The_Bubble(arr,sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

十二.  二级指针

存放指针变量的地址

十三.指针数组

整型数组-->存放整型的数组 int arr[10]

字符数组-->存放字符的数组 char ch[10]

指针数组-->存放指针的数组（每个元素均为指针，指向同一块区域）int* arr[5]

指针数组模拟实现二维数组

十四.字符指针变量

将字符串的第一个字符的地址存放到p中

1.可以将字符串想象为数组，不能被修改

2.常量字符串（不能被修改）出现在表达式时，该值为首字符的地址

 扩展：

十五.数组指针

 整型指针：存放整型变量的地址，指向整型的指针 int*p

字符指针：存放字符变量的地址，指向字符的指针  char*p

数组指针：存放数组变量的地址，指向数组的指针  int (*p1)[10] 

int (*p1)[10]    数组指针：p1是指针，指针指向的是数组，每个元素类型为int

int *p2[10]      指针数组：int *p2[10] p2是数组，每个元素类型为int*

初始化

要存放个数组的地址，就得存放在数组指针变量中

p==&arr  -->   *p==*&arr==arr 

应用：二维数组传参本质

⼆维数组的数组名表⽰的就是第⼀⾏的地址，是⼀维数组的地址

第⼀⾏的地址的类型就是数组指针类型 int(*)[5]
⼆维数组传参本质上也是传递了地址，传递的是第⼀⾏这个⼀维数组的地址
 

十六.函数指针

int (*p)(int x,int y)=Add --> 存放函数的地址

1.函数指针数组

char* arr[5]   字符指针数组

int* arr[5]    整型字符数组

int(*PArr[4])(int,int)   函数指针数组

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int (*PArr[4])(int x, int y) = { Add,Sub,Mul,Div };
	for (int i = 0; i < 4; i++)
	{
		printf("%d\n", PArr[i](6,2));//(*PArr[i])(6,2)
	}
	return 0;
}

 

转移表

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void menu()
{
	printf("$$$$$$$$$$$$$$$$$$$$$$$\n");
	printf("$$     0.exit       $$$\n");
	printf("$$ 1.Add      2.Sub  $$\n");
	printf("$$ 3.Mut      4.Div  $$\n");
	printf("$$$$$$$$$$$$$$$$$$$$$$$\n");
	
}
int Add(int x,int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	do
	{
		menu();
		printf("请选择：\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			int ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入操作数：\n");
			scanf("%d%d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("操作结束\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
		}
	}while (input);
}
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void menu()
{
	printf("$$$$$$$$$$$$$$$$$$$$$$$\n");
	printf("$$     0.exit       $$$\n");
	printf("$$ 1.Add      2.Sub  $$\n");
	printf("$$ 3.Mut      4.Div  $$\n");
	printf("$$$$$$$$$$$$$$$$$$$$$$$\n");
	
}
int Add(int x,int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int (*p[])(int, int) = { 0,Add,Sub,Mul,Div };
	do
	{
		menu();
		printf("请选择：\n");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("操作结束\n");
		}
		else if (input <= 4 && input >= 1)
		{
			printf("请输入操作数:\n");
			scanf("%d%d", &x, &y);
			int ret = p[input](x, y);
			printf("%d\n", ret);
		}
	}while (input);
}

2.回调函数

函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数

回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应
 

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
void menu()
{
	printf("$$$$$$$$$$$$$$$$$$$$$$$\n");
	printf("$$     0.exit       $$$\n");
	printf("$$ 1.Add      2.Sub  $$\n");
	printf("$$ 3.Mut      4.Div  $$\n");
	printf("$$$$$$$$$$$$$$$$$$$$$$$\n");

}
int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int Mul(int x, int y)
{
	return x * y;
}
int Div(int x, int y)
{
	return x / y;
}
void callc(int (*p)(int, int))
{
	int x = 0;
	int y = 0;
	printf("请输入操作数：\n");
	scanf("%d%d", &x, &y);
	int ret = p(x, y);
	printf("%d\n", ret);
}
int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择：\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			callc(Add);
			break;
		case 2:
			callc(Sub);
			break;
		case 3:
			callc(Mul);
			break;
		case 4:
			callc(Div);
			break;
		case 0:
			printf("操作结束\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
		}
	} while (input);
}

十七.typedef关键词

用于类型重命名

                                                  typedef unsigned int unit    -->  unit num

指针类型 (int*-->ptr_t)               typedef int* ptr_t                -->  ptr_t pa

数组指针(int (*)[10]-->parr_t)    typedef int(*parr_t)[10]       int(*pb)[10]-->parr_t pb

函数指针(void(*)(int)-->pf_t)     typedef void(*pf_t)(int)        int(*pf2)(int,int)-->pf_t pf2

十八.qsort

快速排序 

void qsort(void* base,size_t num,size_t size,int(*compar)(const void*,const void*));

void* base （待排序数组的起始位置）(void* :为了接受任意可能的指针类型）

size_t num  (待排序数组元素个数）

size_t size （待排序数组的元素大小）

int(*compar)(const void*,const void*)  （函数指针指向一个函数用来比较待排序数组中的两个元素）

#include<stdio.h>
#include<stdlib.h>
void print(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int com_par(const void* s1, const void* s2)
{
	return *(int*)s1 - *(int*)s2;
}
void test1()
{
	int arr[] = { 1,4,7,2,5,8,3,6,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), com_par);//调用比较函数指针
	print(arr, sz);
}
int main()
{
	test1();
	return 0;
}

#include<stdio.h>     //排序任意类型的数据
#include<stdlib.h>

int com_par();
void print();
void Bubble_sort();

int com_par(const void* s1, const void* s2)
{
	return *(int*)s1 - *(int*)s2;
}

void print(int arr[],int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

void swap(char* p1, char* p2,size_t width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}

void Bubble_sort(void* arr,size_t sz,size_t width, int (*cmp)(const void* p1, const void* p2))
{
	for (int i=0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)arr + width * j, (char*)arr + (j + 1) * width) > 0)
			{
				swap((char*)arr + width * j, (char*)arr + (j + 1) * width, width);
			}
		}
	}

}
void test1()
{
	int arr[] = { 1,0,4,7,2,5,8,3,6,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz, sizeof(arr[0]), com_par);
	print(arr, sz);
}
int main()
{
	test1();
	return 0;
}

#include<stdio.h>    //根据结构体中成员的年龄排序
#include<stdlib.h>
#include<string.h>

int com_par();
void print();
void Bubble_sort();


void swap(char* p1, char* p2, size_t width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}

void Bubble_sort(void* arr, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)arr + width * j, (char*)arr + (j + 1) * width) > 0)
			{
				swap((char*)arr + width * j, (char*)arr + (j + 1) * width, width);
			}
		}
	}

}

struct stu
{
	char name[20];
	int age;
};


int cmp_stu_by_age(const void* s1, const void* s2)
{
	return ((struct stu*)s1)->age-((struct stu*)s2)->age;
}

void test1()
{
	struct stu arr[] = { {"zhangsan",30},{"chenxi",19 }, { "xuhang",39 } };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d\n",arr[i].name, arr[i].age);
	}
}
int main()
{
	test1();
	return 0;
}

#include<stdio.h>    //根据结构体成员的名字排序
#include<stdlib.h>    //qsort对应的头文件
#include<string.h>    //strcmp对应的头文件

int com_par();
void print();
void Bubble_sort();


void swap(char* p1, char* p2, size_t width)
{
	for (int i = 0; i < width; i++)
	{
		char tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}

void Bubble_sort(void* arr, size_t sz, size_t width, int (*cmp)(const void* p1, const void* p2))
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - i - 1; j++)
		{
			if (cmp((char*)arr + width * j, (char*)arr + (j + 1) * width) > 0)
			{
				swap((char*)arr + width * j, (char*)arr + (j + 1) * width, width);
			}
		}
	}

}

struct stu
{
	char name[20];
	int age;
};

int cmp_stu_by_name(const void* s1, const void* s2)
{
	return strcmp(((struct stu*)s1)->name,((struct stu*)s2)->name);
}


void test1()
{
	struct stu arr[] = { {"zhangsan",30},{"chenxi",19 }, { "xuhang",39 } };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
	for (int i = 0; i < sz; i++)
	{
		printf("%s %d\n",arr[i].name, arr[i].age);
	}
}
int main()
{
	test1();
	return 0;
}

十九.sizeof和strlen

sizeof                                                                              strlen

计算的是操作数所占内存的大小（单位：字节）            求字符串长度即找到'\0'为止

不关注内存中存放什么内容                                             头文件#include<string.h>

不挑类型                                                                          只针对字符串

a b c d e f \0

小陈的进阶之路
关注
  • 42
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
彩色荧光鼠标指针鼠标指针.zip
12-01
在IT领域，鼠标指针是用户界面中一个重要的组成部分，尤其是在个人电脑操作系统中。它作为用户与计算机交互的直观工具，扮演着引导和指示的角色。本文将深入探讨“彩色荧光鼠标指针”这一主题，以及如何在Windows...
c语言指针，指针与变量，指针与指针
07-08
本文将深入探讨“指针、指针与变量、指针与数组、指针与函数以及字符串与指针”的相关知识点。 首先，让我们了解什么是指针。在C语言中，指针是一个变量，它存储的是另一个变量的内存地址。通过指针，我们可以直接...
C指针详解 经典 非常详细.pdf
01-13
在学习C语言指针时，我们需要了解指针的类型、指针所指向的类型、指针的值、指针本身所占据的内存区等四个方面的内容。 首先，让我们了解指针的类型。从语法的角度看，只需把指针声明语句里的指针名字去掉，剩下的...
蓝色荧光鼠标指针.zip
10-09
【标题】"蓝色荧光鼠标指针.zip"是一款专门针对Windows操作系统设计的鼠标指针主题包，它提供了独特的蓝色荧光效果，为用户的电脑界面增添了一份科技与时尚的元素。这款鼠标指针皮肤的设计风格独特，以三角形为主题...
好看的Windows11概念版鼠标指针
10-02
"好看的Windows11概念版鼠标指针"这一主题，聚焦于操作系统中一个常常被忽视但至关重要的元素——鼠标指针。Windows 11作为微软的最新操作系统，其设计语言一直都在追求更加现代化、简洁和美观。这个概念版的鼠标...
精美鼠标指针下载内含20余款精美鼠标指针
04-20
在IT领域，用户界面（UI）的个性化是提升用户体验的重要一环，而鼠标指针作为电脑操作中的一个重要元素，其设计和风格也能显著影响到用户的交互感受。标题“精美鼠标指针下载内含20余款精美鼠标指针”表明这是一款...
指针的概念
05-13
本文旨在深入解析指针的概念，并通过具体的例子帮助读者更好地掌握指针的四个关键方面：指针的类型、指针所指向的类型、指针的值以及指针本身所占据的内存区。 #### 二、指针的类型 指针的类型指的是指针本身的...
macOS Sierra 鼠标指针
10-01
在macOS系统中，鼠标指针是用户与操作系统交互的重要元素。macOS Sierra作为苹果公司推出的桌面操作系统，其鼠标指针的设计和功能旨在提供高效、直观的用户体验。本篇文章将详细探讨macOS Sierra中的鼠标指针特性，...
Win10 左手用户的鼠标指针
06-15
在Windows 10操作系统中，为了满足不同用户的需求，尤其是左手用户，系统提供了一系列的定制选项，使得鼠标指针能够适应左撇子的操作习惯。"Win10 左手用户的鼠标指针"这一主题主要涉及如何调整和优化鼠标设置，以便...
鼠标指针 cur文件 集合
03-05
在Windows操作系统中，鼠标指针是用户界面的重要组成部分，它指示了光标所在的位置以及当前用户的交互状态。`.cur`文件是一种特殊的图像格式，专门用于存储Windows系统的鼠标指针样式。`.cur`文件包含了不同形状和...
好看的windows鼠标指针
03-06
在Windows操作系统中，鼠标指针是用户界面的重要组成部分，它为用户提供了一种直观的方式来与系统交互。本资源“好看的windows鼠标指针”是一份包含了14款独特设计的鼠标指针集合，旨在提升桌面环境的视觉体验和操作...
c语言指针c语言指针c语言指针c语言指针c语言指针
08-30
c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针c语言指针...
c语言 指针
02-13
学习c语言指针。ppt
水晶指针
03-18
水晶指针
Night Diamond五套指针.rar
01-10
《夜钻：五款独特鼠标指针的详细指南》 在电脑使用中，个性化和定制化体验已经成为许多用户追求的乐趣之一。"Night Diamond五套指针.rar" 是一个专为鼠标指针爱好者提供的资源包，它包含五款设计精美的夜光钻石主题...
我的世界钻石剑指针资源
08-05
"我的世界钻石剑指针资源"是专为这款游戏定制的一种鼠标指针资源包，旨在为玩家提供更加沉浸式的游戏体验。这个资源包由作者Exoridus精心设计，将游戏内的标志性元素——钻石剑，转化为电脑鼠标指针，让玩家在日常...
特色电脑指针
12-15
【特色电脑指针】是一款由用户自制的个性化鼠标指针软件包，旨在为电脑用户提供与众不同的操作体验。这款鼠标指针设计独特，包含了多种风格，能够满足不同用户对桌面个性化的需求。通过安装这款指针包，用户可以改变...
C ++测试随机数
最新发布
quaer的博客
08-03 271
【代码】C ++测试随机数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值