关于数据结构的内存分配问题

最新推荐文章于 2022-12-06 21:45:42 发布
最新推荐文章于 2022-12-06 21:45:42 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： Data Structure 文章标签： 内存分配 opengl 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lafengxiaoyu/article/details/51428174
版权

博主开始用的是实验室的电脑VS2013，我也不知道是vs2013是没有还是我不会用，在surface上装了vs2015之后调试程序有内存监控【不过我现在发现直接可以在控制面板里找哈哈，就是在运行上一篇博文所展示程序的时候，突然发现占用内存呈线性增加。。这好像有点不太对劲


就是这样，我当时想这个事情太可怕了，那么我的程序就是在吃内存啊。。我这里有一个鼠标获取坐标的语句，因此就是在做一个无限循环，是没有终止的，那么这样的话，如果我不进行终止程序，他就会一直运行下去。。过不了多长时间就会把内存吃光。

不知道VS2013有没有这样的功能。。如果有的话我会在之后的知识结构上补上的。或者有热心网友可以帮帮我找找。


其实我最终想到的解决方法表明这跟我的定义方法有关系，因为把定义语句都放到了展示函数里，而主函数在不停的调用展示函数，而又没有及时地释放内存，就会不停的分配新的内存给他。这也许就是传说中的内存泄漏【并没有系统学过C捂脸求不嘲笑，

可能通过及时释放内存的方法也可以达到防止内存泄漏的方法。我这里采取的方法是首选将定义放到了函数外，也就是说，定义的变量都是适合全局的

struct HE_vert  *v[8];
struct HE_edge  *e[6][4];
struct HE_face  *f[6];

void idv()
{
	for (int i = 0; i < 8; i++)
	{
		v[i] = (HE_vert*)malloc(sizeof(HE_vert));
	}
}


void ide()
{
	for (int i = 0; i < 6; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			e[i][j] = (HE_edge*)malloc(sizeof(HE_edge));
		}
	}
}


void idf()
{

	for (int i = 0; i < 6; i++)
	{
		f[i] = (HE_face*)malloc(sizeof(HE_face));
	}
}
而且可能是我太笨了。。连直接分配内存都不会。。由重新令了三个函数。。其中我也不知道为什么在同一个函数里分配不行。真是各种不会。。

这里值得注意的是，如果我在展示函数中调用

idv();
ide();
idf();

是不行的。。

这种吃内存的速度简直是太吓人了，每秒钟都有1M到2M半小时就能把我的内存吃掉，可是把上面三个函数放到主函数里就没问题了，本来以为大功告成了，发现改动过后是这样的


哦哦哦，原来还有东西在吃，最后就是把

struct HE_edge *en = (HE_edge*)malloc(sizeof(HE_edge));

这句语句放到函数外面去定义

修改的最终版本在此

#include <windows.h>
#include <math.h>            
#include <gl/GL.h>            
#include <GL/glut.h>  


//static const GLfloat vertex_list[][3] = {  
//  -0.5f, -0.5f, -0.5f,  
//  0.5f, -0.5f, -0.5f,  
//  0.5f, 0.5f, -0.5f,  
//  -0.5f, 0.5f, -0.5f,  
//  -0.5f, -0.5f, 0.5f,  
//  0.5f, -0.5f, 0.5f,  
//  0.5f, 0.5f, 0.5f,  
//  -0.5f, 0.5f, 0.5f,  
//};  


GLfloat colors[][3] = {
	{ 1.0, 0.0, 0.0 },
	{ 1.0, 1.0, 0.0 },
	{ 0.0, 1.0, 0.0 },
	{ 0.0, 1.0, 1.0 },
	{ 1.0, 0.0, 1.0 },
	{ 0.0, 0.0, 1.0 },
	{ 0.0, 0.5, 0.0 },
	{ 0.0, 0.5, 0.5 },
};

//static const GLint index_list[][4] = {  
//  0, 1, 2, 3,//bottem          
//  0, 3, 7, 4,//left          
//  2, 3, 7, 6,//front          
//  1, 2, 6, 5,//right          
//  0, 1, 5, 4,//back          
//  4, 5, 6, 7//top          
//};  

