请问，C语言读取文本文件，获取特定字符串，作为鼠标点击按钮？

zzz19760225

文本里的选项文字，不确定文本内和C语言输出屏幕的位置，根据文本制作而定。
那么输出到屏幕，是否可以获取选123的字符串位置，作为鼠标点击的定位呢？
（或者，根据不同屏幕界面大小的数量和比例，对应文本文件读取输出屏幕的相对位置和字体数量推算，算出其文本排序搜索的特定字符串线位置可能？）
（软件作为外壳，过手而已，文本制作者，不需要参与复杂的按钮配置问题，又具有一定灵活机动性可以发挥）
1.txt

[选1游戏开始]

背个书包上学校

[选2游戏说明]


下班烧饭喝酒看新闻
玩玩游戏睡觉

[选3退出游戏]
复制代码

--------------------------------------------------
样本
1.txt

 456  [转眼间]就穿越回了    1450年
123 但 是 一 直 [0一1道0]1550年情况依然是如此
000 而敌方      1650年[已经]开始了不同
复制代码

百度“c语言easyx在文件中查找[和]字符位置”，AI智能回答：

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>

int main()
{
    // 假设我们有一个文件file.txt，内容如下：
    // This is an example [text] with some characters.
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r"); // 打开文件用于读取
    if (file == NULL) {
        printf("无法打开文件\n");
        return 1;
    }
 
    int line = 1;
    int position = 0;
    char ch;
 
    // 逐字符读取文件内容
    while ((ch = fgetc(file)) != EOF) {
        position++; // 更新当前位置
 
        if (ch == '[') {
            printf("在第 %d 行，第 %d 个位置找到 '['\n", line, position);
        }
        if (ch == ']') {
            printf("在第 %d 行，第 %d 个位置找到 ']'\n", line, position);
        }
 
        if (ch == '\n') {
            line++; // 行数增加
            position = 0; // 重置位置计数器
        }
    }
 
    fclose(file); // 关闭文件
    system("pause"); // 暂停，以便查看输出结果
    return 0;
}
复制代码

执行文件exe的结果：

在第 1 行，第 7 个位置找到 '['
在第 1 行，第 14 个位置找到 ']'
在第 2 行，第 17 个位置找到 '['
在第 2 行，第 25 个位置找到 ']'
在第 3 行，第 23 个位置找到 '['
在第 3 行，第 28 个位置找到 ']'
请按任意键继续. . .
复制代码

2024.8.28
---------------------------------------------------------------------
文本线，距离，单元字体的数量，字符串实际占用的像素宽度和高度（int textheight(LPCTSTR str);
），这些概念与全部概念变量量化为数量单元，组成一个数量结构统一的可能？
计算字体数量的二进制信息层面（估计不会用到），十六进制汇编处理信息层面（可能比较大，汇编处理的信息基础。汇编层面也分为文章，字符集正则，工程记录信息的几个软件工具关联存在空间。或者说后面的处理，就是这些层面内容的显示显现），字符集处理的所谓正则（这个平常经常），一般习惯文章处理，四个问题可能空间内容需要的技术准备。
-----------------
1
大话西游一类的网络文字游戏模式，其文字里的选项，选择题。
八戒走到菜菜城，进了:（<武器店><服装店><饰品店>）。
多文本，每次载入一个单独独立的文本，需要制作者每次弄一段文字为一个文本。
全文本，每次截取一个文本的一部分，如一个小说的txt里一段章节。
多文本与全文本之间的一种适度选择。
每次点击操作载入下一页的刷新，处理一次选项的单元数量，避免过度太多出问题。
上图片区选项鼠标点击，中间文字文本文件显示里的选项点击，下边缘脱离文本的框架文字选项点击。
2
图片的单多图，简单电影胶卷模式的动画效应（在无法使用或避免使用gif的情况），怎么与同数量特征的编码文本联动。
图片（影视胶卷），Sleep(胶卷间隔时间)，图片，间隔时间，图片，.............
用一个单图重复的胶卷形式实现图内多因素动画，与多图集成到一个背景上分布的做法选择。需要适合制作者理解认识使用的选择，全都有，可以自选。但是要简化，就得选择一个简单的。
3
列表图表一样的参数单多页界面
2024.8.30
-----------------------
20240913
翻页，文字没有刷新产生重叠现象，在鼠标动作后面加一个刷新。(不跟着刷新，在while里循环，鼠标移动，while会自动产生页面文字闪烁现象)

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <graphics.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main (){
 
char str[1024]={0};

    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));

	int H0=1200,I0=700,H1=1200,I1=500;
    initgraph(H0, I0);
    int a = 0;

    while (!kbhit()) 
	{

     MOUSEMSG msg = GetMouseMsg();
     if (msg.uMsg == WM_LBUTTONDOWN) { 
            wsprintf(szBuffer,TEXT("%s %d.mp3"),TEXT("close"),a);
            mciSendString(szBuffer, NULL, 0, NULL); 
            a=a+1;                                               
            clearrectangle(0,I1,H0,I0);                        } //刷新文字区域

     if (msg.uMsg == WM_RBUTTONDOWN) {
            wsprintf(szBuffer,TEXT("%s %d.mp3"),TEXT("close"),a);
            mciSendString(szBuffer, NULL, 0, NULL); 
            a=a-1;                                              
            clearrectangle(0,I1,H0,I0);                        }//刷新文字区域 

 	            wsprintf(szBuffer,TEXT("%s %d.mp3"),TEXT("play"),a); 
                mciSendString(szBuffer, NULL, 0, NULL); 
                
     sprintf(str,"%d.jpg",a);
 
            IMAGE img;
            loadimage(&img,str,H1,I1);
            putimage(0, 0, &img);
 
     sprintf(str,"%d.txt",a);

            FILE *file = fopen(str, "r");// 打开并读取文本文件
			if (file) 
			{
                 char buffer[1024];
                 int y = 600; // 假设图片下方开始显示文本，上下600位置写字
				 char *line;
                 while (fgets(buffer, sizeof(buffer), file)) 
				 {// 逐行读取文件内容并显示
                     line = strdup(buffer); // 复制行以便修改
                     outtextxy(20, y, line); // 显示文本，假设从(20, y)开始
                     free(line);
                     y += 20;               // 下一行的y坐标
				 }
             fclose(file); // 关闭文件
			 }
 
	}
 
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    closegraph();
 
return 0;
}
复制代码

zzz19760225

批处理的第三方软件读取文件夹图片集

:0
for /l (123.jpg)
第三方显示变量名图片
goto next
ping
goto 0
:next
复制代码

设置一个变量数字增量呢？set /a n=,set /a n=n+1,if n==最终数字，则停止。还是需要goto，单独并不能循环重复。
goto尽量要批量，如一船一船的，一个程序里有三个goto对应通用，组用，专用的，如果goto全用变量，一个就可以了。

@echo off
set /a a=5
:0
ping -n %a% 127.0.0.1 >null
echo:00000
goto:0
pause
复制代码

ping的数值化变量是可以的。批处理全变量或大部分命令的数值全变量。
一个无限自转goto（或者for/l一生多生循环，对应多种进制组合），直到关闭。里面有for/l计数类集合。

for /l (0,1,10) (十个十年的百年一世
for /l (0,1,10) (十年一代
for /l (0,1,360) (360天一年
for /l (0,1,6) (360天额外的5或6天，以独立形式加入
for /f (0.txt) (读取输入信息寄存器切割为日程表，作息表，睡醒表，工作劳动表，一生百年事程表，一代十年事程表，一年事程表，年内循环使用的地图和地图上自由度发挥的路线具体事情。
)))))
复制代码

:1
goto:1
goto(123):1
goto+123:1
:1;
goto+123:1;
goto(123-1=0):1;
信息小人的出生开始和结束，中间的各种内容，以及这些内容怎么通过BMP图片，集成为一种动态演化的图，可以眼睛看的什么一生形态，将时空集成起来，对付人生的参与熟记忆，好恶，主动被动记忆遗忘，建立旁观人生图，如佛让其弟子看前世后生的看一生。
人民自治自组基层土工小组，自下而上生长组构覆盖。自动自下而上生长到极限的家概念人民组织，世代周期新生代重生重新生长一遍。（私有化颜色活动也是新生代群体生长，还得考虑历史文化的后天加成参与投入组合）
以勇士大闯关为基础模型，加入中医许阳作为剧情，勇士大闯关的通天塔类，增加宏观中医和微观中医。将万物太极与原子分子数量数学之间，作为微观中医内容。将抽象通用传统文化中医基础理论内容，作为宏观中医，联系唯物理论为广义中医，治天下。这样基本架构不需要费脑子想剧情了，抄写修改就可以了。（将阴阳放在太极前面，气清浊相对开天辟地。混元，太极圆，原子分子单元集合等概念体联系起来。空，作为不在概念，就是理论上存在，但是实际现实不会存在的静态抽象内容，或极少存在，作为一个0概念镜子，去相对差异=看见相对内容存在，0奇点临界点=相对差异的反射镜子。其余机械理论，是连续变化时空体，其相对慢速的截取静态时空。动态和描述动态的相对静态理论，是主要需要的内容。但是将其余的大部分内容扫清保障环境=谋略和内务政务，余下的主力集中动态内容=相对静态理论，重点重心中心。）勇士大闯关的存取和随机用户名，已有用户的自动演化和先后账号互相模拟演化的关系（这种不需要去想了，超出范围的想法情绪基本截断，集中于已有需要可行的内容）。勇士大闯关里加入图片是可以的，需要弄固定图片大小显示的，这样固定空文字行数下的文字配合图片显示。（中医许阳这本书的意义不会小，比历史的组织，中医名家等普及书籍更高，次于黄帝内经）

zzz19760225

将批处理帖子分解为几个变量组合，每个变量获取其类文件夹里的文件文本行内容。
1开始标签变量
2主题名
3主题内容
4回帖名
5回帖内容
6回帖地址，7回帖点赞，8回帖点踩，
9结束标签变量

信息技术工程复杂细致至零件单元结构界面和内容，与用户需求问题相关常极界面和内容。器能的用户界面，其历史道路，历史阶段，历史年代的相对变与不变的相对。工程类似字典，有关科目就得列，具体要执行的，少了不行。（少了可以，那就少呗）

制造用器的自由度，器默认初始固定记录模式，用户自由度修改储存模式。这种自由度，好像很不好自由。华夏神器，一般平常普通用器。神器概念不好说得通，只是作为模糊混沌的代表存在，放大的个体个人为整体代表，如道一类概念，还是普通和家概念好说明白，人人都是过日子，谁不知道呢。这样所谓神器，就是放大的变量或抽象的家，小家，中家，大家。用家，就好理解了，哦，所谓神器，就是最大的家。这样物器，人器，神器。小器，中器，大器。
器，小器，中器，大器。
家，小家，中家，大家。
事，小事，中事，大事。

VB6.0按钮图片，按按钮控件，然后按钮界面显示的图片运行内容。，也就是不另外安排图片控件一picture或二lmage
透明按钮和按钮图片，循环多个按钮图片。
VB的界面可不可以改呢，改为鼠标一键显示属性栏，再按一下就挂起来。再有快捷键调用，快捷键放在头栏显示，只提示一个总的ctrl+0~9一类（快捷组合键的无限数量化？），后面自己测试记忆。
对技术印象的快捷键，对用户的提示快捷键+挂起和显示。也就是对一般普通用户简化，是可以的，没必要都很复杂。器能，是有可能度的。（缺点是到逻辑组合的那部分，还能简化吗，应该有一个量与质的相对边缘，一般到那个边缘边界就够用了，就停止。而个人使用学习，就可以继续提高那个边缘线，类似车间钳工技师再专门产品上，相对综合知识经验，技术手册，为底线工程师的一点点事实践动手记忆回忆积累的进步）

在一个文件夹里到处随机移动的文件和文本信息小人，不能出这个文件夹世界。
游戏的路社区，以路为集中的分散社区。
国=都，郡=府，县=城，乡=镇，村=社。八洲四海，一个中国，一个外国。外国郡府，洲和州就不用于外国了，减少游戏干扰。市作为市集概念象，不作为城市和地方的名称，属于历史阶段希望经济科技也强盛的模仿选择，但是实际作用只是比较效应，对具体反而横加干扰，可以取消。米郡，阴郡（其原有的郡缩小为县），法郡，德郡，澳郡，加郡。单字重复的需要特殊处理，成词以区别。一个人从中国中原河南郡，乘飞机到外国米郡，又转机到外国阴郡，然后回到江南郡（上海作为县吧，结构功能与特权的矛盾不好，用一个统一的，可以因事特殊处理，不能因特殊情况而要超出整体的特权。缺点是干事多了，会不会激励不足。这点应该分为两类，就如工人固定工资与甲方乙方联系，工人不奴隶干活的问题，其捆绑的话语不提所有权，将两类不同的利益捆绑起来，作为违法不付拖付工资的依据，这时也不提法制了，工人也成私有化资本家一桌人了，回头该历史反复验证的怎么对付工人，还是怎么对付。也就是特殊事的量增加，对工人的奖励也增大，而不是所有权的利润增大。一旦干顺手了，工人利益大大的，所有权形式的利润一方，可以扔掉了，你再去找事吧。无限资本所有权，与时效可以剥离的资本所有权，最后组织为劳动者的时效股份所有权循环承接，这里劳动者时效是方便变化的调整，资本时效是将无限改为有限极限，甚至利用完了就驱离。慈不掌兵，善不持公，向善能恶持公）。
一个批处理，上半部分是程序，下半部分是信息。
先一个bat将自身从中国南京府文件夹，移动到中国上海县。
不删除自身的移动，先复制后删除的分段处理移动，只复制信息建立新文件删除原文件。
两个bat呼叫模式，信息小人一号，呼叫移动交通工具，腿脚，自行车，电瓶车，摩托车，汽车，飞机，轮船啥的，这些交通工具bat被叫来，原本的呼叫停止，静态被动被交通工具bat移动。
如果bat本身结尾有删除功能单元，前面是指向复制自身，是不是模拟了移动呢？
1复制信息小人一号bat文件，至上海县文件夹；
2结尾删除自身bat文件。

@echo off
xcopy "D:\dos\bat\xsj\地星村\土洲\中国\江南郡\南京城\信息小人一号.bat" "D:\dos\bat\xsj\地星村\土洲\中国\江南郡\上海县\信息小人一号.bat" 
pause
复制代码

报错信息：

目标 D:\dos\bat\xsj\地星村\土洲\中国\江南郡\上海县\信息小人一号.bat 是文件名
还是目录名
(F = 文件，D = 目录)?

是一个选择，不是报错。

目标 D:\dos\bat\xsj\地星村\土洲\中国\江南郡\上海县\信息小人一号.bat 是文件名
还是目录名
(F = 文件，D = 目录)? f
D:\dos\bat\xsj\地星村\土洲\中国\江南郡\南京城\信息小人一号.bat
复制了 1 个文件
请按任意键继续. . .
复制代码

是可以的，实现了从南京城文件夹，复制bat本身至上海县文件夹，然后删除自身。（就是有点磕磕绊绊的，选择文件或文件夹，复制过一次的已有同名提示覆盖。为什么呢，要一刀流的，刷）

@echo off
xcopy "D:\dos\bat\xsj\地星村\土洲\中国\江南郡\南京城\信息小人一号.bat" "D:\dos\bat\xsj\地星村\土洲\中国\江南郡\上海县\信息小人一号.bat" 
del %0
pause
复制代码

应该是：

set 变量1=地址1
set 变量2=地址2
命令 变量1 变量2
del删除自身%0
复制代码

