#创作纪念日# 我的创作128天纪念日_csdn代码片获得分享

机缘

小升初时，我开始接触编程，进入了一个全新的世界。刚开始学习编程时，我只是对电脑的一些操作比较感兴趣，但慢慢地，我开始对编写程序、设计算法产生了浓厚的兴趣。在实践中不断摸索和探索，我渐渐意识到编程这一领域有着非常巨大的发展潜力。

我有一份坚定的理想，那就是成为编程领域的创作者。我相信通过自己的不断努力和锤炼，我会成为一个优秀的编程工程师。在我看来，编程领域每一天都在变化，无论是新的技术、新的编程语言或者是新的领域，都有无限的可能性。并且，编程是一门让人感到非常有成就感的学科，通过编写代码，我们可以让计算机按照我们的指令去执行各种各样的任务，这感觉就像是在创造一个个小宇宙一样，非常奇妙。

另外，编程也是一门需要不断自我挑战和超越的学科。在编程的过程中，我们需要思考问题、找寻解决方案、迭代修改，不断改进，这个过程让我有机会去更好地锻炼自己的思维能力和创造力。而且，在编程领域中，我们不受时间和空间的限制，可以在任何地方、任何时间进行工作和学习，这种自由和灵活度也是我非常向往的。

总之，我对编程领域产生了强烈的兴趣和热情，我相信只要坚持不懈地努力，我一定能够成为一个优秀的编程领域的创作者。

---

收获

不知不觉，加入CSDN已经有128天了
也有不少的收获——截至现在，已经完成了49篇文章的创作，而这篇恰好是第50篇；获得了16795的访问量，14个粉丝。
还有……

39次点赞

10次评论

37次收藏

代码片获得136次分享

当然，还有更加宝贵的收获……

首先，我学会了一种新的思考方式——逻辑思维。编程是一门需要严谨逻辑思维的学科，每一步操作都需要考虑到可能出现的所有情况，并设计出最优解决方案。在日常生活中，我也可以运用这种思考方式，更加高效地解决问题。

其次，编程让我懂得了“不断尝试”的重要性。编程过程中有很多bug需要我们去解决，而解决bug的过程就是不断尝试的过程。我们需要不断地修改代码，观察运行结果，找到问题所在并改正。这种经验也适用于生活中的种种困难，只有不停地尝试才能找到解决问题的方法。

再者，编程让我深刻体会到了“合作共赢”的力量。编写一个完整的程序通常需要多人协作完成，因为每个人都有自己的专长和经验，只有团结起来才能完成更复杂的任务。同时，与其他人分享自己的代码，也能从他们的经验中学习到更多的东西，得到进一步提高。

最后，编程让我更热爱探索未知。编程是一门创造性的学科，我们可以通过不断地学习和探索，开发出新的应用和功能，让自己的想象力得到真正的实现。这种成就感也进一步激发了我对生活和未来的热爱。

综上所述，成为编程领域的创作者，让我在思维、解决问题、合作、探索等方面都得到了很大的收获。我相信这些经验和能力将有助于我在未来的学习和工作中取得更好的成果。

---

日常

对我而言，创作已经成为了我生活中不可或缺的一部分。之前，创作对我来说只是一个简单的兴趣爱好。然而，随着时间的推移，创作渐渐地融入了我的生活，成为了我面对生活的一种方式。

创作让我变得更加敏锐和观察力更加敏锐。创作需要聚焦思维，挖掘细节，捕捉那些平常可能被忽略的东西。这些技能对于生活中的许多方面都非常有用，比如注意事物周围的细节，学会理性思考和更好地处理问题。

创作也让我更有耐心和毅力。无论是写博客还是其他形式的创作，都需要大量的时间和努力。我不仅需要花费时间把想法转化为文字，还需要反复修改，不断推敲和完善。这些经历不断地告诉我一个道理：成功需要付出长期的努力和坚持。