float M_PI = 3.14159265f;


static float c = M_PI / 180.0f; //弧度和角度转换参数    
static int du = 90, oldmy = -1, oldmx = -1; //du是视点绕y轴的角度,opengl里默认y轴是上方向    
static float r = 3.1f, h = 0.0f; //r是视点绕y轴的半径,h是视点高度即在y轴上的坐标    
float zoom = 1.0f;


typedef struct HE_vert
{

	float x;
	float y;
	float z;

	struct HE_edge  *edge;  // one of the half-edges emantating from the vertex  

}HE_vert;

typedef struct HE_edge
{
	struct HE_vert *vert;   // vertex at the end of the half-edge  
	struct HE_edge *pair;   // oppositely oriented adjacent half-edge   
	struct HE_face *face;   // face the half-edge borders  
	struct HE_edge *next;   // next half-edge around the face  
}HE_edge;


typedef struct HE_face
{

	struct HE_edge *edge;  // one of the half-edges bordering the face  

}HE_face;

struct HE_vert  *v[8];
struct HE_edge  *e[6][4];
struct HE_face  *f[6];

void idv()
{
	for (int i = 0; i < 8; i++)
	{
		v[i] = (HE_vert*)malloc(sizeof(HE_vert));
	}
}


void ide()
{
	for (int i = 0; i < 6; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			e[i][j] = (HE_edge*)malloc(sizeof(HE_edge));
		}
	}
}


void idf()
{

	for (int i = 0; i < 6; i++)
	{
		f[i] = (HE_face*)malloc(sizeof(HE_face));
	}
}
struct HE_edge *en = (HE_edge*)malloc(sizeof(HE_edge));