地址2变量，是信息小人的随机内容，要怎么实现，还不能跑出地星村这个文件夹。
D:\dos\bat\xsj\地星村\为一个固定的变量，其余的是几个洲国的字词组合选择，在这些选择里，是不会跑出新世界xsj和地星村的固定变量前提。
一个人一生，一年，一天吃饭的事利益，上下两代或五代人的利益，世代人的利益，争取统治者所有权与劳动者劳动的相对短近长远关系。不需要在法律这种形式衣服上去争辩，而是在我们，上下，代世代的统治者利益角度去看所有权利益的取舍，在这种利益中，私有化群体只是利益食物。公有化的善良失败，与私有化的向恶必胜，导致向善的变质需求。
游戏的天气雨雪晴和明暗黑色彩，房路空间，身体心情，环境相对事情情绪。
新纪年历史王朝表，表格互换西历，农历阴阳历，新历（365天，客观少一天的日历与其余实际日历只能在年上交换，天不好全交换，可以交换大部分）。
外国法不是国内法，外国来的罪犯，要进行国内法补充处理一遍，不足的处罚补充完整，该坐牢的继续坐牢，还要有家庭保人的所有资产为押金，出个小问题就百分之十的比例处罚，直到最后低于最低工资。资产的百分之十是不是有点慢，换成百分之五十。
游戏新历转化历史王朝的历史阶段性，三皇五帝一句话，夏商周，秦汉唐，主要是外族入侵部分的定义，外族被打败成为纳入领土的臣服者，就开始变质，不再与之前的侵略者相同，反之继续萌芽新生与之前的侵略者相同，就继续打之，直到打灭或打服，保持大家统一互利共利组织化持久。同理能人私有化官僚资本主义官商，打灭和打服人民百姓大众的法律衣服下白色之黑的存在（深圳生存一百天的胜利，是谁的胜利呢，失败又是谁的失败呢，这样不同圈层级利益利害的相对胜败。活着不好吗，怎么活呢？从个体胜利的追求，走向整体平均化个体利益的胜利，所以平均这个概念才是胜利的追求，反之必然要反对平均，而且是将平均说成绝对化，建立为靶子打）。（这里就存在取舍矛盾问题了，生命只有一次，但是必须要下注，不下注也是下了一种注）
私有化的客观存在效率效益，本能，欲望，纵欲，贪婪的推动力，集中吸取的趋势惯性，至趋势结束，一般是权力和资源重新分配的几代人之间，一百多年，后面是私有化利益方向不变的正反挣扎惯性延续。私有化的客观存在，可不可以成为一种阶段阶梯的垫脚石可能，哪怕是被动的，他们也不想不愿意选择的那种（但是这种具有非通用性，却可以理解为奋斗解题努力的属性。在没有历史通用性的解题之前，有比没有好，所以是可以的吧，有什么办法呢，让大部分人人吃草，还是让一些少数人去啃一般平常人饭菜的选择，原来选择并不难，看与谁比。你看啊，现在吃的好，你看啊，现在这这那那的问题，看有其结构功能之用，但是只看，不承接其后的看法，想法，做法和做积累量至量变质，有屁用，就是忽悠人的）。

解决事与解决人的相对比例选择。

道路道理，乐象，编程组合穷尽地图，生命在本立自由度，相对名实量化关系科研科技，器能，文化传统习俗习惯简化（习俗习惯，属于结构组织需求问题简化。同理是私有化的利益利害选择和规则）。
十二朝
三皇五帝，夏商周，秦汉唐，五代十国南北朝，宋明民新（外族统治，一般得至外族心身物意识组织消亡内化掉，才能算善后结束=元清）。
三皇五帝，夏商周，秦汉隋唐，宋明民新。8+11=19个大概念基本定位，四个历史阶段。历史阶段里的统治组织。经济基础生产力差别，所产生的历史阶段王朝山河区分。内部组织权力斗争与外族内外斗争的再次区别。
1传统断续传承的区别，2经济基础发展的区别，3组织内部竞赛的区别，4组织内外斗争的区别。敌人不得不进入内部竞赛，还是不是敌人了呢？

随机移动文件的随机选择组合单元对象，地星村之下的多个文件夹名字搜索集中，对这些集合的文件夹名字单元，进行随机选择的先复制再删除移动。for处理。批处理获取文件夹
文件夹地图，如果都是变量，是不是都在内存里活动，不需要经常外部读取文本。
tree树叉命令，怎么把文件夹名给排序出来。几个制表字符替换为空，空格怎么办。
历史记录的排序阵列名字，代入通用的变量。
===========================变量
|||||||||||||||||||||||||||||||||||||||||||||||蜈蚣脚或车轮子，滚木的具体定义名字
单机利益风洞试验场，将模拟的信息个体，实验各种方向和极限的现象，数值。
信息小人的模拟性格选择，与满天星星为孔的信息之孔=缸中之脑的信息输入输出。
人民信息时代，与私有化愚民时代的一个历史台阶，很可能要出现，一个新历史阶段新生的信息技术文明种族民族国家。人，火光，影，镜，境的信息组织组合集合一体化。信息是光线，光明的一部分，但是信息也有颜色，可以是白色，也可以是白色的黑色，可以是黑色。白色信息可以照亮路步子，可以眼睛看见手好做事。白色的黑色，可以让人走向各种心身绝境，还以为是光明中（伪白）。黑色是历史存在的明显明面明确的害处。是否有伪黑呢
怎么保证批处理的文件移动，不是到处留下复制的影子文件，不会产生无数个分身，而是唯一一个呢？
tree处理一行一个文件夹名字，其for假设有随机选择，产生的移动，你并不知道文件跑到哪里了。所以先建立一个顺序移动，方便观察。

@echo off
cd.>1.txt
cd.>2.txt
tree >1.txt
setlocal enabledelayedexpansion
(
for /f "delims=" %%i in ('more +3 1.txt') do (
set "str=%%i"
set "str=!str:├=!"
set "str=!str:│=!"
set "str=!str:─=!"
set "str=!str:└=!"
set "str=!str: =!"
echo,!str!
)
)>2.txt
pause
复制代码

以2.txt文本里的文件夹名字，作为循环跳转信息小人的选择。for循环

@echo off
set "a=D:\dos\bat\xsj\地星村\土洲\中国\江南郡\南京城\信息小人一号.bat"
set "b=D:\dos\bat\xsj\地星村\土洲\中国\江南郡\上海县\"
xcopy %a% %b%
del %0
pause
复制代码

怎么将文件夹=路径路线单元，都弄成变量的组合，这些单元的规律随机组合，形成跑路的路线。（还要加上一个时间限制，一天只能走路十几里至二十里，极限翻倍40里，这样县与县移动按照地图大理不差的平均值50西里=外里，就是100里，需要2天多游戏时间？）

开始
变量123=文本内容
变量456=鼠标键盘操作
变量交换
echo:变量页面
变量交换
echo:变量页面
变量清理（这一步需要吗？）
结束
复制代码

zzz19760225

课题1：VBS批量获取文本内容至变量，这些变量储存着，随时可以提取出来，参与单元组合和输出显示。
作业1.1：将两个文本的内容，批量赋值到两个变量里，并输出显示这两个批量变量的内容（之前那个好像算吧，不算，只是程序内自定义变量内容，没有外求获取文件文本内容去赋值变量）；
作业1.2：批量被赋值的两个变量，再次被传递给新的两个分散单独的变量，并输出显示这个两个新变量的内容。

---123-二-456-+十789
---123-贰-456-+拾789
---123+贰-456+拾-789
隐藏的文本储存数值可无限，超出显示极限。（中文与数字的象差。可以假设忽略，大礼不差的基本不乱，适度的不完整，是对习惯完整的一种相对阴阳存在补充。所谓不确定不完美概念=极限之外有无限=人外有人天外有天）

将外文集中起来，筛选100个简体字符。大小写打算，书法体也可以参与，都是图形符号的集合。bpqd容易转动方向混淆的，只取一个，提高识别度。一个字符出来，印象就是一个，独一无二的简单快速。外文之外的图形符号也可以拉进来，如文件的控制页面上的图形，抽象一下的。简化体积和需要识别的度量，简化容易接近的选择度量。

改制自组编码字符队伍，单元是哪些单元，摘洗了选择了，然后按照自身需求的程序下锅。原有和自身的内容，都是在单元组合穷尽的地图里，是地图上的各自路线。（这个地图算不算眼镜，不同的远视和近视，放大，显微的时空进制度量眼镜）
全数字，需要花费力气记忆，还是需要一个对应名字便于记忆。

货币资本圆环经济，一个管道头尾相接，但是管身是动态的，有时膨胀，有时紧缩，而且不是同时同步全部膨胀紧缩，而是相对前后波动化学化合反应一样。在这种动态流量象里，人民资本的内容，要吃得下，消化得了，循环每个历史阶段的钱币睡和醒，相对的另一面是物质的反之睡和醒。这些睡和醒的数量比例参数，是那个年代历史阶段的人数。人数，物数，钱数的三数基本逻辑元组合穷尽地图的时空圈层级经济，现在在地图的哪个地方，同样历史各个阶段王朝，也可以假设地图为尺子丈量，在地图上哪个地方，相对的发展推理应该如何。这样的自动量化游戏，代入穿越游戏，顺着历史地图跑的发大财，然后自由历史人物玩家的各自个人发挥选择。这个地图尺子，怎么做？

一百个游戏人物，一直持续运行的量，与周期运行一下获得数值就可以。这样多个游戏人物在不同的文件夹里，周期间隔时间执行一下的批量生产信息程序。批量执行不同文件夹里的同名程序，其处理的信息是周期时间段运算的结果，相对继续运算。一个游戏人物的石坚白数值集合，有多少。一百个有多少，怎么测试一下。或者定时一百个串起来的先后执行。（实际也应该是先后，只是表面概念是同时执行，所以排先后，只是间隔时间上比计算机的间隔拉大了。计算机不会管卡不卡死，人会考虑，所以用人为先后顺序，执行完一个才开始执行下一个的串执行，比较好些。还得看实际效果）
一百个虚拟的穷人富人家庭出生，再随机走向发展为富人穷人，玩家在其中或外环境天神视角，用各自二次随机的内容去影响变化其内容，实现穷富=人为可以影响制造的穷富度。个体穷富度穷人富人，还有组织集体整体的穷富度=唯物自由度（当唯物无法自由，只能唯心求假想假象的解脱。这里的问题是需要人在相对中，主动被动趋向坚强，能不能懒懒的躺着睡觉，不坚强也可以呢？如吹着口哨那样，也是可以的，但是只是有家德能者担负起环境整体，其余的多数一般平常人可以吹口哨，懒懒的躺着赖着不起来。实际总量不变，当那些人不在了，得有新的人继续去坚强，轮到谁得谁，这种没有办法的事。还是家长，孩子王，孩子的三类。家长也可以过六一儿童节，适度放松一下，不是绝对的家长概念，是需要需求问题事产生的家长，不是绝对化的，是相对而生的。这样就有政治相对概念，相对就是势的组成单元，相对组成一切）。

批处理和VB，VBS，c语言等的单独简化循环取数随机数单元，要用的时候，有一个独立的软件形式或代码模块，清楚怎么来的基本功能。概率二选一，重复01或一二，随时选择，得出的当时选择结果为随机数。扩大延长为更多数或字符名字选择。那么，怎么实现呢，最好是一句话就能记得住的量？
while循环，n=0,n=n+1,if(n=2)set n=0，然后怎么变量区域外取值呢？

@echo off
set n=0
set n=n+1
if %n%==12 set n=0
ping -n 2 127.0.0.1 >nul
%0
复制代码

提取n的值，任何时候都可以。输入一个按键或信号，这个是埋在循环里的，见到信号就往循环围墙外扔一个变量结果。需要一个程序或软件接口=输入输出

@echo off
set n=0
set m=0
:0
set n=n+1
if m==0 goto:1
if %n%==12 set n=0
ping -n 2 127.0.0.1 >nul
goto:0
:1
echo:%n%
pause
复制代码

没有反应。或者用for跳出

m加变量的百分号%%=%m%

set /a n=0
set /a m=0
:0
set /a n=n+1
if %m%==0 goto:1
if %n%==12 set n=0
ping -n 2 127.0.0.1 >nul
goto:0
:1
echo:%n%
pause
复制代码

用for做简单选择，文本里的行是0101010100101，然后读取行，跳出来，选哪个是哪个。总之是执行的时候才需要，触发条件就用，其余就空着不执行。总之就是两个猜一个，再多也是这个差不多一类的。这样只需要执行一遍出结果。

假如车轮是圆圈线，先上的单元点是水滴，就是大平板车是船，水聚散为车轮，水是那个单元组合穷尽的地图。
历史适度的环境名义利益人情诱饵与明算账主体（宗教送小礼物入门与献礼，这点商业的免费与收获，那么公有化有没有层叠的送礼和收获，循环约定送礼和收获汇流）。

打开文件的容器与内容，
start容器1=开容器1=开门=可以进出=打开柜子门，才好找东西=打开房门，才好进这个屋子里找东西
close容器1=关容器1=关门=不可以进出咯=关柜子门=关房门
单元重复读取
大多数情况，人的眼睛看着，手跟随着看的内容做事，少数是眼睛看不到或闭着，手做事。也就是一般平常是眼看手做(不是将差异对立分散分解，强势按闹抢特权。眼睛太不是人了，象农民一样，有土地还要养老金，也不看看付过钱没有，工人太不是人了，不努力赚钱，就想着攀比要高收入高养老金，那么多人富的比比皆是，为什么就是你穷呢。这种价值意识的说法者，源头是哪些重复循环规律的人，是眼睛还是手？)，这样如果程序化，是一个眼信息输入，一个对眼信息处理后再输到手的操作程序。
听风是雨，人概念象，对外象的交换翻译转化，将风这个环境存在，通过眼睛或耳朵等吾五感官，翻译为雨这个内部流通信息。翻译信息，交换信息。
批处理和VBS，将一个文本的内容，对照交换表，进行交换翻译。
if 变量读取的文本单元==集合里的单元，则替换为集合里的单元。
依次读取，C语言依次读取文本和批处理等依次读取文本。

每个人可能成为恶人或善人，不等于每个人是恶人或善人的名实关系。私有化的煽情，是用个体作为例子，去伪证整体，各种手法是一个路数方法方式，但是挺有效，信息企业的喇叭硬件在手里很重要，我的声音就是大。这个部分在游戏中，通过所有权来建立控制比例，私有化硬件喇叭为0%企业单元比例，至100%。对应的是公有化喇叭（这里的问题就出来了，我打工的，不赚老板便宜，还给老板卖命不成。那么如果有公有化所有制和总量整体所有权里的劳动股份所有权比例呢？我算不算十五亿分之一的主人了，法律形式名义上的，对应有量化的物质利益等着呢，快干活吧。也会有反过来，所有权都有了，别人多干点，我少干点，一样机械规则会产生所有权利益，自己少干不是相对多赚了）

游戏里信息人物发帖，然后玩家作为帖子管理员，进行不同情况趋势的导向操作。发帖人群体类别的控制，建立帖子的控制，把帖子排前排的排序控制，帖子里的回帖控制，点赞数控制，点踩数控制。
批处理的帖子点赞和点踩模拟，摆在最后一行，前面加上发帖地址的各国地方。这些需要处理的都是随机选择的集合，管理员的立场和个人利益趋向，影响帖子生产和帖子的观察者。管理员是老板所有权（也可以正反自身所在利益立场），管理员是老板的工人（工人可以自由度选择，成为工人劳动者利益趋势，也可以逆反），管理员是公有的集体成员（好像也可以正反，没有固定的形式和实在一体的，一切是变化的，但是环境影响趋势趋向被动一致的），三类人。

批处理建立一个帖子，管理模式和发帖，观察三模式。另外有个所有权的立法改变，买卖改变（买一个信息企业平台，卖一个信息企业平台。管理员工人被买来干活，或被赶走）。

帖子页面格式，VB6.0的froms控件里的多页，论坛主题多页里的多页回复贴。page1,2,tab1,2,
在游戏中，上下两分。两部分都可以再次最小化和最大化，半分三种选择。其中一个是论坛主题部分，另一个是输出主题主贴内容和回帖。这可以阅读小说，加上语音库，可以做其他事情听小说。VB6.0有没有声音功能，应该有吧？

选择旧的工具，跟着技术时代后面低头走，可以捡到东西，不用还的。（在游戏里打装备没有私有时限这个功能之前，是可以的，还有装备消失的时效）
外图lcon（外部文件夹里的文件图标），内图picture（软件程序内部图片）。

文件夹为地名的文件夹世界游戏模式

VB6.0里，通过time重复读数，然后读取到tag里的临时数，作为随机数。
if
elseif
else
endif
具有对称结构，便于记忆的复杂语句功能命令。
pri vate私有单独独立的
sub代替指代
通用=声明
from=31科目:
1,acti vate 激活开始启动选择
2,click点击，单击
3,dbclick点击，双击
4,de acti vate取消激活开始启动选择
5,dragdrop拖放信号
6,dragover拖放=drag+start+over+enter（类似鼠标按下，不放，松开的信号）
7,gotfocus
8,initialize
9,keydown
10,keypress按键press=按
11,keyup按键key+press+down+up+value=值
from属性=51科目

在南京文件夹里，点击飞机那个bat，输入目的地和航程对应的飞机票，然后移动到北京文件夹里。如果是南京文件夹里有一个北京文件夹，直接“CD 北京”是不行的。最好是一个文件夹浏览器可以执行的语句。
相对高技术物质劳动，平常物质技术劳动，物货钱。（物货钱，分别对应万物物质世界，物加工制造为货，这样与货币联系为下一步的量化钱币流量，对钱币流量，进行结构组织的水固流汽三态编程假设，钱币作为水，进行时空三态编程。钱是什么形态？）

家家一个对外的无人售货机，靠着大门（或者就是一个大门和货柜一体），可以自制商品出售，加上网络消费者远程快递自动对接。先付款，不可以退货？

批处理帖子

@echo off
:0
:帖子1921
echo:帖子1921：我们为什么要问？
echo:答者1911：因为.......所以......。
echo:发帖来源=%变量123%，点赞=%变量456%，点踩=%变量789%。
goto:0
pause
复制代码

zzz19760225

vbs的变量
vbs的变量之间联系线
组合穷尽地图
地图上的路线选择
输入文本的内容载入变量
文本故事剧本剧情初期运行载入内存里运行