总之，创作已经成为了我的生活中不可或缺的一部分。它帮助我理解自己、观察周围的世界、培养耐心和毅力等等。无论是写作还是其他形式的创作，它都是一种很棒的方式来表达自己的想法和情感，也是我喜欢的事情之一。

同时，每天创作的习惯也促使我加快了作业的速度与质量，让我养成了良好的习惯。

---

成就

这……
好像写的都不咋地，随便贴一段吧~

#include <iostream>
#include <windows.h>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;
#define PI 3.1415926
#define wide 49
#define gao 24
#define high 6
int str[gao][wide];


int sentenceIndex = 0;
void heart_name(void);
char getSentenceChar(const char* sentence, int& index);
inline float getX(float x);
inline float getY(float y);
bool func(float x, float y);
#define X_DIVIDED_BY_Y 0.5
#define MAX_X (35.0 / X_DIVIDED_BY_Y)
#define MAX_Y 35.0
#define THRESHOLD 0.5
#define A 13
const int max_iterations = 128;
const float stop_threshold = 0.01f;
const float grad_step = 0.01f;
const float clip_far = 10.0f;

const float Pi = 3.14159265359f;
const float PI2 = 6.28318530718f;
const float DEG_TO_RAD = PI / 180.0f;

typedef struct { float x, y; } vec2;
typedef struct { float x, y, z; } vec3;
typedef struct { float m[9]; } mat3;

const vec3 light_pos = { 20.0f, 50.0f, 20.0f };
float clamp(float f, float a, float b) { return max(min(f, b), a); };