void display(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(80.0f, 1.0f, 1.0f, 1000.0f);
	glMatrixMode(GL_MODELVIEW);
	


	
	//初始化点  
	v[0]->x = -0.5f; v[0]->y = -0.5f; v[0]->z = -0.5f; v[0]->edge = e[0][0];
	v[1]->x = 0.5f; v[1]->y = -0.5f; v[1]->z = -0.5f; v[1]->edge = e[0][1];
	v[2]->x = 0.5f; v[2]->y = 0.5f; v[2]->z = -0.5f; v[2]->edge = e[0][2];
	v[3]->x = -0.5f; v[3]->y = 0.5f; v[3]->z = -0.5f; v[3]->edge = e[0][3];
	v[4]->x = -0.5f; v[4]->y = -0.5f; v[4]->z = 0.5f; v[4]->edge = e[5][0];
	v[5]->x = 0.5f; v[5]->y = -0.5f; v[5]->z = 0.5f; v[5]->edge = e[0][3];
	v[6]->x = 0.5f; v[6]->y = 0.5f; v[6]->z = 0.5f; v[6]->edge = e[0][2];
	v[7]->x = -0.5f; v[7]->y = 0.5f; v[7]->z = 0.5f; v[7]->edge = e[0][1];

	//struct HE_edge  
	//{  
	//  HE_vert* vert;   // vertex at the end of the half-edge  
	//  HE_edge* pair;   // oppositely oriented adjacent half-edge   
	//  HE_face* face;   // face the half-edge borders  
	//  HE_edge* next;   // next half-edge around the face  
	//};  
	//初始化边  
	e[0][0]->vert = v[1]; e[0][0]->pair = e[4][3]; e[0][0]->face = f[0]; e[0][0]->next = e[0][1];
	e[0][1]->vert = v[2]; e[0][1]->pair = e[3][3]; e[0][1]->face = f[0]; e[0][1]->next = e[0][2];
	e[0][2]->vert = v[3]; e[0][2]->pair = e[2][3]; e[0][2]->face = f[0]; e[0][2]->next = e[0][3];
	e[0][3]->vert = v[0]; e[0][3]->pair = e[1][3]; e[0][3]->face = f[0]; e[0][3]->next = e[0][0];

	e[1][0]->vert = v[7]; e[1][0]->pair = e[2][2]; e[1][0]->face = f[1]; e[1][0]->next = e[1][1];
	e[1][1]->vert = v[4]; e[1][1]->pair = e[5][0]; e[1][1]->face = f[1]; e[1][1]->next = e[1][2];
	e[1][2]->vert = v[0]; e[1][2]->pair = e[4][0]; e[1][2]->face = f[1]; e[1][2]->next = e[1][3];
	e[1][3]->vert = v[3]; e[1][3]->pair = e[0][3]; e[1][3]->face = f[1]; e[1][3]->next = e[1][0];

	e[2][0]->vert = v[6]; e[2][0]->pair = e[3][2]; e[2][0]->face = f[2]; e[2][0]->next = e[2][1];
	e[2][1]->vert = v[7]; e[2][1]->pair = e[5][1]; e[2][1]->face = f[2]; e[2][1]->next = e[2][2];
	e[2][2]->vert = v[3]; e[2][2]->pair = e[1][0]; e[2][2]->face = f[2]; e[2][2]->next = e[2][3];
	e[2][3]->vert = v[2]; e[2][3]->pair = e[0][2]; e[2][3]->face = f[2]; e[2][3]->next = e[2][0];

	e[3][0]->vert = v[5]; e[3][0]->pair = e[4][2]; e[3][0]->face = f[3]; e[3][0]->next = e[3][1];
	e[3][1]->vert = v[6]; e[3][1]->pair = e[5][2]; e[3][1]->face = f[3]; e[3][1]->next = e[3][2];
	e[3][2]->vert = v[2]; e[3][2]->pair = e[2][0]; e[3][2]->face = f[3]; e[3][2]->next = e[3][3];
	e[3][3]->vert = v[1]; e[3][3]->pair = e[0][1]; e[3][3]->face = f[3]; e[3][3]->next = e[3][0];

	e[4][0]->vert = v[4]; e[4][0]->pair = e[1][2]; e[4][0]->face = f[4]; e[4][0]->next = e[4][1];
	e[4][1]->vert = v[5]; e[4][1]->pair = e[5][3]; e[4][1]->face = f[4]; e[4][1]->next = e[4][2];
	e[4][2]->vert = v[1]; e[4][2]->pair = e[3][0]; e[4][2]->face = f[4]; e[4][2]->next = e[4][3];
	e[4][3]->vert = v[0]; e[4][3]->pair = e[0][0]; e[4][3]->face = f[4]; e[4][3]->next = e[4][0];

	e[5][0]->vert = v[7]; e[5][0]->pair = e[1][1]; e[5][0]->face = f[5]; e[5][0]->next = e[5][1];
	e[5][1]->vert = v[6]; e[5][1]->pair = e[2][1]; e[5][1]->face = f[5]; e[5][1]->next = e[5][2];
	e[5][2]->vert = v[5]; e[5][2]->pair = e[3][1]; e[5][2]->face = f[5]; e[5][2]->next = e[5][3];
	e[5][3]->vert = v[4]; e[5][3]->pair = e[4][1]; e[5][3]->face = f[5]; e[5][3]->next = e[5][0];
	//struct HE_edge  
	//{  
	//  HE_vert* vert;   // vertex at the end of the half-edge  
	//  HE_edge* pair;   // oppositely oriented adjacent half-edge   
	//  HE_face* face;   // face the half-edge borders  
	//  HE_edge* next;   // next half-edge around the face  
	//};  

	f[0]->edge = e[0][0];
	f[1]->edge = e[1][0];
	f[2]->edge = e[2][0];
	f[3]->edge = e[3][0];
	f[4]->edge = e[4][0];
	f[5]->edge = e[5][0];

	glLoadIdentity();
	gluLookAt(r*cos(c*du)*cos(c*h)*zoom, r*sin(c*h)*zoom, r*sin(c*du)*cos(c*h)*zoom, 0, 0, 0, 0, 1, 0); //从视点看远点,y	轴方向(0, 1, 0)是上方向

	
	//绘制立体图  
	for (int i = 0; i < 6; i++)
	{

		en = f[i]->edge;
		glColor3f(colors[i][0], colors[i][1], colors[i][2]);
		glBegin(GL_POLYGON);
		do {
			{
				glVertex3f(en->vert->x, en->vert->y, en->vert->z);//绘制面
			}
			en = en->next;
		} while (en != f[i]->edge);

		glEnd();
	}



	for (int i = 0; i < 6; i++)
	{

		en = f[i]->edge;

		do {

			glBegin(GL_LINES);
			{
				glVertex3f(en->vert->x, en->vert->y, en->vert->z);//其中每条边由两点组成  
				glVertex3f(en->pair->vert->x, en->pair->vert->y, en->pair->vert->z);//其中每条边由两点组成
			}
			glEnd();
			en = en->next;

		} while (en != f[i]->edge);
		
	}

	
	

	glFlush();
	glutSwapBuffers();
}