变量=字符串（指代编码赋值）‘指代编码交换为数量和内容，没有赋值无法运行
变量=字符变量+字符变量
变量字符串组合聚散

dim a,b,c
b=b456
c=c789
a=b+c
msgbox a
复制代码

结果输出0


不需要数值的字符串变量，组成结构关系后，然后二次赋值为数值，数量流量运行。一次抽象变量结构运行，二次数值流量运行。
b=b
c=c
b456=b456
c789=c789
变量等于自身就可以简单抽象化
但是不对啊，要将文字装进变量的，这样字符串都不显示了。字符串要加引号“”赋值。
b456="b456"
c789="c789"

dim a,b,c
b456="b456"
c789="c789"
a=b+c
msgbox a
msgbox b456
msgbox c789
复制代码

三次输出

如果什么都不赋值呢？
b=
c=
a=b+c

dim a,b,c
b456=
c789=
a=b+c
msgbox a
msgbox b456
msgbox c789
复制代码

报出错，无法运行。

将一个文本内容，代入变量容器单元？

人生生命实在，在一个假设一部分的模拟现实游戏中，进行各种不需要实际实物的游戏熟悉选择。选择里无善无恶和有善有恶，最终人生只有一次考核自由自选，只是多增加一些机动灵活的玩意玩具玩笑，放松面对而已。人生任何时候，你愿意面对生之存在和未知的活吗？我已有所准备，练习游戏百遍，我期待周期实践已知和未知，验证游戏所学。（或者一年一个学习实践的循环周期）
利用通用规律，将未来一个周期（看棋局三步棋的一步），琢磨其中的内容一部分，考古侦探一样，在实践中肯定这部分。这部分成为可流通内容，相对固定下来，再继续寻找可探测未来周期的内容。所谓历史周期律，只是破坏循环至一种叠加重压的债务病局，然后绝对化。而实际人类是可知流组合（为主或比例度），是可知可行可见的（从小到大，从单到多，从少到多，从具体一到抽象宏观广义一），可以看到看法清楚明白，这些是他们将组织失败责任摆脱的一种方式，神化唯心化。建立物质，万物，人为主方向，所谓钱，币，都是一种形式绝对化的假象当作眼镜，一切原本简单（也得透过已有惯性形式，把简化的组织结构找出来，以及简化也有极简的形式，必要形式是什么）。

百度“vbs读取文本输出”

Dim fso, f, text
Set fso = CreateObject("Scripting.FileSystemObject")
Set f = fso.OpenTextFile("C:\path\to\your\file.txt", 1) ' 1 表示只读模式
 
text = f.ReadAll
WScript.Echo text
 
f.Close
Set f = Nothing
Set fso = Nothing
复制代码

修改文本地址“D:\dos\vbs\1.txt”
可以输出

Dim fso, f, text
Set fso = CreateObject("Scripting.FileSystemObject")
Set f = fso.OpenTextFile("1.txt", 1) ' 1 表示只读模式
text123 = f.ReadAll
f.Close
Set f = Nothing
Set fso = Nothing

WScript.Echo text123
复制代码

直接文本，变量后置，也是可以的。目的是文本内容装进变量，而文本的位置是一个空壳类存在（相对地址），只要放在同一文件夹容器里就可以，不需要具体的地址路径指示。

如将一个文件夹里的文件，批量搜素，对应变量批量载入变量呢。这些批量工作做完，是搭配变量单元的组合关系。字符替换，交换翻译。
人生的出生和或者的现状，比较衡量为穿越地图的一个圈层级一个阵列。然后通过穿越的地图，进行对比，产生已有相同想法和历史，以及各种类似类近的联系线，作为参考选择，丰富想法库。
孩子模仿家长，孩子模仿他人。书本时代，孩子通过书本丰富。电视时代，孩子通过电视丰富。网络信息时代，通过信息编程游戏地图丰富。这种游戏可以简化，家庭一般普通人，按照事进行组合穷尽，做成游戏，不需要类似私有化的法律，经济等，弄得复杂人不懂，然后别人听话的模式。从基本需求，是可以进行基本编程满足的，类似棋牌的定量，适度丰富就可以。十五亿人的基本够用信息丰富和基本实在自信，是可以站起来的，在舆论制造的舞台上沉不沉默都没有关系。

游戏概念这个集合，包括各种内容组装成游戏软件各种器具体单元（WIN和LINUX各种变量，都可以实现）。

'{
Dim fso, f, text
   '{
Set fso = CreateObject("Scripting.FileSystemObject")
Set f = fso.OpenTextFile("1.txt", 1) ' 1 表示只读模式
     '{
text123 = f.ReadAll
       '}
f.Close
    '}
Set f = Nothing
Set fso = Nothing
'}
WScript.Echo text123
复制代码

在注释里增加相对关系符号，进行切割组合。

假设已有可运行的程序是机器，拆散了装不上去，就再回到初始的机器样子。

微观，中观，宏观的三层面变量单元组合地图，数组对应多个地图。

王族供养，人民家园的家人基本效率供养，善恶和信用，罪恶分别出来的剔除。养十五亿人的一部分和全部比例度，只养一天，年，生的不同可选。有物质养与没有物质养。有物质机动比例数量的养，收入大于支出的有余养。亏损不养。比例养。老幼孕残里的某一个需要，这些里还可以发展轻劳动，村社看顾一下，有事喊一声，通知一下。失业和工作会，工作局，学习工作=投入如何简化已有知识信息的学习方法方式，联系实习，考核等丰富。集中人，集中人使用人的劳动，人的主观主动劳动量，这些流量就是发展的能量。怎么换成模拟钱币，基本原理，钱币就是人生和活的劳动量。劳动能量之外的物质联系包裹，长远劳动的信息技术知识叠加。短近劳动，物质劳动，长远劳动实践经验教训丰富后浓缩传承的技术知识劳动。应该是很多需要劳动的地方，但是客观现实是缺少这种丰富需求。从压住历史经济阵脚的看法，适度的工作量也是对的。但是工作劳动者需求量决定再私有化手里，这是问题的根源，是私有化经济理论的历史效应。怎么将历史公有化工作劳动库的需求，建立成有序的库存规划计划历史阶段和年代的劳动清单。有一种情况，是明明人人都同意简单需要的事，但是就是无法去做和做成，会有更扯皮的人去阻止事完成，这种状态很普遍。在没有好的办法解决前，可以当作是基本出发层面，要习以为常准备专门的一套招式套路，相对简化减轻阻力。正侧两面，一面是利益化包括这些事，这些事是可以换成钱的东西，为了换钱，促进事完成的侧面。另一面是家概念完成家事的正面，在做事的惯性中，安排进去，顺着惯性一并做了。

工业园区的污水化学组合地图，针对申请的排污管道，进行分解化合反应准备，通用管道容器与对应变化的化合内容。楼房顶上的化工气罩，将化学物质内容分类集中起来化合处理。水和气

以化学知识为操作内容，经济园区治理经营的游戏。提出解决办法，做成产品，立项目收钱，一次付款，成本首付加后期利息，分期付款。

批量建立变量和批量对应文本赋值，规律变量名与文本名。

百度“vbs批量建立变量”

Dim i
For i = 1 To 10
    Execute("Dim var" & i)
    Execute("var" & i & " = i")
Next
复制代码

批量建立变量和赋值后，输出变量。

Dim i
For i = 1 To 10
    Execute("Dim a" & i)
    Execute("a" & i & " = i")
Next
msgbox a1
msgbox a10
复制代码

可以的

Execute=执行

读取文本建立的学生信息表，输出文本保存。学生表广义通用化，为生活表。
百度“vbs制作学生信息”

' 创建一个学生类
Class Student
    Private pName
    Private pAge
    Private pGrade
 
    ' 构造函数
    Public Sub Class_Initialize
        pName = ""
        pAge = ""
        pGrade = ""
    End Sub
 
    ' 设置学生信息
    Public Sub SetInfo(name, age, grade)
        pName = name
        pAge = age
        pGrade = grade
    End Sub
 
    ' 获取学生信息字符串
    Public Function GetInfoString()
        GetInfoString = "Name: " & pName & ", Age: " & pAge & ", Grade: " & pGrade
    End Function
End Class
 
' 创建学生对象
Dim student
Set student = New Student
 
' 获取用户输入
Dim name, age, grade
name = InputBox("请输入学生姓名:")
age = InputBox("请输入学生年龄:")
grade = InputBox("请输入学生年级:")
 
' 设置学生信息
student.SetInfo name, age, grade
 
' 将学生信息写入文本文件
Dim fso, textFile
Set fso = CreateObject("Scripting.FileSystemObject")
Set textFile = fso.CreateTextFile("C:\students.txt", True)
textFile.WriteLine student.GetInfoString()
textFile.Close
 
' 清理对象
Set textFile = Nothing
Set fso = Nothing
Set student = Nothing
 
WScript.Echo "学生信息已保存到 C:\students.txt"
复制代码

出错信息“名称重定义”？

排序数字，弄一个背景是格子的图片，伪装成表格底子。上面显示的数字间隔分减号-与加号+，加号代表还有储存起来的数量。
---123--+456--+789
表格里的123数列全部显示，456和789还有隐藏的储存数量。对齐和提示数量。在前面可以有个位数提示，储存的数量有几个位数。
---123-2+456-9+789
---123-2-456-9+789（9位数上面还有位数，就不显示了，至少要这9位用光再说）
---123-2-456-0+789（用0代表十10）
或者用汉字
---123-二-456-十+789
---123-贰-456-拾+789

一段一段依次添加尝试验证可行执行，第二段的student后面加1区别。

Dim student
Set student = New Student
student.SetInfo name, age, grade
textFile.WriteLine student.GetInfoString()
Set student = Nothing
复制代码

一共5个地方student修改为student1，可以顺利运行。

无器本能劳动，天才精英能人有品德者，后天学习劳动，制造用器，器能人民，器能的组织，生活资料需求，人民劳动库，人民资本总量流量，劳动实在与货币钱币的量化交换，物价价格交换率，历史道路阶段年代圈层级人物相对量，几者的关系。（为什么没有一共历史清清楚楚明明白白的表格清单，人人可以通过清单简单看透一切，更好的去选择）

人眼，历史眼睛，眼镜，放大镜，显微镜，望远镜，天文时空望远镜，历史望远和微观时空圈层级里的像素图形，印象，模糊，逐渐清楚，细节清晰可见。理论与实践的差异差别，绝对化的事理论和情，作为名义，代替客观存在的差异差别，这就是无赖流氓，历史风闻清谈官，官僚挂羊头卖狗肉指鹿为马的一个原因？应该补上，挂羊头卖狗肉和指鹿为马，与绝对化名义否定客观现实实践，两者是有本质区别的。不同时空的看看法，与空间象视觉变形的文艺绘画技术作品联系，与几何形象学关联。艺术与科学在技术上是一体的，归于同一个实在本体的各种形式衣服演化，这些演化变化万法归宗，所以互相有内在关系，分散看好似吓了一跳，我的神啦，这么巧合（括号：假设这种情况可能不是巧合，是广义宏观名实关系。那么这个名是指什么呢，人看看到看法和想想到想法，做做法做到的交换流通过程变了形？光干涉的观察问题，属于人下锅的内容和方式顺序不对？）。

zzz19760225

GIF为单元的剧情集合，一条点单元先后顺序组成的线，重复线路。以舆论战操作的话题为阵地单元点，这些点连接起来的信息阵线，其通用重复循环规律的组织度，贯通在其中，可以似曾相识的识别一些。

VB6.0的GIF可以勉强实现，那么C语言的GIF库和可实现gif的图形库呢？按照GDI的gifx看，就应该是可以实现的。怎么入手呢，什么方向呢，怎么先聚相关的内容？gifx的代码

事线段
扫地-----
整理房间----------
买菜-----------------
摘菜------
洗菜--------
线段的点，是有时空单元数量的。
线段为集合，那么并集，交集，内集，外集的情况，主要是并集和内集类处理线段形态。
数字递减，一个间隔减号，间隔一个代表点空间的数字（数词？）。
扫地12-11-10-9-8-7-6-5-4-3-2-1=0


数字线段的有与冇，中间指示色彩位移。要有星际争霸那种地图旁观眼角瞄的概念空间一体（但要避免小地图一直遮盖，总有部分被盖住感，在固定地图位置上有快捷键提示，可全屏幕显示），游戏界面的线段数值，要在画面中印视入眼，心中有数，可快速做出反应，减少眼睛注视专注的能量损耗量（顺带这个效应）。
扫地12-11-10-9-8-7-6-5-4-3-2-1=0
1.txt
1.txt.ansi
1.txt.html
1.txt.u8.u16
C语言中播放影视片段，代表代替GIF（技术不行就掀桌子，换一个）。

WIN10+VC6.0
通义千问2.5：“C语言生成1bit的bmp”

#include <stdio.h>
#include <stdlib.h>

#pragma pack(1) // 确保结构体成员之间没有填充字节

typedef struct {
    unsigned short bfType;      // 文件类型，必须是 'BM' (0x4D42)
    unsigned int   bfSize;      // 文件大小
    unsigned short bfReserved1; // 保留，必须为0
    unsigned short bfReserved2; // 保留，必须为0
    unsigned int   bfOffBits;   // 像素数组偏移量
} BITMAPFILEHEADER;

typedef struct {
    unsigned int biSize;        // 本结构的大小
    signed int   biWidth;       // 图像宽度
    signed int   biHeight;      // 图像高度
    unsigned short biPlanes;    // 颜色平面数，必须为1
    unsigned short biBitCount;  // 每个像素的位数
    unsigned int biCompression; // 压缩类型
    unsigned int biSizeImage;   // 图像大小（可以为0）
    signed int   biXPelsPerMeter;
    signed int   biYPelsPerMeter;
    unsigned int biClrUsed;     // 调色板中颜色表项数
    unsigned int biClrImportant;// 重要颜色数
} BITMAPINFOHEADER;

typedef struct {
    unsigned char rgbBlue;
    unsigned char rgbGreen;
    unsigned char rgbRed;
    unsigned char rgbReserved;
} RGBQUAD;

void create_1bit_bmp(const char *filename, int width, int height) {
    FILE *fp = fopen(filename, "wb");
    if (!fp) {
        perror("无法打开文件");
        return;
    }

    // 设置文件头
    BITMAPFILEHEADER bfh = {0};
    bfh.bfType = 0x4D42; // 'BM'
    bfh.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 2 + ((width + 7) / 8) * height;
    bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 2;

    // 设置信息头
    BITMAPINFOHEADER bih = {0};
    bih.biSize = sizeof(BITMAPINFOHEADER);
    bih.biWidth = width;
    bih.biHeight = height;
    bih.biPlanes = 1;
    bih.biBitCount = 1;
    bih.biCompression = BI_RGB;
    bih.biSizeImage = ((width + 7) / 8) * height;

    // 设置调色板
    RGBQUAD palette[2] = {
        {0, 0, 0, 0}, // 黑色
        {255, 255, 255, 0} // 白色
    };

    // 写入文件头
    fwrite(&bfh, sizeof(BITMAPFILEHEADER), 1, fp);

    // 写入信息头
    fwrite(&bih, sizeof(BITMAPINFOHEADER), 1, fp);

    // 写入调色板
    fwrite(palette, sizeof(RGBQUAD), 2, fp);

    // 创建像素数据
    for (int y = height - 1; y >= 0; y--) {
        unsigned char byte = 0;
        for (int x = 0; x < width; x++) {
            if (x % 8 == 0 && x != 0 || x == width - 1) {
                fwrite(&byte, 1, 1, fp);
                byte = 0;
            }
            // 这里设置每个像素的颜色，简单起见，我们全部设为白色
            byte |= (1 << (7 - (x % 8)));
        }
        // 如果这一行不是8的倍数，需要填充到最近的8的倍数
        if (width % 8 != 0) {
            int padding = 8 - (width % 8);
            for (int i = 0; i < padding / 8; i++) {
                unsigned char pad = 0;
                fwrite(&pad, 1, 1, fp);
            }
        }
    }

    fclose(fp);
}

int main() {
    const char *filename = "output.bmp";
    int width = 100;
    int height = 100;

    create_1bit_bmp(filename, width, height);

    printf("1位BMP图像已成功创建: %s\n", filename);

    return 0;
}
复制代码

编译发出出错的怪兽叫声，出错信息复制百度搜素。

error C2065: 'BI_RGB' : undeclared identifier 表示编译器在编译过程中遇到了一个未声明的标识符 BI_RGB。在这个上下文中，BI_RGB 很可能是一个常量或宏，它在编译器尝试编译它的代码段时没有被定义或者导入。

解决方法：

确认是否包含了定义 BI_RGB 的头文件。BI_RGB 通常与位图信息头结构有关，在Windows编程中，你可能需要包含 windows.h 或者其他定义了 BI_RGB 的头文件。

如果 BI_RGB 是你自己定义的，确保你已经正确地声明了它，例如：

#define BI_RGB 0

加了“#define BI_RGB 0”，顺利执行编译。
问题是产生的文件到底在哪里，找不到。


合法出错