vec2 make2(float x, float y) { vec2 r = { x, y }; return r; }
vec2 add2(vec2 a, vec2 b) { vec2 r = { a.x + b.x, a.y + b.y }; return r; }
vec2 sub2(vec2 a, vec2 b) { vec2 r = { a.x - b.x, a.y - b.y }; return r; }
float dot2(vec2 a, vec2 b) { return a.x * b.x + a.y * b.y; }
float length2(vec2 v) { return sqrt(dot2(v, v)); }
vec3 make3(float x, float y, float z) { vec3 r = { x, y, z }; return r; }
vec3 add3(vec3 a, vec3 b) { vec3 r = { a.x + b.x, a.y + b.y, a.z + b.z }; return r; }
vec3 sub3(vec3 a, vec3 b) { vec3 r = { a.x - b.x, a.y - b.y, a.z - b.z }; return r; }
vec3 mul3(vec3 a, vec3 b) { vec3 r = { a.x * b.x, a.y * b.y, a.z * b.z }; return r; }
vec3 scale3(vec3 v, float s) { vec3 r = { v.x * s, v.y * s, v.z * s }; return r; }
float dot3(vec3 a, vec3 b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
float length3(vec3 v) { return sqrt(dot3(v, v)); }
vec3 normalize3(vec3 v) { return scale3(v, 1.0f / length3(v)); }
vec3 mul(mat3 m, vec3 v) {
	return make3(
		m.m[0] * v.x + m.m[3] * v.y + m.m[6] * v.z,
		m.m[1] * v.x + m.m[4] * v.y + m.m[7] * v.z,
		m.m[2] * v.x + m.m[5] * v.y + m.m[8] * v.z);
}

mat3 rotationXY(float x, float y) {
	vec2 c = { cos(x), cos(y) }, s = { sin(x), sin(y) };
	mat3 m = {
		c.y      , 0.0f, -s.y,
		s.y * s.x,  c.x,  c.y * s.x,
		s.y * c.x, -s.x,  c.y * c.x
	};
	return m;
}

float opI(float d1, float d2) { return max(d1, d2); }
float opU(float d1, float d2) { return min(d1, d2); }
float opS(float d1, float d2) { return max(-d1, d2); }

float sdPetal(vec3 p, float s) {
	p = add3(mul3(p, make3(0.8f, 1.5f, 0.8f)), make3(0.1f, 0.0f, 0.0f));
	vec2 q = make2(length2(make2(p.x, p.z)), p.y);

	float lower = length2(q) - 1.0f;
	lower = opS(length2(q) - 0.97f, lower);
	lower = opI(lower, q.y);

	float upper = length2(sub2(q, make2(s, 0.0f))) + 1.0f - s;
	upper = opS(upper, length2(sub2(q, make2(s, 0.0f))) + 0.97f - s);
	upper = opI(upper, -q.y);
	upper = opI(upper, q.x - 2.0f);

	float region = length3(sub3(p, make3(1.0f, 0.0f, 0.0f))) - 1.0f;
	return opI(opU(upper, lower), region);
}

float map(vec3 p) {
	float d = 1000.0f, s = 2.0f;
	mat3 r = rotationXY(0.1f, PI2 * 0.618034f);
	r.m[0] *= 1.08f;  r.m[1] *= 1.08f;  r.m[2] *= 1.08f;
	r.m[3] *= 0.995f; r.m[4] *= 0.995f; r.m[5] *= 0.995f;
	r.m[6] *= 1.08f;  r.m[7] *= 1.08f;  r.m[8] *= 1.08f;
	for (int i = 0; i < 21; i++) {
		d = opU(d, sdPetal(p, s));
		p = mul(r, p);
		p = add3(p, make3(0.0, -0.02, 0.0));
		s *= 1.05f;
	}
	return d;
}

vec3 gradient(vec3 pos) {
	const vec3 dx = { grad_step, 0.0, 0.0 };
	const vec3 dy = { 0.0, grad_step, 0.0 };
	const vec3 dz = { 0.0, 0.0, grad_step };
	return normalize3(make3(
		map(add3(pos, dx)) - map(sub3(pos, dx)),
		map(add3(pos, dy)) - map(sub3(pos, dy)),
		map(add3(pos, dz)) - map(sub3(pos, dz))));
}

float ray_marching(vec3 origin, vec3 dir, float start, float end) {
	float depth = start;
	for (int i = 0; i < max_iterations; i++) {
		float dist = map(add3(origin, scale3(dir, depth)));
		if (dist < stop_threshold)
			return depth;
		depth += dist * 0.3;
		if (depth >= end)
			return end;
	}
	return end;
}

float shading(vec3 v, vec3 n, vec3 eye) {
	vec3 ev = normalize3(sub3(v, eye));
	vec3 vl = normalize3(sub3(light_pos, v));
	float diffuse = dot3(vl, n) * 0.5f + 0.5f;
	vec3 h = normalize3(sub3(vl, ev));
	float rim = pow(1.0f - max(-dot3(n, ev), 0.0f), 2.0f) * 0.15f;
	float ao = clamp(v.y * 0.5f + 0.5f, 0.0f, 1.0f);
	return (diffuse + rim) * ao;
}

vec3 ray_dir(float fov, vec2 pos) {
	vec3 r = { pos.x, pos.y, -tan((90.0f - fov * 0.5f) * DEG_TO_RAD) };
	return normalize3(r);
}

float f(vec2 fragCoord) {
	vec3 dir = ray_dir(45.0f, fragCoord);
	vec3 eye = { 0.0f, 0.0f, 4.5f };
	mat3 rot = rotationXY(-1.0f, 1.0f);

	dir = mul(rot, dir);
	eye = mul(rot, eye);

	float depth = ray_marching(eye, dir, 0.0f, clip_far);
	vec3 pos = add3(eye, scale3(dir, depth));
	if (depth >= clip_far)
		return 0.0f;
	else
		return shading(pos, gradient(pos), eye);
}
char getSentenceChar(const char* sentence, int& index)
{
	while (true)
	{
		if (index >= strlen(sentence))
		{
			index = 0;
		}
		char c = sentence[index++];
		if (' ' == c)
		{
			index++;
		}
		else
		{
			return c;
		}
	}
}

inline float getX(float x)
{
	return (x - MAX_X / 2) * X_DIVIDED_BY_Y;
}

inline float getY(float y)
{
	return MAX_Y / 7.0 - y;
}

bool func(float x, float y)
{
	return (pow(x, 2) + pow(y, 2) + A * x - A * sqrt(pow(x, 2) + pow(y, 2))) < THRESHOLD;
}

void printchar()
{
	int i, j;
	for (i = 0; i < gao; i++)
	{
		for (j = 0; j < wide; j++)
		{
			if (str[i][j] == 0)cout << " ";
			else if (str[i][j] == 1)cout << "*";
			else cout << " ";
		}
		cout << endl;
	}
}

void Color(int a) {
	if (a == 0 || a == 14 || a == 20) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
	}
	else if (a == 1 || a == 12) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
	}
	else if (a == 2) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_GREEN);
	}
	else if (a == 3) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
	}
	else if (a == 4 || a == 11) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_RED);
	}
	else if (a == 5 || a == 13) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
	}
	else if (a == 7) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_GREEN | FOREGROUND_BLUE);
	}
	else if (a == 15) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY);
	}
	else if (a == 16) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);
	}
	else if (a == 17) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED);
	}
	else if (a == 8) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
	}
	else if (a == 6) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_BLUE);
	}
	else if (a == 9) {
		SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
			FOREGROUND_INTENSITY | FOREGROUND_RED | BACKGROUND_RED | BACKGROUND_GREEN);
	}
}
void countdown(void)
{
	Color(0);
	int temp, i, j;
	system("cls");
	Sleep(1000);
	system("cls");
	void printchar();
	for (temp = 3; temp >= 1; temp--)
	{
		switch (temp)
		{
		case 1:
			for (i = 2; i <= 15; i++)
			{
				for (j = wide / 2; j <= wide / 2 + 1; j++)str[i][j] = 1;
			}break;
		case 2:
			for (i = 2; i <= 15; i++)
			{
				switch (i)
				{
				case 2:case 3:case 8:case 9:case 14:case 15:
					for (j = wide / 2 - 7; j <= wide / 2 + 8; j++)str[i][j] = 1; break;
				case 4:case 5:case 6:case 7:
					for (j = wide / 2 + 7; j <= wide / 2 + 8; j++)str[i][j] = 1; break;
				default:
					for (j = wide / 2 - 7; j <= wide / 2 - 6; j++)str[i][j] = 1; break;
				}
			}break;
		case 3:
			for (i = 2; i <= 15; i++)
			{
				switch (i)
				{
				case 2:case 3:case 8:case 9:case 14:case 15:
					for (j = wide / 2 - 7; j <= wide / 2 + 8; j++)str[i][j] = 1; break;
				default:
					for (j = wide / 2 + 7; j <= wide / 2 + 8; j++)str[i][j] = 1; break;
				}
			}break;
		}
		printchar();
		Sleep(1000);
		for (i = 0; i < gao; i++)
		{
			for (j = 0; j < wide; j++)str[i][j] = 0;
		}
		system("cls");
	}
	Sleep(500);
	system("cls");
}
void dian(int b)
{
	int i = 0;
	while (i < b)
	{
		cout << ".";
		Sleep(500);
		i++;
	}
	i = 0;
	cout << endl;
}
int main()
{
	system("title Windows实用系统工具");
a:
	string yonghuming, mima;
	while (MessageBox(NULL, TEXT("即将打开程序"), TEXT("打开程序"), MB_YESNO) == IDNO)
	{
		while (MessageBox(NULL, TEXT("即将退出程序"), TEXT("退出程序"), MB_YESNO) == IDNO)
		{
			goto a;
			break;
		}
		return 0;
		break;
	}
Login:
	int i;
	system("cls");
	Color(0);
	char Word[120] = "==========================================Windows实用系统工具==========================================";
	for (i = 0; Word[i] != NULL; i++)
	{
		cout << Word[i];
		Sleep(50);
	}
	cout << "\n\n";
	Color(0);
	int y = 0;
	while (1) {
		Color(5);
		char Word[80] = "请输入用户名";
		for (i = 0; Word[i] != NULL; i++)
		{
			cout << Word[i];
			Sleep(50);
		}
		cout << "\n";
		cin >> yonghuming;
		char Wort[41] = "请输入密码";
		for (i = 0; Wort[i] != NULL; i++)
		{
			cout << Wort[i];
			Sleep(50);
		}
		cout << "\n";
		cin >> mima;
		Color(0);
		if (yonghuming == "123456" && mima == "123456")
		{
			goto Start;
			break;
		}
		else
		{
			Color(17);
			cout << "用户名或密码错误，请重试" << endl;
			Color(0);
			y++;
		}
		if (y >= 5) {
			Color(17);
			cout << "用户名或密码错误次数过多，请5分钟后再试" << endl;
			Color(0);
			goto Waiting;
			break;
		}
	}
Waiting:
	Sleep(600000);
	goto Login;

Start:
	string chosen_functions;
	cout << "加载中";
	dian(6);
	system("cls");
	Color(0);
	cout << "==========================================Windows实用系统工具==========================================\n\n";
	Color(0);
Chosen_functions:
	Color(4);
	Sleep(500);
	system("cls");
	char Wor[90] = "请问您想使用什么功能?";
	for (i = 0; Wor[i] != NULL; i++)
	{
		cout << Wor[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(1000);
	Color(6);
	char Wo[90] = "功能（输入想使用的功能所对应的中文即可）:";
	for (i = 0; Wo[i] != NULL; i++)
	{
		cout << Wo[i];
		Sleep(50);
	}
	cout << "\n";
	Color(5);
	Sleep(500);
	char W[10] = "关机";
	for (i = 0; W[i] != NULL; i++)
	{
		cout << W[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(500);
	char N[10] = "重启";
	for (i = 0; N[i] != NULL; i++)
	{
		cout << N[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(500);
	char B[10] = "休眠";
	for (i = 0; B[i] != NULL; i++)
	{
		cout << B[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(500);
	char C[60] = "打开任务管理器";
	for (i = 0; C[i] != NULL; i++)
	{
		cout << C[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(500);
	char D[60] = "打开cmd命令提示符";
	for (i = 0; D[i] != NULL; i++)
	{
		cout << D[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(500);
	char R[60] = "删除当前C盘用户（极度危险，慎用）";
	for (i = 0; R[i] != NULL; i++)
	{
		cout << R[i];
		Sleep(50);
	}
	cout << "\n";
	Sleep(500);
	char U[30] = "关于";
	for (i = 0; U[i] != NULL; i++)
	{
		cout << U[i];
		Sleep(50);
	}
	cout << "\n";
	Color(5);
	Color(0);
	cin >> chosen_functions;
	if (chosen_functions == "关机")
	{
		system("cls");
		Color(0);
		cout << "==========================================Windows实用系统工具==========================================\n\n";
		Color(0);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		if (MessageBox(NULL, TEXT("您需要定时关机吗？"), TEXT("定时关机"), MB_YESNO) == IDNO)
		{
			Beep(2500, 200);
			Beep(2500, 200);
			Beep(2500, 200);
			if (MessageBox(NULL, TEXT("即将关机"), TEXT("关机"), MB_YESNO) == IDNO)
			{
				goto Chosen_functions;
			}
			else
			{
				char Zx[10] = "关机中";
				for (i = 0; Zx[i] != NULL; i++)
				{
					cout << Zx[i];
					Sleep(50);
				}
				dian(6);
				countdown();
				system("shutdown -p");
			}
		}
		else
		{
			char o[50] = "请问您要在几分钟后关机？";
			for (i = 0; o[i] != NULL; i++)
			{
				cout << o[i];
				Sleep(50);
			}
			double guanji;
			cin >> guanji;
			system("cls");
			Color(0);
			cout << "==========================================Windows实用系统工具==========================================\n\n";
			Color(0);
			Sleep(guanji * 60000 - 3);
			countdown();
			system("shutdown -p");
		}

	}
	else if (chosen_functions == "重启")
	{
		system("cls");
		Color(0);
		cout << "==========================================Windows实用系统工具==========================================\n\n";
		Color(0);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		if (MessageBox(NULL, TEXT("您需要定时重启吗？"), TEXT("定时重启"), MB_YESNO) == IDNO)
		{
			Beep(2500, 200);
			Beep(2500, 200);
			Beep(2500, 200);
			if (MessageBox(NULL, TEXT("即将重启"), TEXT("重启"), MB_YESNO) == IDNO)
			{
				goto Chosen_functions;
			}
			else
			{
				cout << "重启中";
				dian(6);
				system("shutdown -r");
			}
		}
		else
		{
			char X[50] = "请问您要在几分钟后重启？";
			for (i = 0; X[i] != NULL; i++)
			{
				cout << X[i];
				Sleep(50);
			}
			double chongqi;
			cin >> chongqi;
			system("cls");
			Color(0);
			cout << "==========================================Windows实用系统工具==========================================\n\n";
			Color(0);
			Sleep(chongqi * 60000 - 3);
			countdown();
			system("shutdown -r");
		}
	}
	else if (chosen_functions == "休眠")
	{
		system("cls");
		Color(0);
		cout << "==========================================Windows实用系统工具==========================================\n\n";
		Color(0);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		if (MessageBox(NULL, TEXT("您需要定时休眠吗？"), TEXT("定时休眠"), MB_YESNO) == IDNO)
		{
			Beep(2500, 200);
			Beep(2500, 200);
			Beep(2500, 200);
			if (MessageBox(NULL, TEXT("即将休眠"), TEXT("休眠"), MB_YESNO) == IDNO)
			{
				goto Chosen_functions;
			}
			else
			{
				cout << "休眠中";
				dian(6);
				system("shutdown -h");
			}
		}
		else
		{
			char V[50] = "请问您要在几分钟后休眠？";
			for (i = 0; V[i] != NULL; i++)
			{
				cout << V[i];
				Sleep(50);
			}
			double xiumian;
			cin >> xiumian;
			system("cls");
			Color(0);
			cout << "==========================================Windows实用系统工具==========================================\n\n";
			Color(0);
			Sleep(xiumian * 60000 - 3);
			countdown();
			system("shutdown -h");
		}
	}
	else if (chosen_functions == "打开任务管理器")
	{
		system("cls");
		Color(0);
		cout << "==========================================Windows实用系统工具==========================================\n\n";
		Color(0);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		if (MessageBox(NULL, TEXT("即将打开任务管理器"), TEXT("任务管理器"), MB_YESNO) == IDNO)
		{
			goto Chosen_functions;
		}
		else
		{
			char Zy[10] = "打开中";
			for (i = 0; Zy[i] != NULL; i++)
			{
				cout << Zy[i];
				Sleep(50);
			}
			dian(6);
			countdown();
			system("taskmgr.exe");
		}
	}
	else if (chosen_functions == "打开cmd命令提示符")
	{
		system("cls");
		Color(0);
		cout << "==========================================Windows实用系统工具==========================================\n\n";
		Color(0);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		Beep(2500, 200);
		if (MessageBox(NULL, TEXT("即将打开cmd命令提示符"), TEXT("cmd命令提示符"), MB_YESNO) == IDNO)
		{
			goto Chosen_functions;
		}
		else
		{
			char Zy[10] = "打开中";
			for (i = 0; Zy[i] != NULL; i++)
			{
				cout << Zy[i];
				Sleep(50);
			}
			dian(6);
			countdown();
			system("cmd.exe");
		}
	}
	else if (chosen_functions == "删除当前C盘用户（极度危险，慎用）")
	{
		for (i = 0; i <= 3; ++i)
		{
			Beep(1000, 200);
		}
		if (MessageBox(NULL, TEXT("您确定要删除当前C盘用户吗？（极度危险，慎用）"), TEXT("警告"), MB_YESNO) == IDNO)
			goto Chosen_functions;
		else
			for (i = 0; i <= 3; ++i)
			{
				Beep(1000, 200);
			}
		if (MessageBox(NULL, TEXT("您真的确定要删除当前C盘用户吗？（极度危险，慎用）"), TEXT("警告"), MB_YESNO) == IDNO)
			goto Chosen_functions;
		else
			for (i = 0; i <= 3; ++i)
			{
				Beep(1000, 200);
			}
		if (MessageBox(NULL, TEXT("您千真万确确定要删除当前C盘用户吗？（极度危险，慎用）"), TEXT("警告"), MB_YESNO) == IDNO)
			goto Chosen_functions;
		else
		{
			string c;
			c = "rd /s /q \"C:/Users\"";
			for (i = 0; i <= 3; ++i)
			{
				Beep(1000, 200);
			}
			if (MessageBox(NULL, TEXT("即将删除（极度危险，慎用）"), TEXT("警告"), MB_YESNO) == IDNO)
				goto Chosen_functions;
			else
			{
				for (i = 0; i <= 30; ++i)
				{
					Beep(1000, 1000);
				}
				countdown();
				system(c.c_str());
			}
		}
	}
	else if (chosen_functions == "关于")
	{
		system("cls");
		system("Color 79");
		char Zv[200] = " 该程序为喜欢电脑的平某人原创";//
		for (i = 0; Zv[i] != NULL; i++)
		{
			cout << Zv[i];
			Sleep(50);
		}
		cout << endl << endl;
		char Zn[200] = " 禁止抄袭或商用";
		for (i = 0; Zn[i] != NULL; i++)
		{
			cout << Zn[i];
			Sleep(50);
		}
		cout << endl << endl;
		char Zk[50] = " 感谢您的使用和支持！";
		for (i = 0; Zk[i] != NULL; i++)
		{
			cout << Zk[i];
			Sleep(50);
		}
		Sleep(1000);
		system("cls");
		float a, b, c;
		for (b = 1.5; b > -1.5; b = b - 0.1)
		{
			for (a = -1.5; a < 1.5; a = a + 0.05)
			{
				c = a * a + b * b - 1;//
				putchar(c * c * c - a * a * b * b * b <= 0.0 ? 'v' : ' ');
			}
			system("color 0c");
			putchar('\n');
		}
		char Zo[50] = " 按任意键返回......";
		for (i = 0; Zo[i] != NULL; i++)
		{
			cout << Zo[i];
			Sleep(50);
		}
		system("pause");
		goto Chosen_functions;
	}
	else
	{
		MessageBox(NULL, TEXT("输入错误，请重试"), TEXT("输入错误"), MB_OK);
		goto Chosen_functions;
	}
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776

详见：#Windows实用系统工具 用C++实现一个可以在Windows系统下关机、删除C盘用户等功能的小程序

---

憧憬

编程是一门让人沉迷其中的艺术，我喜欢用代码来创造各种有趣的东西。我对未来的憧憬是，在这个数字时代里，成为一名优秀的编程创作者。

未来是充满无限可能的，我相信在这个时代的编程领域，会有更多更先进的技术被开发出来。作为一名编程领域创作者，我想要不断进步，积累更多的技能和经验，让自己能够创造出更加出色的作品。

我憧憬着能够开发出一个能够帮助人们解决实际问题的应用程序，比如一个可以自动诊断疾病的医疗软件，或者是一个可以帮助人们提高工作效率的办公软件。我也想创造出一些游戏或者娱乐应用，让人们能够在闲暇之余更好地享受生活。

但是，我的未来憧憬不仅仅局限于编程领域，我也希望能够探索其他领域的知识，从而获得更多的灵感与思考。我想学习物理、化学、历史和人文等课程，或者参加各种社会实践活动，这些都可以丰富我的人生经验，让我更好地理解人类的需求与问题。

最重要的是，我希望能够成为一个有责任感、有创造力、有同情心的人。我相信只有这样，才能够真正成为一名优秀的编程创作者，创造出更多有益于人类的作品，并为这个世界带来一点点改变。

我会坚持学习、努力创作，实现自己的梦想与愿景，期待着展开自己美好的未来，期待着与大家一起努力，一起进步，创造出一个更好的明天！