void Mouse(int button, int state, int x, int y) //处理鼠标点击    
{
	if (state == GLUT_DOWN) //第一次鼠标按下时,记录鼠标在窗口中的初始坐标    
		oldmx = x, oldmy = y;


	if (state == GLUT_UP && button == GLUT_WHEEL_UP)
	{
		zoom = zoom + 0.2;
		if (zoom >= 2)zoom = 2;

		//glutPostRedisplay();  
	}
	if (state == GLUT_UP && button == GLUT_WHEEL_DOWN)
	{
		zoom = zoom - 0.2;
		if (zoom <= 0.6) zoom = 0.6;
		//glutPostRedisplay();  
	}
}

void onMouseMove(int x, int y) //处理鼠标拖动      
{
	//printf("%d\n",du);      
	du += x - oldmx; //鼠标在窗口x轴方向上的增量加到视点绕y轴的角度上，这样就左右转了      
	h += (y - oldmy); //鼠标在窗口y轴方向上的改变加到视点的y坐标上，就上下转了      
	if (h > 90)
	{
		h = 90;
	}
	else if (h < -90)
	{
		h = -90;
	}
	//if (h>1.0f) h = 1.0f; //视点y坐标作一些限制，不会使视点太奇怪      
	//else if (h<-1.0f) h = -1.0f;      
	oldmx = x, oldmy = y; //把此时的鼠标坐标作为旧值，为下一次计算增量做准备      
}

int main(int argc, char *argv[])
{

	idv();
	ide();
	idf();
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("OpenGL");
	glutDisplayFunc(display);
	glutIdleFunc(display);  //设置不断调用显示函数    
	glutMouseFunc(Mouse);
	glutMotionFunc(onMouseMove);
	glutMainLoop();
	return 0;
}

监控的效果是这样的


可见如果在被不停的调用会出现之前的情况

内存的分配实在是太重要了。。看来还得补好多C语言的基础课啊^^