建立一个名为output.bmp的BMP图片，然后执行这个程序，就打不开了。程序修改处理过，反而不成了。
虾仁的背景远近渐变，红白机的背景移动变化。用Q版汉服，做服装。
按照变量为单元，可以换变量内容，可以在变量之间取相对联系线，比固定的小说剧情更自由度。其一个历史阶段人物集合的单元组合穷尽，是很难的。要一个对照生活象的单元集合

删除output.bmp，执行exe是可以产生新的output.bmp，但是打不开。是1bit的bmp，不再适用WIN10的看图软件？

制作1bit的bmp(bitmp)，好像不是那么容易的。（不用第三方软件的间隔，直接C语言制造点位图片）

文字按钮用FIVE的变量储存，对应固定方框，鼠标点击，输出一个图片或文本到连环画画面界面区。

道气无有，太极阴阳相对。
实在，象名，量数，易法，器体。
私，常私，极私，相对公，无私公。
整个，
利害，善恶，无善无恶，有善有恶，极善极恶，向善向恶，向善限恶，向善除恶。善恶比例组合体的人皆可主动向善，但是客观大多是自我性格习惯和环境利益利害影响，会选择向善内容和比例度。
1五善五恶，2四善六恶，3四恶六善，4三善七恶，5三恶七善，6二恶八善，7二善八恶，8一恶九善，9一善九恶，10十善，11十恶，12无善无恶。
混沌混乱无有排序。
道路重复循环规律道理
愚公蚂蚁，从小增大，家国天下，少多，小大，近远。（大小头问题，外国的小在前组合文字模式。从小到大）
愚公蚂蚁，从小到大。

长远，保持独断，倾斜倾倒，慢栽慢栽的定量处理，定量效率随着积累增加，最后不够处理的，完成一个稳定步进战略效率，不内伤。

zzz19760225

信息处理和点阵界面，信息处理的一切皆文本，以文本处理为主要可用形式内容。这样有处理路径文件夹（文件夹也属于文件名，类似文件里有几个单独的字符字词，代表对应的文件夹和文件。文件夹里也可以加字符的），文件文本名字，文件内容三部分。
文件名处理的数字0~9十个和英文，外文，中文等字符集顺序代表数量，排序处理等于也是一个地图概念空间。在默认字符单元为容器之上，建立间隔字符，形成集合容器，就扩大了空间。
0.1.txt
a.2.txt
a.甲.3.txt
.123:456.abc:xyz.甲乙丙:太极易.txt:exe..789.txt.
开始点.结束点.相异独立信息之间就形成两个点.说明不是一起的。
无限信息自由度，可行可用形式内容，抽象通用度内容，组用，专用内容。主要是通用内容形成一个抽象内容，可以形成变量概念空间结构层面，与具体数量数字化信息层面组合。两者信息的硬件化，与汉字DOS的可能联系。
或可以在一个文件夹里，用文本文件完成全部内容，包括建立文本式虚拟文件夹，就是信息路线处理的效应。

一个点的平面行列量，222.304，汉字联系，组合.
222组304.686组892
两点之间的线，两点之间的方形（对角线）。对角线与方形，三角形勾股线关系（终于是产生了客观需求的三角函数）。
三边形和四边形的数字化，1.1:.2:.3:.(linux的处理文件前面有点.是否可以看作类似考虑？)
.1.1:.2:.3:.
1.1:123.2:456.3:?.
1:.2:.3:的序数怎么来的？定义，主被动建立联系就可以。
那么在一个640.480的图形界面中，一个鼠标点击的点，1.640组480.，一个方形文字按钮，2.0组0至200组200.好像不行，感觉好像不直观。
方形对角点，方1=H1:100I2:200，H3:300I4:400。区间为100~300，200~400，可以有两个对角线对角点数值组合，基本数值是4个。100<msg.H<300,200<msg.I<400
H1<MSG.H<H3,I2<MSG.I<I4
点1，点2，点3
线1，线2，线3（2点线，3点线）
面1，面2，面3（3线面，4线面）
体1，体2，体3（3面体，4面体，5面体，6面体）
境1，境2，境3（3体境，4体境）
面里的线组合，任意一个线组合，其任意一线与其余线的概念空间相对关系类集合理论。
a*a+b*b=c*c的平方，假如理解为a与a的组合穷尽,b与b的组合穷尽,c与c的组合穷尽，三线面的两线组合穷尽的组合，等于第三线的组合穷尽？
太集合（个体，整体概念单元），点太，线太，面太，体太，境太。
太1，太2，太3
点1太，线2太，面3太，体4太，境5太（境5体）。
C语言显示动图gif的库安装，自动选择gif图库和对应声音库，建立编程结构形成的随机剧情。人只是选择制作库集合里的单元文字，然后查看自动剧情演化，调整编程结构。WIN的C语言，得安装gif库。
简便的背景gif库，人物gif库，剧情剧本程序库(程序文字转图片的交换易)。
开始习惯叫号叫人中文名字的软件。

#include=朱重八；#include=朱老四；#include=沈万三；#include=沈万九；
#include=动图giflb(无声影视)；#include=影视mp4(集合动图声音文字)；
复制代码

用酒为中心的文章，与不用酒但是描述酒为中心的文章。阴阳文，明暗文，虚实点阵，以联系关系内容为点阵的组合选择描绘。

一个模拟论坛的发帖游戏，建立一群假设账号，发帖人看到一个随机选择的问题库新闻题目，对应可选的回答模块语句，或自身对应感受，发出去，随机选择群账号集合里的一个账号。然后怎么进行两个账号群的立场舆论规则之战，观察观看欣赏类似的网络真假论战的现象。这个用批处理就可以吧
随机，字符显示界面，最好是连续在一个界面里可以上下文一体查看，最后可以全部导出或后续叠加导出，类集合库的单元语句，对应联系关系的选择逻辑。
新闻话题，赞语句，损语句，水语句，针对赞损水语句的再次赞损水语句，关联转移注意力方向的语句。四个库，话题库，赞语句库，损语句库，水语句库。库集中显示的界面
文件夹里的文本，语句是单独一语句一个txt文本，还是一行一语句呢？一个语句一个txt文本，便于不同集合之间的单元调用调整。


软件类集合库，软件库的部件，零件，逻辑单元。

vb6.0播放gif动图（WebBrowser模式？），用部件库里的控件=工程----部件----添加 Microsoft Internet Controls，勾选增加一个圆团图形。
点用该图形，在工作界面上拉选一块空间出来。
点击该拉选出来的空间，出现文本编码输入界面。

Private Sub Form_Load()
WebBrowser1.Navigate "D:\111.gif"
End Sub
复制代码

去掉原有自动代码，复制或输入新代码。
将代码里动图gif路径部分，修改为自己电脑里的图片路径。




VC6.0静态图剧情图形小软件，显示静态图，显示小短语句，显示比例按钮，比例按钮按照剧情指向连接下一个舞台剧情页的静态图+小短语句+按钮。（放弃无法自我实现的想法内容）

梦我游戏，在自我的梦世界中，各种形式的个体世界梦人，梦鱼，梦蝶，梦山海经，梦巨人国小人国历险记梦童话大王。在假设的梦无善无恶混沌，有善有恶混沌，向善混沌的三混沌里，人概念脑子太极容器空间跷跷板，在相对趋向的利害善恶公私上用语句加码，不得个体个人惩罚罪恶罪犯，软色是劳动，罪犯是不得已，将受害者和未成年受害者丢一边说未成年罪犯是需要挽救的去投入，人性就是这些罪犯罪恶等等向恶的，把人脱到它们一个层面的模仿游戏化。向善的难度付出消耗被围猎，以及向善的非完美圣人的圈层级历史事进步渐进，在其中选择的语句。通过自制或已有集合的语句，对游戏中的人群集合，进行语句平衡砝码投入，实现相对影响的善恶趋向=向恶挑唆和向善劝善。劝游戏

gif动图集合的每个单元图片以0x2c开始？那么Sleep间隔图片，也进行有序间隔排序输出组织起来呢

vc6.0编译happy886rr的gifx代码，居然可以通过完成！
#include <Gdiplus.h>
#pragma comment(lib, "Gdi32.lib")
#pragma comment(lib, "Gdiplus.lib")
#pragma comment(lib, "Ole32.lib")
也就是VC6.0，是可以直接使用GDI的。
编译过程有一些问题，但是不影响需求使用。

环境程序部分；
本体程序部分；
实践程序部分。（顺序验证完成与各种差异差别区别问题显示出错，不成。硬件空间，软件空间=操作系统集合层面平台和平台上单元软件的各种差异问题）
需要绘图类com组件，这个组件是否可以通过vb6.0自制呢？

#include<123.h>:
{
1,......;
2,......;
3,......。
}
各个文章段的结构格式，名字或数量编码，冒号言语代表指向，括号或其他字符首尾代表开始结束。
名字.456：
开始
789
结束
名字.456：开始，789，结束。

编程程序的编码编号切换界面，或者类似作弊秘籍那类调出。这样玩游戏与看影视，与编程空间相对隔离。一个输入窗口的调出快捷组合键：show me the money。中文模式，shift+123:编程1+回车键。

数量编码和备注，组成一个综合工程名字。20241217.1+数字按键

窗口程序=舞台程序=剧院程序=电影院程序

软件的操作界面，有两个类集合的名字过滤误操作，总可操作基本命令按键数量是有极限的（基本极限之外的隐形命令，快捷组合无限变量数量编码键调用，shift+a+123），两次误操作出错的概率问题。

太极集合概念空间单元，delphi的页概念，一切为文本的空间装入纸页形式信息中，某页的概念空间，然后调用这个页形式，就如道可道的道这个字文字形式，说了就做的说内容，知行合一的知内容。

编程文本通用标准，一个文本就是一个概念空间，类似文件后缀的文本处理选择不同，产生不同的输出效果，不需要第二个或更多编程空间，在一个熟悉的空间里，随之产生无数相对演化的空间形式信息编译等。一个二进制文本，其集合后缀的txt,JPG,GIF,MP4的后缀变化，就如不同的光线角度，产生不同的影子效应形态。通透的信息和对应形式镜像影像形态

批处理自动随机语句舆论模式，科目类集合的多层文件夹，主要是两层，其余类集合下的数量排序文件夹。这些文件夹概念类集合容器，不是预定，而是批处理自动搜索，然后比较，进行怎么联系随机选择输出，形成自动舆论效应。这样人的工作，一是结构编程自动处理文件夹，二是处理文件夹里的内容就可以，两类工作完成这个舆论游戏。各种可能具有舆论灌输效应的新闻题目，都可以采摘为游戏内容，进行实验。
集合内单元调用，集合甲（甲1，甲2），或反过来，单元在前，集合在后。乙（甲），乙.(甲)
捣鼓gif的难度，与尝试建立类似动图gif的动图文件，会不会一样难。前者是建立在商业软件法则上，法则一变，劳动全部浪费，后者也是建立在微软软件层面上，而且没头绪啊（或者，可以试一试？）。

VB6.0的需要在制作gif上设置适配界面对应的大小，自由度需要定标准，至少可以用吧。剧情怎么制作呢，一天的生活转圈圈表面动图，先转起来，然后考虑量化参与的内容。

有情常情，少极情绝情，有情文化表面发挥挥发内容（出于心，源源不绝念想，化为情。可能有两种情，一类是记忆回忆类情，另一类是实践想法互动的名实类情？）。但是法为事，为里理=里王。

zzz19760225

（锁在一个地方转不出去了，始终想在变量里完成这个需求，认为认定变量作为概念空间单元的组合选择相对关系，是可以概念内完成的。问题是现实中自我已有内容并不能完成。这里的纯变量这个方向，放弃，还是继续无效折腾）

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    FILE *file = fopen("1.txt", "r"); 
 
	int m=1,n=0,s=0,n1=0,n2=0,n3=0;
	int a1=0,a2=0,a3=0,a4=0,a5=0,a6=0;
 	int a11=0,a12=0,a13=0,a14=0,a15=0,a16=0,a17=0;
    char ch;
    while ((ch = fgetc(file)) != EOF)
	{
 
        n=n+1; 
        if (ch == '\n'){ 
			            m=m+1;          
						n = 0;                
		}
        if (ch == '[') {
			            s=s+1;
			            n1=n;
		                //printf("\n文字按钮%d,行%d,[列%d,\n",s,m,n1); 
						a1=s;
						a2=m;
						a3=n;
						a4=n1;
		}
        if (ch == ']') { 
			            n2=n;
		                n3=n2-n1;
                        printf("\n文字按钮%d,行%d,[列%d,间%d,]列%d\n",s,m,n1,n3,n2);
						a5=n2;
						a6=n3;
                        printf("\n");
						a11=s,a12=m,a13=n1,a14=n3,a15=n2,a16=a6,a17=a5;
		} 
    }
    fclose(file);
	if(a11=2){   printf("a11=%d,a12=%d,a13=%d,a14=%d,a15=%d,a16=%d,a17=%d,\n",a11,a12,a13,a14,a15,a16,a17);  }
    system("pause"); 
return 0;
}
复制代码

显示结果

也不能说不对，按照结果论来说，阶段步子的结果，已经出来了。需要取出结果，并需要进一步对接后面的机关线路（逻辑线）。
1问题，如何取出结果，全部结果，选择结果（FIVE66的二次指针装载解决方法，与纯变量路线）。
2不同结果内容怎么处理（作为数值建立图形空间数据）。
3通用，组用，专用的处理结果联系对接（新的大难题，自动开关选择新的页面，批处理的游戏新页面，网页和百度模式的超级链接打开文本页面。也许这部分不会如想的那么难）。

C语言中system()，括号中可不可以弄一条DOS命令批处理文件的线(q995855“批处理做一机一码的问题”)，这样作为一个辅助的部队存在。
system(dir&dir /&help)
是可以实现的
通义千问2.5：“C语言win下system("dir&pause")”。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
//#include <graphics.h>
//#include <easyx.h>
int main(){

system("dir&pause");

return 0;
}
复制代码

汉字DOS信息通用标准化，单机文化技术知识百科（单机为节点联网的网络），单机和可联网的简单综合游戏。下载的免费，伪免费和一元临时收费并列。伪免费是为他们服务一个点的现时或储蓄点，都可以。免费需要学习一个随机知识点
文字游戏，图形游戏（单图形页面，多，立体面集中的多维，其工作量怎么降下去，单页与多维页面一个工作量？应该是不可能的，或者寻找一个硬件效能与无有极常默游戏需求之间，相对平衡的一个台阶选择，硬件去选择软件信息地图里的对应阵列点）。
变量为单元的任意变量数字之集合，建立的任意进制。
十进制的任意进制，进制位选择，进制为集合的形式。
(0,1,2,3,4,5,6,7,8,9)(组合形式规则)(10000=1.12.456.0.0.789+123.456.789)二次或三次规则组成的进制体
变量+组合选择方法+方式和内容
如果main内是1MB，那么放main外部?
也不行

字和数字组合的组合之间加减乘除运算，代数方程式式运算。代数aXa=2a，需要一种排列形式英文在前面，可以加减的规则。
a1+a1=a2,
a2xa2=a4,
a4-a1=a3。
前面字a是敲门砖，以适应客观存在的计算机规则官僚体系，后面可以计算的。

也许应该在动态生成变量的指针块，考虑图形点阵，在两者之上考虑原理类的结构组织，相对简化已有的行业技术障碍，走原理类玩具技术验证，能用于家庭一般信息处理功用就可以。简单容易上手，高于一般人脑处理信息量，客观上完成一生的运算信息量，大概有所知的巨量准备。
就以那个动态变量10亿为信息地图

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
//#include <graphics.h>
//#include <easyx.h>
 
int main() {
    
    char *a = (char *)malloc(1000000000 * sizeof(char));  // 动态分配10亿个char的空间
    //if (a == NULL) {fprintf(stderr, "Memory allocation failed\n");return 1;}  /*出错提示*/
    for (size_t i = 0; i < 1000000000; ++i) { /*初始化数组（可选）*/ a[i] = '0';} /* 或者任何其他初始化值*/

    printf("%c\n",a[123]);
    printf("%c\n",a[456]);

    free(a);    /*当不再需要这些数据时，释放内存*/
    return 0;
}
复制代码

可不可以通过生命游戏模式，获取点阵的组合选择，规律探索绘画信息有限时空组合穷尽地图。

单数，单多增减连续，断续数，集合数。

时效与空效（间效），空间效应的有效范围。同样的话，说法，在这里空间有效，在那里空间就无效，甚至有害向恶作恶。
同层面的圆规律自转因果，任意时空的人在相同的资源条件，推理验证出相同活类似的结果。异层面的螺旋圆，跨越多层面，或阶梯式层面停留积累数量变质突破进入新层面，或本身是一个宏观巨大的管道道路。

混元太极=道？最大的抽象集合，太极阴阳，相对集合。
那元，是什么？混元=混元气。
无极与太极的关系呢？无，统一归一=太，大中小圈层级概念空间。
一个需求产生，针对该需求进行的各种有意识和无意识收集和准备，其收集准备的内容为一个混元无极概念空间，这个空间逐渐的趋向一个太极一体印象概念空间，在印象概念空间里的正同反异非内容相对阴阳关系，到相对多行关系里的五行关系，关系里的量化为数量，产生数量代表的数字，数学，数运算数算需求的算术。
实在存在空间的代表生文字，数字，文字和数字数量空间的组合形式，去指代模仿模拟存在实在空间。
这里就产生一个从文字之名代表存在实在空间，其中量化数量需求，如何创造数字和数学的内容。
一个问号？，代表一个字符集单元的单元变量。
set ??=12
1.txt
开头？
过程？？
结尾？？？
通用的单元变量和集合变量（*代表一切，?.txt，??.?，123.?，*.*，*.txt，123.*）
单多通用符的使用概念空间，1*.2*.3*.txt，圈层级的效用通用集合概念空间容器。

科学汉化，将科学基本基础内容成语化，归类到成语集合里，形成通用组用专用年代和历史阶段的成语编程体，通过成语为公式集群学习。成语后面是变量抽象的载体形式，先数量数字化，再数字化对应各国不同的母语概念字词。

递进。环进，圆进，更进，循进，转进，加进，减进，乘进，除进，复进。复进

文本处理的特定字符[，其顺序数可得其后行列数值，那么其后的行列数值，如何鼠标点击区域数值，反求出顺序数？数值=等于(可以反求出)，特定方框<小于数值。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>   //图环境资源条件1
#include <easyx.h>      //图环境资源条件2
int main()              //头文件，首领，领导办公室，调度室
{
	int H0=1000,I0=500;
    initgraph(H0, I0);  //开始图形程序

    FILE *file = fopen("1.txt", "r"); //开始文件

    int m = 1;          //文件行计数，默认开始已经是第一行
	int n = 0;          //文件一行的列计数，换行则清零再计数

    int s = 0;          //指定字符的搜索计数，为序数

	int m1 = 0;
	int n1 = 0;
	int m2 = 0;
	int n2 = 0;

    char ch;

    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '[') { s=s+1;m1=m,m2=m1+20,n1=n,n2=n+20; }
        if (ch == '\n'){ m=m+1;          n = 0; }
	//if(s==2){   printf("%d,%d,%d,%d,%d,\n",s,m1,m2,n1,n2); }
	if(m1==5&&m2==25&&n1==23&&n2==43){   printf("%d,\n",s); }
    }

    fclose(file);      //结束文件
    system("pause");   //暂停查看，随意按钮继续
    closegraph();      //结束图形程序
    return 0;          //？
}
复制代码

特定的，不重复的方形图块单元集合，是具有逻辑准确度的资源条件，怎么组织成为一个逻辑结构。
假设有一片散布的被排序处理形成方块单元，如果鼠标点击在其中的一个方块单元空间里，则输出该单元被机器处理的关联排序序数信息内容。
如内容全部复制出来，然后进行对比是可以的。FIVE的变量。如果不用变量，减少变量的一个过滤，只在处理阶段完成比较选择呢？至少要获得为什么不可以的结果

鼠标点击集合，与机器处理文本获取字符，形成图形集合内的各单元小集合之间的逻辑关系。
图形集合数值等于=，与小于该图形方形数值内的逻辑关系。
如果鼠标if(5>msg && msg>25 && 23>msg && msg>43)，则 if(H1==5 && H2==25 && I1=23 && I2=43)，就输出对应序数 s=2 ？
首先得有机器处理文本字符，产生字符信号排序数值，然后对这个数值结果的元素集合，与鼠标点击数值进行比较，做出选择。文本处理得是全域变量，鼠标处理和处理结果进行比较，是次级局部变量和二次局部变量。
各种字符集前面排序序号统一机器执行，年代或历史阶段的多字符集文本信息处理，按照其变化和使用时间相对长的规律，作为历史字符集库的成员。发生相同的，可以修改默认优先字符集，但是不清除有相同字符的另一个字符集，求同存异，历史史记模式留存，使用上自我可选择自由度结构功能。
连环画exe文件，一个是按照上面图片或整个文件界面为对象简单点击鼠标左右进退，另一个是上面图片区无效，以下面文字区有效文字按钮，进行操作。这两种的矛盾需要一个结构功能设置区域（结构功能集合里的单元元素），或者直接在界面上有一个选择按钮，连环画模式，与文字按钮模式。
软件的基本层面是数字编码，然后用对应外文字母形成的蒙皮，这样广义中文化包括各国文字的蒙皮替换。

编程程序的编译规则集，gcc通用的win和linux，一个规则和其他更多差异，区别，相对独立的规则集合单元，在这些规则单元集合上进行选择。硬件相关的单元规则取舍，软件系统层面平台的规则单元取舍选择，具体软件结构功能的规则单元选择，已有功能与功能概念地图空间的未有选择。将规则集合化分类的类集合，类似字符集集合一样，可以通用标准化选择处理，相对简化。

得用gcc+easyx


如果，只是信息文件容器，点阵图形界面，两者之间建立联系操作，是不是就可以，不需要更多的各种win和linux软件内容。WIN和LINUX层面上的字符或信息处理和点阵模块，锁需要的实现环境资源条件。
信息存取的概念空间地图移动交换易，图形界面的整个界面为地图的圈层级概念空间移动交换易，两者两端是类似类同的概念处理。组合成概念地图空间，对地图进行选择处理。
怎么做呢？从单点到所有点的增减显示，其范围里必然包括屏幕和点阵字符空间。
程序文本的动态序数序号的标记标号，具体形式信息字符标号，无标号与有标号，冇标号。建立联系的指针指向指代，无指线，有指线，冇指针。

鼠标点击的行列线HI数量，0.0至640.480，需要比较多个方形四数值H1,H2,I1,I2。每次循环比较一圈，如批处理for语句的行梯次比较一遍，通常留下最后一个比较选择结果。
H1.1-N1，H2.1-N2，I1.1-M1，I2.1-M2。

zzz19760225

是可以提取的，只是，怎么才能更进一步呢，准确些呢？

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    FILE *file = fopen("1.txt", "r"); 

	int m=1,n=0,s=0,n1=0,n2=0,n3=0;
	int a1=0,a2=0,a3=0,a4=0,a5=0,a6=0;

    char ch;
    while ((ch = fgetc(file)) != EOF)
	{

        n=n+1; 
        if (ch == '\n'){ 
			            m=m+1;          
						n = 0;                
		}
        if (ch == ']') { 
			            n2=n;
		                n3=n2-n1;
                        printf("间%d,]列%d\n",n3,n2);
						a5=n3;
						a6=n2;
		}
        if (ch == '[') {
			            s=s+1;
			            n1=n;
		                printf("\n文字按钮%d,行%d,[列%d,",s,m,n1); 
						a1=s;
						a2=m;
						a3=n;
						a4=n1;
                       printf("\n");
		}

					//	a1=s;
					//	a2=m;
					//	a3=n;
					//	a4=n1;
					//	a5=n3;
					//	a6=n2;
        if(s==2){
        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",s,m,n,n1,a5,a6);
		}
    }
    fclose(file);
    system("pause"); 
return 0;
}

/*



        if (s == '1') { 
			            a1=s;
		                a2=m;
						a3=n;
						a4=n1;
						a5=n2;
						a6=n3;
                        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",a1,a2,a3,a4,a5,a6);
		}
        if (s == '2') { 
			            a1=s;
		                a2=m;
						a3=n;
						a4=n1;
						a5=n2;
						a6=n3;
                        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",a1,a2,a3,a4,a5,a6);
		}
        if (s == '3') { 
			            a1=s;
		                a2=m;
						a3=n;
						a4=n1;
						a5=n2;
						a6=n3;
                        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",a1,a2,a3,a4,a5,a6);
		}
        if (s == '4') { 
			            a1=s;
		                a2=m;
						a3=n;
						a4=n1;
						a5=n2;
						a6=n3;
                        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",a1,a2,a3,a4,a5,a6);
		}




*/
复制代码

文字按钮1,行5,[列9,
间10,]列19

文字按钮2,行5,[列23,
a1=2,a2=5,a3=23,a4=23,a5=10,a6=19,
a1=2,a2=5,a3=24,a4=23,a5=10,a6=19,
a1=2,a2=5,a3=25,a4=23,a5=10,a6=19,
a1=2,a2=5,a3=26,a4=23,a5=10,a6=19,
间4,]列27
a1=2,a2=5,a3=27,a4=23,a5=4,a6=27,
a1=2,a2=6,a3=0,a4=23,a5=4,a6=27,
a1=2,a2=7,a3=0,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=0,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=1,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=2,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=3,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=4,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=5,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=6,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=7,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=8,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=9,a4=23,a5=4,a6=27,
a1=2,a2=8,a3=10,a4=23,a5=4,a6=27,

文字按钮3,行8,[列11,
间11,]列22

文字按钮4,行11,[列13,
间12,]列25
请按任意键继续. . .
复制代码

直接输出a123456，就可以。

        if(s==2){
        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",a1,a2,a3,a4,a5,a6);
		}
复制代码

文字按钮1,行5,[列9,
间10,]列19

文字按钮2,行5,[列23,
a1=2,a2=5,a3=23,a4=23,a5=10,a6=19,
a1=2,a2=5,a3=23,a4=23,a5=10,a6=19,
a1=2,a2=5,a3=23,a4=23,a5=10,a6=19,
a1=2,a2=5,a3=23,a4=23,a5=10,a6=19,
间4,]列27
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,
a1=2,a2=5,a3=23,a4=23,a5=4,a6=27,

文字按钮3,行8,[列11,
间11,]列22

文字按钮4,行11,[列13,
间12,]列25
请按任意键继续. . .
复制代码

可以考虑建立图形模板人物图片，在模板上进行修改或直接用模板（换成自制图片或照片，摄像视频。文图音的二进制流文件，是需要的），简单的模板游戏。影视新闻舆论战的套路规律，一套套路招式，基本所有人大概可用。类似QQ游戏头像选择。套件，背景动静图层和人物动静图层，两个图层就可以。应该三个图层，一，背景图层，二，人物图层，和三相对人物图层。戏剧，戏曲的脸谱式通用游戏，文字机器唱曲唱腔。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
	int a=0;
	for(int m=0;m<5;m=m+1){
		a=a+1;
		int nm=a;
	printf("%d",nm);
	}
    system("pause>null"); 
return 0;
}
复制代码

12345
复制代码

顺序定义的变量是可以的。
问题还是怎么把前面的变量组合内容，挖出来，对应顺序变量。还得怎么可用起来
变量的局部变量区域，与整体全局变量的联系关联，微观概念空间里的小变量，操作整体宏观概念空间的大变量。变量这个容器概念空间单元的圈层级，流通流动流体一体。大中小变量之间建立联系，喂喂喂，我是小变量。收到，我是大变量。
变量的太极阴阳相对矛盾论主次统一，根据需求问题和事情，建立可以矛盾对立隔离的信息关系，也可以建立相互融合一体组织的信息关系。
要把这个输出结果“12345”与“文字按钮1,行5,[列9,间10,]列19”挖出来，两者属于同一类问题。在那个资源条件范围空间里去完成，出范围就失效了。
读取文本，处理文本内容，获得机器选择的结果。这些结果对应的序数，产生对应的自动变量群，文本处理的机器数据结果，输出到变量群里作为字典选用，对应鼠标点击开关。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    int s=0,m=1,n=0,n1=0,n2=0;
    char ch;
    FILE *file = fopen("1.txt", "r"); 
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '[') { 
		                 //printf("%d,%d,%d,",s,m,n); 
			             n1=n;
		}
        if (ch == ']') { 
			             //printf("%d\n",n);   
		                 s=s+1; 
		                 n2=n;
                              if( s == 2 ){
                                            printf("%d,%d,%d,%d,\n",s,m,n1,n2);
							  }
		}
        if (ch == '\n'){ 
			             m=m+1;               
			             n = 0; 
		}
    }
    fclose(file);
    system("pause>null"); 
return 0;
}
复制代码

结果：

2,5,23,27,
复制代码

怎么把结果输送出来

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    int s=0,m=1,n=0,n1=0,n2=0;
    int a1=0,a2=1,a3=0,a4=0,a5=0;
    char ch;
    FILE *file = fopen("1.txt", "r"); 
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '[') { 
		                 //printf("%d,%d,%d,",s,m,n); 
			             n1=n;
		}
        if (ch == ']') { 
			             //printf("%d\n",n);   
		                 s=s+1; 
		                 n2=n;
                              if( s == 2 ){
                                            //printf("%d,%d,%d,%d,\n",s,m,n1,n2);
											a1=s,a2=m,a3=n1,a4=n2;
							  }
		}
        if (ch == '\n'){ 
			             m=m+1;               
			             n = 0; 
		}
    }
    fclose(file);

    printf("%d,%d,%d,%d,\n",a1,a2,a3,a4);

    system("pause>null"); 
return 0;
}
复制代码

结果：

2,5,23,27,
复制代码

可以针对提取的。
下面是怎么自动化，相对减少人工手动内容。
应该先考虑鼠标点击连成一线，之后再考虑去手工手动的自动化。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    int s=0,m=1,n=0,n1=0,n2=0;
    int a1=0,a2=0,a3=1,a4=0,a5=0,a6=0;
    char ch;
    FILE *file = fopen("1.txt", "r"); 
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '[') { 
		                 //printf("%d,%d,%d,",s,m,n); 
			             n1=n;
		}
        if (ch == ']') { 
			             //printf("%d\n",n);   
		                 s=s+1; 
		                 n2=n;
                         a2=s;
						 a6=a5-a4;
                              if( s == 1 ){
                                            //printf("%d,%d,%d,%d,\n",s,m,n1,n2);
											a1=s,a3=m,a4=n1,a5=n2;
							  }
		}
        if (ch == '\n'){ 
			             m=m+1;               
			             n = 0; 
		}
    }
    fclose(file);

    printf("序%d-总%d,行%d,左[%d,间%d,右]%d,\n",a1,a2,a3,a4,a6,a5);

    system("pause>null"); 
return 0;
}
复制代码

结果：

序1-总4,行5,左[9,间10,右]19,
复制代码

将文字按钮括号内的字符内容，和序号组成一个编码代码编号线条，怎么去查字典或什么的得出一个结果？
如果不要[]字符对称概况，而是百度百科的文字标识一下？（还是需要一个功能信号信息内容）
环境疑问：为什么产生断线卡壳的空间活动现象（从外向本看：技术不够，脑力问题，经验积累）
本体疑问：这个问题集合里有什么（建立在机器单元重复循环读取文本字符的截取上，对代表字符的并行数量齿轮变量太极，这些运动概念空间的看法想法做法需求认识理解）
内容疑问：如何处理（还是得一个个怎么去拆解才行，问题并没有到最后阶段，而是先难而后获的阶段，是一个认识理解的攻坚，也是一直存在的内在问题需要解决，一个变量数量关系的方法方式工具的问题。解决办法就是习，练习，实践，磨平问题的棱角，可以拿捏才行。怎么会这么难的呢，明明应该是齿轮组合关系，但是却无法象所需要的去输出）
如果是自我的想法选择的去向，是错误呢？迷宫中的小老鼠与实践实验验证对错，在验证的基础上进行选择。自我定义对错，自我之外通用重复规律空间的去个人化去自我的验证内容为尺子，衡量一些基本单元，这些基本单元组合选择出人需要的主动时空物质内容。

zzz19760225

全显示，多个按钮绘制都可显示。手工版编程，而不是脑思维干活，吃力。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>