拉风小宇
关注
专栏目录
【数据结构】顺序表的实现——动态分配
m0_74195174的博客
04-01 1524
本文旨在深入探讨顺序表的动态分配实现，帮助读者理解并掌握这一技术的核心概念和应用方法。通过动态分配内存，我们可以根据实际需求动态地调整顺序表的大小，从而更加高效地管理数据
数据结构/内存分配中的堆和栈
心向暖的博客
03-26 577
数据结构中的堆和栈 栈 后进先出。 堆 堆是一种经过排序的树形数据结构，每个结点都有一个值。通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。由于堆的这个特性，常用来实现优先队列，堆的存取是随意，直接取出我们想要的结点。 内存分配中的栈和堆 内存中的栈区处于相对较高的地址以地址的增长方向为上的话，栈地址是向下增长的。栈中分配局部...
数据结构----内存分配问题
wangprince2017
09-01 915
一、结构的存储分配 在座各位，肯定都明白机器内存分配对程序的运行效率有多重要。今天，首先我们就来梳一遍结构的存储分配问题。编译器按照成员列表的顺序，依次给每个成员分配空间。只有当存储成员时满足正确的边界对齐要求时，成员之间才可能出现用于填充的额外空间。系统禁止编译器在一个结构的起始位置跳过几个字节来满足边界对齐的要求，因此所有结构的存储位置必须是结构中边界要求最严格的数据类型所要求的位置。 如...
Linux2.6为数据结构分配内存-slab
weixin_30458043的博客
04-30 86
1.高速缓存描述符、slab描述符、数据结构对象之间的关系 slab描述符也可以在外面 不管slab描述符在哪里，空闲链接数组紧跟在slab描述符后面 第一张图跟2.6的不太一样，2.6中，所有箭头都是双向的，且没有不同各种类slab描述符的链接 建立一个缓冲的专用队列： 1.从cache_cache中分配一个kmem_cache_t结构的高速缓存描述符 ...
redis探秘：选择合适的数据结构，减少80%的内存占用，这些点你get到了吗？
tianyaleixiaowu的专栏
12-10 2093
本文首发于京东零售平台公众号，https://mp.weixin.qq.com/s/uzuz7rqctQ-bjdRcf1tO9g redis作为目前最流行的nosql缓存数据库，凭借其优异的性能、丰富的数据结构已成为大部分场景下首选的缓存工具。 由于redis是一个纯内存的数据库，在存放大量数据时，内存的占用将会非常可观。那么在一些场景下，通过选用合适的数据结构来存储，可以大幅减少内存的占用，...
C语言结构体的存储分配
苍白的咏叹调的博客
08-22 2418
1.简介 若结构体里面包含多种数据类型，其如何在内存中分配存储空间呢？ 编译器在处理结构体空间分配时，采取的是对齐方式，按照结构体中成员中成员类型字节数最大的为标准，从上往下对结构体成员进行赋值，若当前成员的字节数小于最大成员字节数，接着为下一个连续分配内存，若下一个的内存分配后会大于最大成员字节数，则为当前成员补齐至最大成员字节数。 2.具体解析 #include&lt;stdio.h...
C 程序设计课件：第七章 动态内存分配与数据结构.ppt
06-18
在C程序设计中，动态内存分配是编程时的一项重要技能，特别是在处理不确定大小的数据结构时。第七章"动态内存分配与数据结构"深入探讨了如何在程序运行时动态分配和释放内存，以及如何利用这些技术来构建高效的数据...
cunit动态内存分配与数据结构实用PPT学习教案.pptx
10-06
《CUnit动态内存分配与数据结构实用教程》深入解析了C++编程中关于动态内存管理和数据结构的关键概念。动态内存分配是程序运行时根据需要在内存中动态分配空间的技术，主要涉及自由存储区的管理。自由存储区不同于...
C++ 程序设计课件：第七章 动态内存分配与数据结构.ppt
09-21
在C++编程中，动态内存分配是程序在运行时根据需要请求系统分配内存的过程，而数据结构则是组织和管理大量数据的有效方式。第七章“动态内存分配与数据结构”主要探讨了这两个关键概念。 首先，动态内存分配允许...
C语言 动态内存分配详解
01-20
动态内存分配涉及到堆栈的概念：堆栈是两种数据结构。堆栈都是数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。 栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部...
数据结构-顺序表（动态分配存储空间）
热门推荐
快乐的小小程序猿
09-21 1万+
#include <stdio.h> #include <malloc.h> #include <stdlib.h> /** * 数组空间动态分配 */ #define InitSize 100 //动态分配存储空间时，不限制最大，只给定一个初始值 #define ListIncrement 10 //分配增量 typedef struct { int...
【数据结构】malloc(),realloc(),calloc(),free(),动态分配存储空间轻谈
m0_52586550的博客
04-05 380
在学习数据结构中遇到的几种关于分配空间大小的函数 说明： 动态内存分配相对于静态内存分配特点是： ​ 1：不需要预先分分配存储空间 ​ 2：分配的空间可以根据程序的需要扩大或缩小 为指针分配内存之后，指针就变成了数组 文章中的ElemType代表的是数据类型，在写代码的时候可以在开始的地方写上例如: typedef char ElemType 就可以做到定义的指针等一些数据类型的统一。 1：new,delete函数 这是c++的语法 分配空间： 指针名 = new ElemType[maxsize]; 释
学习数据结构--动态内存分配的必要知识（基础）
sw__xin的博客
04-23 1440
数据结构-动态内存开辟
数据结构学习笔记——存储空间的分配
HiSi_的博客
08-29 1217
1.静态分配 int i[10] = 10;//不接受未被初始化的变量 这就是静态分配，一开始就已经分配好了，直到超出其作用范围。 2.动态分配 用malloc()函数。 下面展示malloc()函数的用法 char *p; int num,n; n = 2*num; p = (cahr*)malloc(n*sizeof(char)); printf("请输入字符个数："); scanf("%d",&num); printf("请输入字符："); scanf("%s",p); printf("
C（数据结构与算法）---动态分配存储空间malloc函数的简单使用、顺序表基本运算的实现
DOER__的博客
12-06 746
p：指针变量(char*)：强制类型转换，转换为字符指针10：分配的字符个数sizeof（char） ：求每个字符占用的空间大小注：指针变量p属于自动变量,它自身的存储空间由系统自动分配和释放，但用 malloc()函数分配的存储空间(也就是 p指向的存储空间)不会被系统自动释放，所以需要使用free（p）释放下面我们看一个更难点的demo 注：这种动态存储空间分配方式的优点是不需要预先分配存储空间,分配的空间可以根据程序的需要扩大或缩小，如链式存储结构通常采用动态存储空间分配方式。其缺点是需要程序员简
和小白一起学数据结构四之存储分配问题
坚持更！
08-30 278
和小白一起学数据结构（四） 昨天博主遇到十一点后发文不过审的问题，非常糟心。想弃了cdsn这枚小贱人（哼），但又想到和博主小白一起学习的你们，还是决定以后更新时间放在晚上十点之前（看来第二天的文要提前写了qaq）。 我们今天来干嘛，今天就跟博主一起好好梳理复习一遍c语言中涉及到的内存分配问题。有些同学跟博主反映博客东西太基础了，要小博加一些高大上的内容，emmm，说到这个高大上啊，例如卷积神经网络...
数据结构 顺序表（静态分配内存）
ElysiumAILab
04-20 707
数据结构 顺序表（静态分配内存） 文章目录数据结构 顺序表（静态分配内存）前言一、顺序表二、代码部分1.头文件2.预定义3.定义存储结构4.顺序表初始化5.顺序表重置为空表6.判断是否是空表7.按位查找顺序表的元素，并返回第i个元素，传入e的引用来存储8.按值查找顺序表的元素,并传入i的引用存储该元素的位置，若无则返回09.顺序表插入数据元素10.顺序表删除数据元素11.顺序表遍历12.创建一个顺序表13.主函数总结 前言 数据结构要考试，写写代码复习复习 一、顺序表 顺序表有两种。一种为静态分配内
了解内存与数据结构的关系（一）。..
csmqq的专栏
05-16 2269
  内存：存储程序以及数据的地方．选择存盘时，内存中的数据才会被存入硬盘．按照这个说法是，打开一个应用软件应该会是占内存空间的；我在写代码时应该会占到内存空间；运行程序时会占到内存空间（恩，复杂度应该就是因为这里吧．如果不考虑复杂度的话，占到内存过大，那不就是很慢了？谁能受得了慢呢！）　．．．但是我若不干上述事情，那电脑应该不死机才对啊！内存还有在什么时候会用到呢？  内存是一个什么样的结
数据结构和算法之哈希表(散列)的介绍和内存布局
auy40613的博客
08-25 261
散列表的基本介绍 散列表(Hash table,也叫哈希表)，是根据关键码值(key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存 放记录的数据叫做散列表。 在写了一段java程序，java程序要去操作数据库，然后数据库经过一番操作将结果返回给java程序，java程序拿到结果进行显示，...
数据结构内存分配问题
最新发布
10-14
好的，关于数据结构内存分配问题，一般来说有两种方式：静态分配和动态分配。静态分配是在程序编译时就确定了内存大小，而动态分配则是在程序运行时根据需要动态地分配内存。 静态分配的优点是速度快，缺点是浪费...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拉风小宇

请我喝个咖啡呗

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值