int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
    FILE *file = fopen("1.txt", "r"); 
    int m  = 1, n  = 0, s  = 0;
	int n1 = 0, n2 = 0, n3 = 0;
 	int a1,a2,a3,a4,    a5,a6,a7,a8;
	int a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34,a41,a42,a43,a44;
    a11=10;
    a12=50;
    a13=150;
    a14=70;
    a21=10;
    a22=200;
    a23=150;
    a24=220;
    a31=10;
    a32=300;
    a33=150;
    a34=320;
    a41=10;
    a42=400;
    a43=150;
    a44=420;

             setlinecolor(BLUE); 
			 rectangle(a11,a12,a13,a14); 
			 rectangle(a21,a22,a23,a24); 
			 rectangle(a31,a32,a33,a34); 
			 rectangle(a41,a42,a43,a44); 

    RECT bof1 = {a11,a12, a13, a14};    
    RECT bof2 = {a21,a22, a23, a24};   
	RECT bof3 = {a31,a32, a33, a34};    
    RECT bof4 = {a41,a42, a43, a44}; 
    char ch;

    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '[') {
		            /*左*/            a2=m*20;  /*上*/    /*右*///若值小,为左上  
                    a1=n*10+10;       a4=a2+20; /*下*/    a3=a1+20;    
                          setlinecolor(BLUE);          
                          rectangle(a1,a2,a3,a4);   
                          RECT bof5 = {a1,a2, a3, a4}; 

		}
 
        if (ch == ']') { 
		                              a6=m*20;          
                    a5=a1+10;         a8=a2+20;           a7=n*10+20;   
					      setlinecolor(RED);          
                          rectangle(a5,a6,a7,a8);  
						  RECT bof6 = {a5,a6,a7,a8}; 

		}
        if (ch == '\n'){ 
			              m=m+1;          
					      n = 0;  
				
		}
    }

	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                              //HOPE2021鼠标
    RECT bof5 = {a1,a2, a3, a4}; 
    RECT bof6 = {a5,a6,a7,a8}; 
	if (msg.uMsg == WM_LBUTTONDOWN){          //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                         // 鼠标点击图片方位数量
 
            if (PtInRect(&bof1, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "甲123"); 
			 }
            if (PtInRect(&bof2, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "乙456"); 
			 }
            if (PtInRect(&bof3, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丙789"); 
			 }
            if (PtInRect(&bof4, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丁111"); 
			 }
            if (PtInRect(&bof5, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "子000"); 
			 }
            if (PtInRect(&bof6, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丑abc"); 
			 }
	}}

    fclose(file);
    system("pause"); 
    closegraph();
return 0;
}
复制代码

如果按钮数量为p，则数组[p][8]{p,m,n,a1,a2,a3,a4;p-1,m,n,a1,a2,a3,a4;......},已知p则得a1,a2,a3,a4，对应命令功能为p=.......。
有一个计数，计数几个就有几个对应的开关建立，测试的时候就是输出那个称呼，文字按钮1，鼠标点击=“文字按钮1”，这个“文字按钮1”得是自动对应的。然后这个自动对应的编码代码，是通用的，对应一个编码表什么的，而数组就是列表嘛，只能用数组咯。要怎么把数组当作一个列表字典，按照空间相对排列的固化规律，查一得二。查单得多
如何将a12345678装进a[][]，是场统一中原的收编大战啊，不一定好打。
各个太元的圈层级组合选择，其太内元组合是有穷尽的，而选择提取是可以怎么编码叫号。（数组的表格列表规律，[第几行][第几列]，或[第一批太中的元][第二批太中的元]的组合地图）
环境问题（容器外内外相对问题），本体问题（容器问题），体内问题（内容问题）。是什么问题（本体容器），怎么解决问题（一般平常内部内容，超常异常非常需要外部环境联系结合），为什么产生问题（内外环境）。器与不器，知与不知
行m列n的组合概念空间，是内容容器环境三个概念空间的什么分类。产生的获取不到的问题现象，属于这些概念空间组合的哪些，原因是什么。
软件空间这个身体的健康，其环境资源内容，本体本身整体内容，身体内的圈层级量化集合单元组合和独立单元内容。软件，可行的能活着，与健康身体能力流通平衡的活着活好。
a12345678算不算是一群组合的概念空间，临时的不规律的数组，或不统一的数组。
二次变量层面，将数组表格列表格式相对固定，与具体数量的变量内容隔离开来。1数组，2一次变量层面，3二次变量层面，4具体数量数字编码代码（名）=5联系互动至实。两个变量概念的容器层面，互相联系交换，分别代表数组和具体形式。
一维二维三维四维数组，集中在二维和三维，一维和四维在底限和环境极限。
顺序和无序，无序储存取空间里的有序。打散了重组，随便散放，随时重组，不足替换的组构结构功能。
行m列n，如果按照不同的按钮，顺序出数量数字，四个按钮a1[m1][n1],a2[m2][n2],a3[m3][n3],a4[m4][n4]。而这个按钮a1234自动生成，来自n的[]按钮计数。自动生成数组？
数组实一个元素单元和组合集合，那么其输出就可以是单元和组合里的有序选择。通过组合编码维地图，选择需要的任意一个地图单元点，集合多点，线，面。将数组理解为一个点阵屏幕，组合和选择。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
int main()
{
	int szu[2][2]={{1,2},{3,4}};
    printf("%d,%d\n%d,%d\n",szu[0][0],szu[0][1],szu[1][0],szu[1][1]);

    system("pause"); 
return 0;
}
复制代码

数组的变量装填，并不好操作。
应该是两个部分，存，取。
要用变量，切断具体数字与数组的联系连接，重新建立一个变量具体交换开关层面。
源元，存取，输入输出容器门路和容器内容。
m,n,n1,n2,a12345678，szu[1000][12],通用的输出变量门路开关内容。
数组行列组合的规律编码

文字按钮1,行5,[列9,间10,]列19
复制代码

在显示按钮顺序的时候，自动建立变量，这批机器自动生成中介变量群，就是解题的援军。（要不要数组了呢？如果不需要数组，不需要另外自动生成变量群，直接本身变量就能完成命令指向的任务，那是最好不过了）
-
虽然没有把间隔的数值刷出来，总算是有了一点眉目。有迹可循了，胜利在望。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    FILE *file = fopen("1.txt", "r"); 

	int m=1,n=0,s=0,n1=0,n2=0,n3=0;
	int a1=0,a2=0,a3=0,a4=0,a5=0,a6=0;

    char ch;
    while ((ch = fgetc(file)) != EOF)
	{

        n=n+1; 
        if (ch == '\n'){ 
			            m=m+1;          
						n = 0;                
		}
        if (ch == '[') {
			            s=s+1;
			            n1=n;
		                printf("\n文字按钮%d,行%d,[列%d,\n",s,m,n1); 
						a1=s;
						a2=m;
						a3=n;
						a4=n1;
		}
        if (ch == ']') { 
			            n2=n;
		                n3=n2-n1;
                        printf("间%d,]列%d\n",n3,n2);
						a5=n2;
						a6=n3;
                        printf("\n");
		} 
        printf("a1=%d,a2=%d,a3=%d,a4=%d,a5=%d,a6=%d,\n",a1,a2,a3,a4,a5,a6);
    }
    fclose(file);
    system("pause"); 
return 0;
}
复制代码

应该说，是从表面组合的稀里糊涂，走向有具体机器定量为参考的量化有迹可循，开始看到方向。后面还有一大截，至少方向是有了，或者是圈层级的方向又准确或修正了一次，正向修正主义。

zzz19760225

手工失去了有效图形，但是勉强可以对应鼠标点击的，先试一下。后面再看变量的了

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
    FILE *file = fopen("1.txt", "r"); 
    int m  = 1, n  = 0, s  = 0;
	int n1 = 0, n2 = 0, n3 = 0;
 	int a1,a2,a3,a4,    a5,a6,a7,a8;
	int a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34,a41,a42,a43,a44;
    a11=100;
    a12=100;
    a13=120;
    a14=150;
    a21=200;
    a22=200;
    a23=220;
    a24=250;
    a31=300;
    a32=300;
    a33=320;
    a34=350;
    a41=400;
    a42=400;
    a43=420;
    a44=450;
             setlinecolor(BLUE); 
			 rectangle(a11,a12,a13,a14); 
			 rectangle(a21,a22,a23,a24); 
			 rectangle(a31,a32,a33,a34); 
			 rectangle(a41,a42,a43,a44); 
    RECT bof1 = {a11,a12, a13, a14};    
    RECT bof2 = {a21,a22, a23, a24};   
    RECT bof3 = {a31,a32, a33, a34};    
    RECT bof4 = {a41,a42, a43, a44}; 
    char ch;
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '\n'){ 
			              m=m+1;          
					      n = 0;                
		}
        if (ch == '[') {
		            /*左*/            a2=m*20;  /*上*/    /*右*///若值小,为左上  
                    a1=n*10+10;       a4=a2+20; /*下*/    a3=a1+20;    
                          setlinecolor(BLUE);          
                          rectangle(a1,a2,a3,a4);   
		}
        if (ch == ']') { 
		                              a6=m*20;          
                    a5=a1+10;         a8=a2+20;           a7=n*10+20;   
					      setlinecolor(RED);          
                          rectangle(a5,a6,a7,a8);     
		}
	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                              //HOPE2021鼠标

	if (msg.uMsg == WM_LBUTTONDOWN){          //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                         // 鼠标点击图片方位数量
 
            if (PtInRect(&bof1, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "甲123"); 
			 }
            if (PtInRect(&bof2, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "乙456"); 
			 }
            if (PtInRect(&bof3, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丙789"); 
			 }
            if (PtInRect(&bof4, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丁111"); 
			 }
	 }}

    }
    fclose(file);
    system("pause"); 
    closegraph();
return 0;
}
复制代码

天见可怜，终于看到图形的影子了。
变量文字按钮，依然是最后一个可以输出显示。还好是显示了，总比不显示要好。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
    FILE *file = fopen("1.txt", "r"); 
    int m  = 1, n  = 0, s  = 0;
	int n1 = 0, n2 = 0, n3 = 0;
 	int a1,a2,a3,a4,    a5,a6,a7,a8;
	int a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34,a41,a42,a43,a44;
    a11=100;
    a12=100;
    a13=120;
    a14=150;
    a21=200;
    a22=200;
    a23=220;
    a24=250;
    a31=300;
    a32=300;
    a33=320;
    a34=350;
    a41=400;
    a42=400;
    a43=420;
    a44=450;
             setlinecolor(BLUE); 
			 rectangle(a11,a12,a13,a14); 
			 rectangle(a21,a22,a23,a24); 
			 rectangle(a31,a32,a33,a34); 
			 rectangle(a41,a42,a43,a44); 
    RECT bof1 = {a11,a12, a13, a14};    
    RECT bof2 = {a21,a22, a23, a24};   
	RECT bof3 = {a31,a32, a33, a34};    
    RECT bof4 = {a41,a42, a43, a44}; 
    char ch;
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '\n'){ 
			              m=m+1;          
					      n = 0;                
		}
        if (ch == '[') {
		            /*左*/            a2=m*20;  /*上*/    /*右*///若值小,为左上  
                    a1=n*10+10;       a4=a2+20; /*下*/    a3=a1+20;    
                          setlinecolor(BLUE);          
                          rectangle(a1,a2,a3,a4);   
                          RECT bof5 = {a1,a2, a3, a4}; 
		}
        if (ch == ']') { 
		                              a6=m*20;          
                    a5=a1+10;         a8=a2+20;           a7=n*10+20;   
					      setlinecolor(RED);          
                          rectangle(a5,a6,a7,a8);  
						  RECT bof6 = {a5,a6,a7,a8}; 
		}
    }
	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                              //HOPE2021鼠标
    RECT bof5 = {a1,a2, a3, a4}; 
    RECT bof6 = {a5,a6,a7,a8}; 
	if (msg.uMsg == WM_LBUTTONDOWN){          //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                         // 鼠标点击图片方位数量
 
            if (PtInRect(&bof1, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "甲123"); 
			 }
            if (PtInRect(&bof2, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "乙456"); 
			 }
            if (PtInRect(&bof3, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丙789"); 
			 }
            if (PtInRect(&bof4, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丁111"); 
			 }
            if (PtInRect(&bof5, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "子000"); 
			 }
            if (PtInRect(&bof6, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丑abc"); 
			 }
	}}
    fclose(file);
    system("pause"); 
    closegraph();
return 0;
}
复制代码

变量里有一组可以实现了，如何实现更多包括的三组空间。
虽然按钮只剩一个，但是，问题应该接近要解决的最终阶段了。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
    FILE *file = fopen("1.txt", "r"); 
    int m  = 1, n  = 0, s  = 0;
	int n1 = 0, n2 = 0, n3 = 0;
 	int a1,a2,a3,a4,    a5,a6,a7,a8;
	int a11,a12,a13,a14,a21,a22,a23,a24,a31,a32,a33,a34,a41,a42,a43,a44;
    a11=10;
    a12=50;
    a13=150;
    a14=70;
    a21=10;
    a22=200;
    a23=150;
    a24=220;
    a31=10;
    a32=300;
    a33=150;
    a34=320;
    a41=10;
    a42=400;
    a43=150;
    a44=420;
             setlinecolor(BLUE); 
			 rectangle(a11,a12,a13,a14); 
			 rectangle(a21,a22,a23,a24); 
			 rectangle(a31,a32,a33,a34); 
			 rectangle(a41,a42,a43,a44); 
    RECT bof1 = {a11,a12, a13, a14};    
    RECT bof2 = {a21,a22, a23, a24};   
	RECT bof3 = {a31,a32, a33, a34};    
    RECT bof4 = {a41,a42, a43, a44}; 
    char ch;
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '\n'){ 
			              m=m+1;          
					      n = 0;                
		}
        if (ch == '[') {
		            /*左*/            a2=m*20;  /*上*/    /*右*///若值小,为左上  
                    a1=n*10+10;       a4=a2+20; /*下*/    a3=a1+20;    
                          setlinecolor(BLUE);          
                          rectangle(a1,a2,a3,a4);   
                          RECT bof5 = {a1,a2, a3, a4}; 
		}

        if (ch == ']') { 
		                              a6=m*20;          
                    a5=a1+10;         a8=a2+20;           a7=n*10+20;   
					      setlinecolor(RED);          
                          rectangle(a5,a6,a7,a8);  
						  RECT bof6 = {a5,a6,a7,a8}; 
	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                              //HOPE2021鼠标
    RECT bof5 = {a1,a2, a3, a4}; 
    RECT bof6 = {a5,a6,a7,a8}; 
	if (msg.uMsg == WM_LBUTTONDOWN){          //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                         // 鼠标点击图片方位数量
 
            if (PtInRect(&bof1, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "甲123"); 
			 }
            if (PtInRect(&bof2, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "乙456"); 
			 }
            if (PtInRect(&bof3, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丙789"); 
			 }
            if (PtInRect(&bof4, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丁111"); 
			 }
            if (PtInRect(&bof5, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "子000"); 
			 }
            if (PtInRect(&bof6, pt)&& WM_LBUTTONDOWN) { 
		     clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
             outtextxy(300, 200, "丑abc"); 
			 }
	}}
		}
    }
    fclose(file);
    system("pause"); 
    closegraph();
return 0;
}
复制代码

zzz19760225

1四边空间的边量固定与相对辩证效应，产生的混乱。
2四边量的输入获取不清楚，产生的混乱。
3变量运算的混乱（例如初中的数学考卷上，都写满了答案，但是都是错误的。主观认识与客观存在重复规律的差异差别）
在脑力某些不够的情况，通过什么方式方法工具，来填补，就如建筑的垫，砖缝的填，影子，记忆与记录，形象直观与抽象思维组合观。
四个变量概念单元的数量，是有穷尽的，在万千百数量之内，受屏幕物质制造和人眼可识别的界面相对字体大小极限限制，太小的存在字体，人眼是看不到的，太大的更少，不需要考虑数量太多的问题，一般平常就几个。
四个变量是一组一组使用的，是根据人的设置，产生的四组。
四个变量一组一组是可以截取的，类似批处理的for行读取，最后留下最后一行一组有效。(那么全过程的内容怎么获取？批处理那种，加一个if过滤。if的条件问题怎么来)
四个变量一组是由行m列n组成初始，并重复循环规律组合选择，而成四个变量的。
其环境，屏幕数量极限，屏幕字符和像素大小；（默认不考虑）
其本体，软件界面数量极限，软件界面里的字符大小；
其内部相对运动的数量，输入源初始行m列n，相对关系数量增减回m+1,n+1,n=0。mn行列没搞清楚，所以后面四边输入，更是糊涂上加糊涂。那么能搞清楚吗，为什么？

for和findstr等命令，作为一个软件结构单元，放在c语言环境中观察，适合个人化的改制版，有没有呢？有的话，就是可以模仿的，文字按钮的计算问题会不会好一些（也可能遥遥无期，没有结果，因为做不到）。通过C语言软件，将dos命令，解释语言的命令内容脱模复制出来。

以需求，信息为概念空间集合，其单元的组合。
以已有技术概念空间形成的机器，机器制造用的可用内容单元，其组合。

变量是否理解为0，无，空，集合，
中文的字符集和信息数据两条路线，其实它们本无差别，无善恶，无区别，只是信息流，水流，河边的影子，或者镜子。
点像素的点，很重要。
一，储存取和显存图形单元像素点，二，通用信息数量数据进制。没有储存取的组合选择，就不会有进制通用，属于概念空间理论，制，体制，制度，院子，房子。后面人概念需求儒，就是在院子，房子里活动的人，人民，个人。三，信息进制的组合选择。（包括信息历史传承延续的统一形式可能）
准备：
WIN10+VC6.0+EASYX
1.txt

          勇士大闯关


        [开始游戏]


          [游戏说明]


            [退出游戏]
复制代码

开始过程：

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    FILE *file = fopen("1.txt", "r"); 
    int m = 1;
    int n = 0;
    char ch;
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '[') { printf("%d,%d,",m, n); }
        if (ch == ']') { printf("%d\n", n)    ; }
        if (ch == '\n'){ m=m+1;          n = 0; }
    }
    fclose(file);
    system("pause"); 
return 0;
}
复制代码

结束结果效果

5,9,18
8,11,20
11,13,22
请按任意键继续. . .
复制代码

空间移动的空间圈层级相对组合选择，形成的人主观主动意识组合空间，满足人的类我世界时空需求。这点汇编里寻找mov移动一类的，重复这个动作和不同地址，避免其他更多复杂内容，对门外汉来说应该有可能。
易（交换），移动，if若吐如果，三个应该都可以重复，就完成虚拟信息世界的组合。
一环境条件，一般是有的，机器和汇编软件（但是知识技术没有）。
二是本体内容，三段或四段模式，一个可以显示的界面要带着，要不看起来不习惯。
三是易，移动，if的内容，不需要数字和字符集，移动的全部是数量和顺序编码代码两者。尽可能脱离外文，甚至字符集。
四怎么易，
五如何求出需求的组合选择世界？
内核是一个概念空间容器变量编码代码组成的层面流通，流量。
（已有硬件组成可满足的基本需求，移动和如果选择->）圈层级太（抽象变量通用信息的组织->（具体软件->物质技术制作围绕信息为中心展开的硬件，回到硬件组成的基本需求，历史阶段年代的人概念需求为灵魂的硬件身体））
太（易，若）
汇编输出哈喽世界，然后进行移动和IF选择，还得有储存取。一条指令（移（a,b），if（123）），前后排序换一下，另一条指令（if（456），移（c,d））。算不算是指令集，那么这样的内容，C语言也是可以实现的，位操作。C语言可以直接变量化，基本的int整数变量，或者type通用变量。应该是通用变量，这样先没有数字数量，组合中相对关系产生数量数字代码。一切从定义，相对关系，组合开始。（这里会矛盾，如果硬件是数字数量组成，那么怎么能否定数字数量组成内容呢，假设一切数字数量硬件空间不存在，或者是一切为万物去再次组合，最后组合的圆，会转回去，类似鸡生蛋或实践论的循环。得试了才知道真假对错）
怎么试移动和如果呢？

#include <stdio.h>
int main()
{
char a,b,c;
c=ab;
printf("%c",c);
return 0;
}
复制代码

ab得有输入赋值才能得出C的抽象变量关系内容。怎么脱离具体数量数值，建立抽象纯变量层面关系呢？
不应该到处乱飞，应该集中，如何解决眼前连环画的问题，这个解决就可以用到生活里。
怎么把行m，[n，]n，三个变量提取出来。m,n1,n2,第二个可以类似相对地址（偏移地址），有一个n2-n1，相对n1的数量。提出来放哪里，输出为文本，屏幕显示的内容数码编码指向开关（句柄）输出到文本，或者输出到变量概念空间，还在机器里面转（能做到这样当然好，怎么做到呢？）。
齿轮元圆，相对运动组合，形成的组合内容单元，这些单元很多，怎么留下来，而且是留在变量里？（数组，链表？）
储存取:一组（m1,n1.1,n1.2,if1）;二组（m2,n2.1,n2.2,if2），if12是指向执行对象的关系联系，关系户，联系方式，命令输出。
如果直接方形方框四边数值+行数+if空间=6个元素。用int变量就可以，数字核对一下编号表，暗号表，通过。
全部用散的单元整数和字符变量为储存池，
int m1~m1024,
int n1.1~n1.1024,
int n2.1~n2.1024
每次一个界面一般平常大概只会用这么多极限以内，无限多页的文字按钮要多一些，甚至无限延伸下去至硬件极限，而不得不进行惯常需求定义选择截取。
如果mn变量不需要另外储存，就可以完成全部文字按钮的需求呢？
一，准备
1.txt

          勇士大闯关


        [开始游戏 ]   [   ]


          [游戏说明  ]


            [退出游戏   ]
复制代码

二，开始过程
a1.exe

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
int main()
{
    FILE *file = fopen("1.txt", "r"); 
    int m = 1;
    int n = 0;
	int s = 0;
	int n1,n2,n3;
    char ch;
    while ((ch = fgetc(file)) != EOF)
	{
        n=n+1; 
        if (ch == '\n'){ 
			            m=m+1;          
						n = 0;                
		}
        if (ch == '[') {s=s+1;
			            n1=n;
		                printf("文字按钮%d,行%d,[列%d,",s,m,n1); 
		}
        if (ch == ']') { 
			            n2=n;
		                n3=n2-n1;
                        printf("间%d,]列%d\n",n3,n2);
		}
    }
    fclose(file);
    system("pause"); 
return 0;
}
复制代码

三，结束结果效果

文字按钮1,行5,[列9,间10,]列19
文字按钮2,行5,[列23,间4,]列27
文字按钮3,行8,[列11,间11,]列22
文字按钮4,行11,[列13,间12,]列25
请按任意键继续. . .
复制代码

要是有个输出，输出排序按钮1，按钮2，这样对应输出的一个什么编号，出动开关执行那个（通用字典）内容。
应该先整理好四方框的方形空间单元，然后输出到数组一类，数组里多一个拨出电话号码的if元素，翻页就清除掉，重新输入新内容。
那么mn到a12345678，会不会也是输出内容没有保存，类似批处理for多行内容，只显示最后一行。这样需要两次储存取，会不会有点麻烦了。a123456768合并一次输出，这样只考虑一个输出储存取。
[的次数，就是按钮的次数。
很可能应该用数组，去存四个数据元素？1按钮顺序数量，2行数量，3首列数量，5间数量，4尾数量（首尾得间，间数量次于尾数量，因为来源的次序）。另外一个命令if对应编号（第一个按钮顺序数量，也可以完成这个工作）循环4个数量数值存取

要其中几个文字按钮，指向FIVE66三步曲变量。if文字按钮1，则指向已有文字或图片区域的现数值上一步（-1），文字按钮2，则指向下一步+1。
不应该直接指向，而是中间有一个交换开关层面。如文字按钮123，则指向开关阵列456（自动生成的临时字典或指令集，增加了劳动量），再指向三步曲变量。多一个步骤，专用，组用，通用，要人人能看想做明白简化的形式，哪个简化用哪个。
先得按钮发挥作用才行
鼠标每次点击的变量集合里，只能是一个，不会同时点击两个。一一对应关系，先有组合的变量集合，后有选择的鼠标，点击一次敲门，对应号码开门。
鼠标点击怎么认识这是第一个按钮，还是第二个按钮，或者是整个屏幕呢？方形方框自己知道，但是鼠标不知道啊。约定合约，在这个文字按钮的默认环境本体中，符合两个条件，鼠标点击到那个区域，就被那个区域的if部队，认为是选择了我这个按钮村社阵地，发出一个信号，我们是第三文字按钮，联系通知我们守门的，可以开门了。信息信号，还是得这方形方框去联系通知。
有四个按钮，则有对应得四个内容自动生成。四个按钮的任意一个被触发敲打敲门，就if联系过去，对应开门。
if——方形方框变量123集合==鼠标点击变量456集合——则变量789集合开门输出。
三个变量集合，每个都是一个while，或者只需要前两个。这样就感觉好一些了，好像有头绪了。那么怎么连起来呢
四个按钮：
if_按钮1方形==被鼠标点击，则输出甲或修改变量开关操作一功能；
if_按钮2方形==被鼠标点击，则输出乙或修改变量开关操作二功能；
if_按钮3方形==被鼠标点击，则输出丙或修改变量开关操作三功能；
if_按钮4方形==被鼠标点击，则输出丁或修改变量开关操作四功能；
先不要急着自动（字典阵列），先手工手动完成。
那么又回到前面的鼠标点击问题，不对路子的变形。鼠标点击选择有效第一，再之是按钮方形。之前的问题，好像是按钮方形的问题。两个问题，一个是变量只有最后一个输出被捕捉有效（需要全部有效，全部按钮方形处于捕捉动态），另一个是区域布局的方形变小失去空间了。

如果图片文字弄成C语言的网页式显示模式，可能需要换一些内容。单机伪装浏览器（如果信息可以进制换算编译，也说不定），帮助文本？

zzz19760225

点击三个文字按钮的任意一个，都是显示一个输出，果然是想象的问题出现了，而不是想象的顺利内容。
如何区分不同的位置，给出不同的对应内容呢？是不是给出的内容太少，没得选？

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
	int a=0;
 	int  a1,a2,a3,a4,a5,a6,a7,a8;
    char str[1024]={0};
	int z=20;
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));
 
    setfont(z, 0, "宋体");             // 设置字体大小为20，指定字体为“宋体”
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r");  // 打开文件用于读取
 
    if (file == NULL) {    printf("无法打开文件\n");      return 1;     }
 
    int m = 1;
    int n = 0;
    char ch;
    int y = 20;  
 
	a=a+1;
    sprintf(str,"%d.txt",a);
 
            FILE *file1 = fopen(str, "r");    // 打开并读取文本文件
			if (file1) 
			{
                 char buffer[1024];
    
				 char *line1;
                 while (fgets(buffer, sizeof(buffer), file1)) 
				 {                            // 逐行读取文件内容并显示
                     line1 = strdup(buffer);  // 复制行以便修改
                     settextcolor(GREEN);     //  设字符颜色
                     outtextxy(z, y, line1);  // 显示文本，假设从(20横坐标, y纵坐标)开始
                     free(line1);
                     y =y+z;                  // 下一行的y坐标
				 }
             fclose(file1);                   // 关闭文件
			 }
                                              // 逐字符读取文件内容
             while ((ch = fgetc(file)) != EOF) {
                    n=n+1;    
                    if (ch == '[') {  printf("%d行%d个'['\n", m, n);
		                  a2=m*20;      a4=a2+20;     //2,4,上下，上0相对，数值小上大下效应形态
                          a1=n*10+10;   a3=a1+20;     //1,3,左右，左0相对，数值小左大右效应形态
                    //    setlinecolor(RED);          // 设绘画的线条颜色
                    //    rectangle(a1,a2,a3,a4);     // 方形绘画
					}
                    if (ch == ']') {printf("%d行%d个']'\n", m, n); 
		                  a6=m*20;      a8=a2+20;     //2,4,上下，上0相对，数值小上大下效应形态
                          a5=n*10+20;   a7=a1; 
					      setlinecolor(RED);          // 设绘画的线条颜色，红色RED，黑色隐入背景黑色BLACK
                          rectangle(a5,a6,a7,a8);     // 方形绘画
					} 
                    if (ch == '\n') {
                          m=m+1;   // 行数增加
                          n = 0;   // 重置位置计数器
					}
			 }

    while (!kbhit() || (unsigned)getch() != 27) {// 无限循环，直到用户按下ESC键  

		MOUSEMSG msg = GetMouseMsg();// 鼠标状态
		if (msg.uMsg == WM_LBUTTONDOWN || (msg.x>a5 && msg.y>a6 && msg.x<a7 && msg.y<a8)) // 如果是左键点击 
		{
		  //cleardevice();// 清除屏幕
          outtextxy(300, 200, "123"); 		
		} 
		  if (msg.uMsg == WM_LBUTTONDBLCLK) // 如果是左键双击
		  {
		
		  }
	    	if (msg.uMsg == WM_RBUTTONDOWN) // 如果是右键点击
			{
		
			}
	}
    system("pause"); // 暂停，以便查看输出结果
    closegraph();
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    return 0;
}
复制代码

假如它们的内容单元线，是顺序叫号，那么后面有一个对号的地方，可以对暗号，是不是可以带到对应的输出内容门路。有熊村四组的王莽，张三，李四，王二麻，跟我去太极一区二阳路三阴工场五行田里干活。
4个单元一组的传说中的数组，四个一装的打包，贴上数量标签，顺序标签。数量贴标签的机器
还有这个显示的内容，怎么清除呢，又不能把已有的结构清除掉。清除后重新循环显示。还是那个指定区域清除。也不对，应该是跟随需求进行清除，全清除，部分区域清除，指定小区域单元清除。（这点是否可以考虑点阵自由度的屏幕处理，用于点阵自由度汉字的内容）
也有与输出显示需求有关，文字按钮的并行页面显示，换页显示。并页就应该对并列的显示区域当作屏幕一样去清屏处理。所以遇到的需求情况，一个一个单元去处理，已有单元最好都过一遍，这些单元集合就是工具箱。
1文字按钮点击并页显示部分
1.1并页显示文字

    while (!kbhit() || (unsigned)getch() != 27) {  // 无限循环，直到用户按下ESC键  

		MOUSEMSG msg = GetMouseMsg();  // 鼠标状态
		if (msg.uMsg == WM_LBUTTONDOWN || (msg.x>a5 && msg.y>a6 && msg.x<a7 && msg.y<a8))  // 如果是左键点击
		{
		  //cleardevice();// 清除屏幕
          clearrectangle(300, 200, 480, 640);  // 清除指定的矩形区域
          outtextxy(300, 200, "123"); 	
		}
		  if (msg.uMsg == WM_LBUTTONDBLCLK)  // 如果是左键双击
		  {

		  }
	    	if (msg.uMsg == WM_RBUTTONDOWN)   // 如果是右键点击
			{
		     clearrectangle(300, 200, 480, 640);  // 清除指定的矩形区域
		     outtextxy(300, 200, "456"); 
			}
	}
复制代码

出大事情了！鼠标不是点击指定区域进行开关输出显示，而是整个界面点击都输出显示！
-----------
-----------

	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                                 //HOPE2021鼠标
    RECT bof = {0,0, 200, 200};     //图片矩形区域 = 左, 顶, 右, 底
    RECT bof1 = {0,200, 400, 400};     //图片矩形区域 = 左, 顶, 右, 底
     if (msg.uMsg == WM_LBUTTONDOWN){     //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                             // 鼠标点击图片方位数量
 
            if (PtInRect(&bof, pt)&& WM_LBUTTONDOWN) {                              // 鼠标点击图片方位数量的区域有效
		     clearrectangle(300, 200, 480, 640);  // 清除指定的矩形区域
             settextstyle(20, 0, "宋体"); // 设置文字大小为20，无倾斜，使用"微软雅黑"字体
             outtextxy(300, 200, "123"); // 在窗口坐标(1100,500)处输出文本

			 }
			 if (PtInRect(&bof1, pt) && WM_RBUTTONDOWN) {                              // 鼠标点击图片方位数量的区域有效
		     clearrectangle(300, 200, 480, 640);  // 清除指定的矩形区域
             settextstyle(20, 0, "宋体"); // 设置文字大小为20，无倾斜，使用"微软雅黑"字体
             outtextxy(300, 200, "456"); // 在窗口坐标(1100,500)处输出文本

			 }	 
	 }}
复制代码

是可以不同区域点击，显示不同内容的。
-
-

	int a21,a22,a23,a24;
	a21=0,a22=0,a23=200,a24=200;
    int a31,a32,a33,a34;
	a31=0,a32=200,a33=400,a34=400;

	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                                 //HOPE2021鼠标
    RECT bof = {a21,a22, a23, a24};     //图片矩形区域 = 左, 顶, 右, 底
    RECT bof1 = {a31,a32, a33, a34};     //图片矩形区域 = 左, 顶, 右, 底
     if (msg.uMsg == WM_LBUTTONDOWN){     //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                             // 鼠标点击图片方位数量
 
            if (PtInRect(&bof, pt)&& WM_LBUTTONDOWN) {                              // 鼠标点击图片方位数量的区域有效
		     clearrectangle(300, 200, 480, 640);  // 清除指定的矩形区域
             outtextxy(300, 200, "123"); // 在窗口坐标(1100,500)处输出文本

			 }
			 if (PtInRect(&bof1, pt) && WM_RBUTTONDOWN) {                              // 鼠标点击图片方位数量的区域有效
		     clearrectangle(300, 200, 480, 640);  // 清除指定的矩形区域
             outtextxy(300, 200, "456"); // 在窗口坐标(1100,500)处输出文本

			 }	 
	 }}
复制代码

同样数值放在变量里是可以重复显示的
-
-

    RECT bof = {a1,a2, a3, a4};     //图片矩形区域 = 左, 顶, 右, 底
    RECT bof1 = {a5,a6, a7, a8};     //图片矩形区域 = 左, 顶, 右, 底
复制代码

将文字按钮的方形框变量代入，又不行了。

	while (1) 
	{
    MOUSEMSG msg = GetMouseMsg();                              //HOPE2021鼠标
    RECT bof = {a1-20,a2-20,a3+20,a4+20};                 //图片矩形区域 = 左, 顶, 右, 底
	if (msg.uMsg == WM_LBUTTONDOWN){          //HOPE2021鼠标
            POINT pt = {msg.x, msg.y};                         // 鼠标点击图片方位数量
 
            if (PtInRect(&bof, pt)&& WM_LBUTTONDOWN) { 
		     //clearrectangle(300, 200, 200, 200);  // 清除指定的矩形区域
			 rectangle(a1-20,a2-20,a3+20,a4+20); 
             outtextxy(300, 200, "123"); 
			 }
	 }}
复制代码

可以显示，但是，不听话，不是按照主观认为的按钮方形框对应内容点击显示。
虽然乱七八糟的，但是至少有现象内容，不是凭空消失无所选择，叫有得选，这样还可以有继续从错误走向不错的可能。

（或者每次截取一组四个单元）


1.2并页显示文本


2文字按钮点击换页显示部分


全面点击（整体），部分区域点击（单元），部分区域点击里的空间阵列多个单元点击，以及先后顺序区别点击，时间点击（11点钟敲钟吃饭）。
HOPE的鼠标坐标数值，进行数量数值对比，以及更复杂绕脑子的相对关系抽象变量维度集合对比。
长远技术积累的通用内容，应该是越走越薄的假设，其余组用，专用的历史阶段和年代内容，相对变化要少。中文编程应该主体通用内容为主，年代承接越来越熟悉熟练。
需要一个配套的变量形态显示方形框，可以看见，观察，对名形进行相对选择的空间。否则对着一个扫雷游戏一样的到处乱点鼠标，太不行了。另外是如何类似FOR那样，将a1a2a3a4a5a6a7a8的内容全部显示出来，要不老是稀里糊涂的，很麻烦。而实际是可以进一步相对简化的，就如没有地图的乱走，需要那个主观想法接近的工具地图。（根源应该还是m和n的数量处理那部分，信息都是来自那里，把根源源处理好，后面变量叠加再处理，a1~a8影子就出来了）

zzz19760225

手动左位文字按钮字符，对齐方形框起位。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
	int a=0;
 	int  a1,a2,a3,a4;
    char str[1024]={0};
	int z=20;
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));
 
    setfont(z, 0, "宋体");             // 设置字体大小为20，指定字体为“宋体”
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r");  // 打开文件用于读取
 
    if (file == NULL) {    printf("无法打开文件\n");      return 1;     }
 
    int m = 1;
    int n = 0;
    char ch;
    int y = 20;  
 
	a=a+1;
    sprintf(str,"%d.txt",a);
 
            FILE *file1 = fopen(str, "r");    // 打开并读取文本文件
			if (file1) 
			{
                 char buffer[1024];
                           // 假设图片下方开始显示文本，上下600位置写字
				 char *line1;
                 while (fgets(buffer, sizeof(buffer), file1)) 
				 {                            // 逐行读取文件内容并显示
                     line1 = strdup(buffer);  // 复制行以便修改
                     settextcolor(GREEN);    //  设字符颜色
                     outtextxy(z, y, line1);   // 显示文本，假设从(20横坐标, y纵坐标)开始
                     free(line1);
                     y =y+z;                // 下一行的y坐标
				 }
             fclose(file1);                   // 关闭文件
			 }
                     // 逐字符读取文件内容
             while ((ch = fgetc(file)) != EOF) {
                    n=n+1;       // 更新当前位置
                    if (ch == '[') {  printf("在第 %d 行，第 %d 个位置找到 '['\n", m, n);
		                  a2=m*20;      a4=a2+20;  //2,4,上下，上0相对，数值小上大下效应形态
                          a1=n*10+10;      a3=a1+20;  //1,3,左右，左0相对，数值小左大右效应形态
                          setlinecolor(RED);             // 设绘画的线条颜色
                          rectangle(a1,a2,a3,a4);     // 方形绘画
					}
                    if (ch == ']') {printf("在第 %d 行，第 %d 个位置找到 ']'\n", m, n); } 
                    if (ch == '\n') {
                          m=m+1;   // 行数增加
                          n = 0;   // 重置位置计数器
					}
			 }
 
    system("pause"); // 暂停，以便查看输出结果
    closegraph();
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    return 0;
}
复制代码

间隔不会影响左定位

下面应该是，如何进行右定位对齐了。
一[联系一]计算中间的间隔字符单元数量。
[左字符可以左定位，那么如果]右字符进行右定位，会不会同样可以呢？
（如果这些定位方式方法，在后续对接鼠标点击中无效，就是方向错误，需要推倒重来。好处是有了一个概念空间的练习积累，坏处是好像白跑了一圈，又回到了从前的心意识感觉）

如果有一个通用的文本字符处理阵列集合，或百宝箱，这样文字按钮就可以有更多自由度丰富选择？
编码变量，变量穿针引线的概念空间规律。
抄写代码，实现功能，并单元化，可单元组合化。（机器编程AI编程，应该不是，一个是抽象相对关系可能尝试的批处理，一个是具体产业实践的名实有限内容）
第三方单元集？批处理第三方单元集？基本需求基本简单功能的批处理第三方单元集。
C语言中的单元集呢，goto标签段落为一个单元

本来是想前[后]相减，负值取反，后来不知道怎么拼凑，居然有符合需求的内容，就先这样，先走下一步鼠标区域点击部分，稀里糊涂拼凑存疑的，以后再说。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
	int a=0;
 	int  a1,a2,a3,a4,a5,a6,a7,a8;
    char str[1024]={0};
	int z=20;
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));
 
    setfont(z, 0, "宋体");             // 设置字体大小为20，指定字体为“宋体”
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r");  // 打开文件用于读取
 
    if (file == NULL) {    printf("无法打开文件\n");      return 1;     }
 
    int m = 1;
    int n = 0;
    char ch;
    int y = 20;  
 
	a=a+1;
    sprintf(str,"%d.txt",a);
 
            FILE *file1 = fopen(str, "r");    // 打开并读取文本文件
			if (file1) 
			{
                 char buffer[1024];
    
				 char *line1;
                 while (fgets(buffer, sizeof(buffer), file1)) 
				 {                            // 逐行读取文件内容并显示
                     line1 = strdup(buffer);  // 复制行以便修改
                     settextcolor(GREEN);     //  设字符颜色
                     outtextxy(z, y, line1);  // 显示文本，假设从(20横坐标, y纵坐标)开始
                     free(line1);
                     y =y+z;                  // 下一行的y坐标
				 }
             fclose(file1);                   // 关闭文件
			 }
                                              // 逐字符读取文件内容
             while ((ch = fgetc(file)) != EOF) {
                    n=n+1;    
                    if (ch == '[') {  printf("%d行%d个'['\n", m, n);
		                  a2=m*20;      a4=a2+20;     //2,4,上下，上0相对，数值小上大下效应形态
                          a1=n*10+10;   a3=a1+20;     //1,3,左右，左0相对，数值小左大右效应形态
                    //    setlinecolor(RED);          // 设绘画的线条颜色
                    //    rectangle(a1,a2,a3,a4);     // 方形绘画
					}
                    if (ch == ']') {printf("%d行%d个']'\n", m, n); 
		                  a6=m*20;      a8=a2+20;     //2,4,上下，上0相对，数值小上大下效应形态
                          a5=n*10+10;   a7=a1+10; 
					      setlinecolor(RED);          // 设绘画的线条颜色
                          rectangle(a5,a6,a7,a8);     // 方形绘画
					} 
                    if (ch == '\n') {
                          m=m+1;   // 行数增加
                          n = 0;   // 重置位置计数器
					}
			 }
 
    system("pause"); // 暂停，以便查看输出结果
    closegraph();
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    return 0;
}
复制代码

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
	int a=0;
 	int  a1,a2,a3,a4,a5,a6,a7,a8;
    char str[1024]={0};
	int z=20;
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));
 
    setfont(z, 0, "宋体");             // 设置字体大小为20，指定字体为“宋体”
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r");  // 打开文件用于读取
 
    if (file == NULL) {    printf("无法打开文件\n");      return 1;     }
 
    int m = 1;
    int n = 0;
    char ch;
    int y = 20;  
 
	a=a+1;
    sprintf(str,"%d.txt",a);
 
            FILE *file1 = fopen(str, "r");    // 打开并读取文本文件
			if (file1) 
			{
                 char buffer[1024];
    
				 char *line1;
                 while (fgets(buffer, sizeof(buffer), file1)) 
				 {                            // 逐行读取文件内容并显示
                     line1 = strdup(buffer);  // 复制行以便修改
                     settextcolor(GREEN);     //  设字符颜色
                     outtextxy(z, y, line1);  // 显示文本，假设从(20横坐标, y纵坐标)开始
                     free(line1);
                     y =y+z;                  // 下一行的y坐标
				 }
             fclose(file1);                   // 关闭文件
			 }
                                              // 逐字符读取文件内容
             while ((ch = fgetc(file)) != EOF) {
                    n=n+1;    
                    if (ch == '[') {  printf("%d行%d个'['\n", m, n);
		                  a2=m*20;      a4=a2+20;     //2,4,上下，上0相对，数值小上大下效应形态
                          a1=n*10+10;   a3=a1+20;     //1,3,左右，左0相对，数值小左大右效应形态
                    //    setlinecolor(RED);          // 设绘画的线条颜色
                    //    rectangle(a1,a2,a3,a4);     // 方形绘画
					}
                    if (ch == ']') {printf("%d行%d个']'\n", m, n); 
		                  a6=m*20;      a8=a2+20;     //2,4,上下，上0相对，数值小上大下效应形态
                          a5=n*10+20;   a7=a1; 
					      setlinecolor(RED);          // 设绘画的线条颜色
                          rectangle(a5,a6,a7,a8);     // 方形绘画
					} 
                    if (ch == '\n') {
                          m=m+1;   // 行数增加
                          n = 0;   // 重置位置计数器
					}
			 }
 
    system("pause"); // 暂停，以便查看输出结果
    closegraph();
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    return 0;
}
复制代码

把[]区域也包括进去，这样空间就足够了。
下面是针对这个数值内容，进行鼠标点击区域设置（不管数值怎么来的）。
鼠标点击区域部分，点击输出信息部分，所有不同区域点击输出一个内容，各个区域点击分别拉线穿针到不同的if联系连接地方。（一个区域集中输出，提示有信号。一个区域集中输出，输出不同点击的内容信号）
（点击，换一个个文本，换文本中的一个个章节段落，搜索文件夹和文件及其内容。单机简化式家用版google，百度，知识链接的跳转，链接为一个信息整体，抽象简化够用的圆概念）

zzz19760225

上下相对的a1,a3,数值内容，与左右的a2,a4,交换一下，就从显示的上下竖布置，换成横布置了。

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>

#ifdef _MSC_VER                   //Five66变量三步曲
#pragma warning(disable:4996)     //Five66变量三步曲
#endif                            //Five66变量三步曲
 
int main(){

    char str[1024]={0};   //Five66变量三步曲
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));          //Five66变量三步曲

	int H0=400,I0=250;
    initgraph(H0, I0);

 

    int  m = 1      ;
    int  n = 0      ;
    char ch         ;
    int  a = 0      ;
	int  a1,a2,a3,a4;
    setfont(20, 10, "宋体"); // 设置字体大小为20，指定字体为“宋体”
    // sprintf(str,"%d.txt",a);                //Five66变量三步曲,文字文本文件变量
 
    FILE *file = fopen("1.txt", "r");    // 打开并读取文本文件
    while ((ch = fgetc(file)) != EOF) { // 逐字符读取文件内容
        n=n+1;     
        if (ch == '[') {  
                    	a2=m*18;  a4=a2+18 ;
                    	a1=n*18;  a3=a1+18 ; 
                        rectangle(a1,a2,a3,a4);
		}
        if (ch == '\n') {  	m=m+1;     	n = 0;        	}
	}
	if (file) 
	{
            char buffer[1024];
                 int y = 20;                // 假设图片下方开始显示文本，上下600位置写字
				 char *line;
                 while (fgets(buffer, sizeof(buffer), file)) 
				 {                           // 逐行读取文件内容并显示
                     line = strdup(buffer);  // 复制行以便修改
                     outtextxy(20, y, line); // 显示文本，假设从(20, y)开始
                     free(line);
                     y += 20;                // 下一行的y坐标
				 }
             fclose(file);                   // 关闭文件
	}

    fclose(file);                       // 关闭文件
	getch();                            //暂停以便于观察程序
closegraph();
return 0;   
}
复制代码

可以横过来了。但是新的问题，是按钮的文字内容与绘图方框不能并列，之前手动那个是可以并列的，便于观察。
另一个主要新的问题是所有的多文字按钮，是对应一个相同的鼠标触发，输出同一个内容，还是分别对应不同的内容。如何实现多个鼠标点击区域，对应不同选择内容。
还有个，是开始Five66三步曲变量，文字按钮点击切换后，新的内容是否有效，不断点击文字按钮，切换显示新的文本内容，新的文字按钮（刷新？，新显示是切换设置好的一个个文本单元，还是一个文本里的一个个章段节信号截取？）。

文字按钮和定位方框可以并列了，但是没有规律对应联系连接起来。需要穿针引线裁剪缝纫细密些

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
	int a=0;
 	int  a1,a2,a3,a4;
    char str[1024]={0};
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));
 
        setfont(20, 0, "宋体"); // 设置字体大小为20，指定字体为“宋体”
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r"); // 打开文件用于读取
    if (file == NULL) {
        printf("无法打开文件\n");
        return 1;
    }
 
    int m = 1;
    int n = 0;
    char ch;
 
    // 逐字符读取文件内容
    while ((ch = fgetc(file)) != EOF) {
        n=n+1; // 更新当前位置
 
        if (ch == '[') {printf("在第 %d 行，第 %d 个位置找到 '['\n", m, n);
		                a2=m*18;  a4=a2+18 ;
                    	a1=n*18;  a3=a1+18 ; 
                        rectangle(a1,a2,a3,a4);
		}
        if (ch == ']') {printf("在第 %d 行，第 %d 个位置找到 ']'\n", m, n);} 
        if (ch == '\n') {
            m=m+1; // 行数增加
            n = 0; // 重置位置计数器
        }
    }
	a=a+1;
    sprintf(str,"%d.txt",a);
 
            FILE *file1 = fopen(str, "r");// 打开并读取文本文件
			if (file1) 
			{
                 char buffer[1024];
                 int y = 0; // 假设图片下方开始显示文本，上下600位置写字
				 char *line1;
                 while (fgets(buffer, sizeof(buffer), file1)) 
				 {// 逐行读取文件内容并显示
                     line1 = strdup(buffer); // 复制行以便修改
                     outtextxy(20, y, line1); // 显示文本，假设从(20, y)开始
                     free(line1);
                     y += 20;               // 下一行的y坐标
				 }
             fclose(file1); // 关闭文件
			 }
 
    system("pause"); // 暂停，以便查看输出结果
    closegraph();
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    return 0;
}
复制代码

鼠标点击的模拟方形框，其上下行参数数值，应该以文字为相对数值，联动。
上下
字体开始显示位置，字符上线，字体高度显示大小，字符下线。字符有间隔值，区别于字符字体大小，属于双层值。字符字体大小，等于间隔值，字符字体的上下，就是间隔值的上下线。要对齐，减少一个麻烦。
                         方形上线，方形包括字体区域，方形下线。方形没有间隔值
太麻烦了
基本可以保持上下文字于方形一致，为什么做到，需要慢慢熟悉再说。后面应该是怎么把字的左右距离拉近[字符

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <graphics.h>
#include <easyx.h>
 
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")
#pragma comment(lib,"user32.lib")
 
#ifdef _MSC_VER
#pragma warning(disable:4996)
#endif
 
int main()
{
	int H0=1000,I0=500;
    initgraph(H0, I0);
	int a=0;
 	int  a1,a2,a3,a4;
    char str[1024]={0};
	int z=20;
 
    TCHAR *szBuffer=(TCHAR *)calloc(1024,sizeof(TCHAR));
 
    setfont(z, 0, "宋体");             // 设置字体大小为20，指定字体为“宋体”
 
    char filename[] = "1.txt";
    FILE *file = fopen(filename, "r");  // 打开文件用于读取

    if (file == NULL) {    printf("无法打开文件\n");      return 1;     }
 
    int m = 1;
    int n = 0;
    char ch;
    int y = 20;  

	a=a+1;
    sprintf(str,"%d.txt",a);
 
            FILE *file1 = fopen(str, "r");    // 打开并读取文本文件
			if (file1) 
			{
                 char buffer[1024];
                           // 假设图片下方开始显示文本，上下600位置写字
				 char *line1;
                 while (fgets(buffer, sizeof(buffer), file1)) 
				 {                            // 逐行读取文件内容并显示
                     line1 = strdup(buffer);  // 复制行以便修改
                     settextcolor(GREEN);    //  设字符颜色
                     outtextxy(z, y, line1);   // 显示文本，假设从(20横坐标, y纵坐标)开始
                     free(line1);
                     y =y+z;                // 下一行的y坐标
				 }
             fclose(file1);                   // 关闭文件
			 }
                     // 逐字符读取文件内容
             while ((ch = fgetc(file)) != EOF) {
                    n=n+1;       // 更新当前位置
                    if (ch == '[') {  printf("在第 %d 行，第 %d 个位置找到 '['\n", m, n);
		                  a2=m*20;      a4=a2+20;  //2,4,上下，上0相对，数值小上大下效应形态
                          a1=n*18;      a3=a1+18;  //1,3,左右，左0相对，数值小左大右效应形态
                          setlinecolor(RED);             // 设绘画的线条颜色
                          rectangle(a1,a2,a3,a4);     // 方形绘画
					}
                    if (ch == ']') {printf("在第 %d 行，第 %d 个位置找到 ']'\n", m, n); } 
                    if (ch == '\n') {
                          m=m+1;   // 行数增加
                          n = 0;   // 重置位置计数器
					}
			 }

    system("pause"); // 暂停，以便查看输出结果
    closegraph();
    if(szBuffer != NULL) {free(szBuffer);szBuffer=NULL;}
    return 0;
}
复制代码