C++实现仿数据库的数据管理工具，还没彻底完工，贴目前的代码

private_sql.h文件（心虚，事实上离sql差了十万八千里）

 

#pragma once
#ifndef PRIVATE_SQL_H_H
#define PRIVATE_SQL_H_H
#include <string>//类成员，需要声明整个类
using namespace std;

class private_sql
{

public:

    private_sql();

    //新建表
    int new_table(string tabname, string  colname);

    //新建行
    int new_row(string tabname, string sqlstr);

    //删除行
    int delete_row(string tabname, string sqlstr);

    //删除表
    int delete_table(string tabname);

    //更新数据
    int updata_data(string tabname, string sqlstrset, string sqlstrwhere);

    //新建列
    int new_col(string tabname, string colname);

    //删除列
    int delete_col(string tabname, string colname);

    typedef struct tab
    {
        int lock = 0;//对文本文件和结构体变量加锁，多线程间不要同时使用一个文本文件，不能同时使用一个结构体变量
        int vregexsize;//保存列名的匹配字符数//列名的匹配字符会比行名多一位为的是分割最后一位列名与正文
        int vnamesize;//保存列名数//列名数与列名匹配字符数相等
        string * vregex;//保存列名的匹配字符
        string * vdatatype;//保存数据类型
        string * vname;//保存列名
        int smrowsize;//保存行号数
        int smcolsize;//保存列号数
        string * srow;//srow存放行匹配字符串，行匹配字符只有行
        string ** scol;//scol存放列匹配字符串,列匹配字符是行*列
        string ** sm;//第二个数组参数表示行，第三个参数表示列
    }tab;
    //查询三步
    //查询表1
    int select_table(tab * s, string tabname);

    //显示读出的文件2
    int show_tab(tab * s);

    //清理结构体变量3
    int clean_tab(tab * s);

    //查询表,显示
    int select_table_show(string tabname);

    //调试工具
    int set_sql();
};
#endif

 

 

 

 

 

 

 

 

private_sql.cpp文件（理想总是要有的，万一哪天实现了呢？）

 

#include "private_sql.h"
#include <iostream>
#include <fstream> 
#include <regex>
#include <vector>
#include <WINSOCK2.H>   
#include <stdio.h>     
#include <string>
#include <stdlib.h>//用于随机生成字母
#include <time.h>//同上
#pragma comment(lib, "ws2_32.lib")     链接到WS2_32.lib  
using namespace std;//不加这段命名空间，就会报错cout和endl未声

string vnameregex = "|zzljhfislefs|wjj*zzl|gdsergwazlefhsegslf|";//中间的*号作为数字位置识别标记
string vnameregextop = "|zzljhfislefs|wjj";    //列名匹配符前半
string vnameregexbot = "zzl|gdsergwazlefhsegslf|";
string rowregex = "|zzlesfeegdse|wjj*zzl|gdsergfdsezgtsdcnhu|";
string rowregextop = "|zzlesfeegdse|wjj";    //行名匹配符前半
string rowregexbot = "zzl|gdsergfdsezgtsdcnhu|";
string colregex = "|felzegidsfgieuze|wjj*zzl|geuponhuemrszun|";
string colregextop = "|felzegidsfgieuze|wjj";    //列匹配符前半
string colregexbot = "zzl|geuponhuemrszun|";
string VNAMESIZE = "[|][z][z][l][j][h][f][i][s][l][e][f][s][|][w][j][j][A-Z]*[0-9]*[z][z][l][|][g][d][s][e][r][g][w][a][z][l][e][f][h][s][e][g][s][l][f][|]";
string ROWSIZE = "[|][z][z][l][e][s][f][e][e][g][d][s][e][|][w][j][j][0-9]*[z][z][l][|][g][d][s][e][r][g][f][d][s][e][z][g][t][s][d][c][n][h][u][|]";
string COLSIZE = "[|][f][e][l][z][e][g][i][d][s][f][g][i][e][u][z][e][|][w][j][j][0-9]*[z][z][l][|][g][e][u][p][o][n][h][u][e][m][r][s][z][u][n][|]";

private_sql a;
typedef struct tab
{
    int lock = 0;//对文本文件和结构体变量加锁，多线程间不要同时使用一个文本文件，不能同时使用一个结构体变量
    int vregexsize;//保存列名的匹配字符数//列名的匹配字符会比行名多一位为的是分割最后一位列名与正文
    int vnamesize;//保存列名数//列名数与列名匹配字符数相等
    string * vregex;//保存列名的匹配字符
    string * vdatatype;//保存数据类型
    string * vname;//保存列名
    int smrowsize;//保存行号数
    int smcolsize;//保存列号数
    string * srow;//srow存放行匹配字符串，行匹配字符只有行
    string ** scol;//scol存放列匹配字符串,列匹配字符是行*列
    string ** sm;//第二个数组参数表示行，第三个参数表示列
}tab;

//一个自定义的头文件
private_sql::private_sql()
{
    tab;
}

//注！重要事项，每次调用有全局自定义数组的函数后，都需要在下次调用前或者函数结尾时使用delete删除申请的空间;首次调用不需要删除空间
//id是一个特殊的列名，以id为列名的表，删除行的时候无法删除id
//另外，如修改id这样的操作是无效的，id不可更改
//以后可能修改新建表，使id自动增长从1开始
string strget(string strpath)
{
    int i, str_length, c;
    FILE *fi;
    string str;
    char path[1024];
    sprintf(path, "%s", strpath.c_str());//string字符串赋值给字符数组需要在后面加.c_str()
                                         //cout << path << endl;
    fi = fopen(path, "r");
    if (fi == NULL) {//rb读取为二进制
        printf("该表不存在!");
        return "false";
    }
    //____循环得到总的字符数_____________________________________________
    i = 0;
    while (1)
    {
        c = fgetc(fi);
        if (EOF == c) { break; }
        i++;
    }
    //cout << i << endl;
    str_length = i;
    char * strchar;//这是经典的数组长度定义
    strchar = new char[str_length + 1];//通过new定数组长度(尽量往长了定义，不怕长就怕短)
    rewind(fi);
    i = 0;
    while (1) {
        c = fgetc(fi);//fgetc()读取函数，从文件中读取单个的字符，同时光标自动向后移一位
        if (EOF == c) { strchar[i] = '\0'; break; }

        //fputc(c,fo);//fputc()输出函数，把单个字符输出到文件中
        strchar[i] = c;

        //printf("%c", strchar[i]);
        i++;
    }
    str = strchar;
    //cout << str;
    //Sleep(7000);
    fclose(fi);
    delete[] strchar;
    return str;
}
//写入txt文档
int strgive(string strpath, string str)
{
    int outsize, strlength, pathlength;
    FILE *fo;
    //cout << strpath << endl;
    char *path, *ch;
    outsize = strpath.length();
    pathlength = outsize;
    path = new char[outsize + 1];
    outsize = str.length();
    strlength = outsize;
    ch = new char[outsize + 1];

    strcpy(path, strpath.c_str());//C++中把string字符串转化为字符数组的代码
    path[pathlength] = '\0';//不加'\0'会有意外错误
    strcpy(ch, str.c_str());
    ch[strlength] = '\0';
    //
    //sprintf(path, "%s", strpath.c_str());//string字符串赋值给字符数组需要在后面加.c_str()
    //cout << path << endl;
    //sprintf(ch, "%s", strcom.c_str());

    fo = fopen(path, "w");
    if (fo == NULL) {//rb读取为二进制
        printf("该表不存在!");
        return -1;
    }

    fputs(ch, fo);//向文本文档输入字符串，用fputs()

    fclose(fo);
    delete[] path;
    delete[] ch;
    return 1;
}

//正则匹配分割字符串，匹配后结果存入regexst.s[]数组，结果的个数存入regexst.idsize
struct MyStruct
{
    int idsize;
    string * s;
    int idtize;
    string * t;
};
MyStruct regexst;
int  regex_stold(string str, string strreg)
{//返回-1表示被匹配字符串为空，返回-2匹配正则表达式为空，返回-10没有匹配的项目

    regex reg(strreg);//加载正则匹配的公式
    int i = 0;
    int j = 0;
    for (sregex_token_iterator it(str.begin(), str.end(), reg, -1), end; it != end; it++, i++) {
        if (it->str() != "") {//因为有可能前面第一个就是匹配字符串，或者中间有连续而无意义的匹配字符
            j++;
        }
    }
    //cout << "j:" << j << endl;
    regexst.idsize = j;
    regexst.s = new string[i];
    i = 0;
    j = 0;
    for (sregex_token_iterator it(str.begin(), str.end(), reg, -1), end; it != end; it++, i++) {
        if (it->str() != "") {
            regexst.s[j] = it->str();
            //cout << regexst.s[j] << endl;
            j++;
        }

    }

    //记数字符串里匹配正则的个数，最后的个数i赋值给regexst.idtize,idtize是t的个数
    smatch sm;
    string strtoo = str;
    i = 0;
    while (regex_search(strtoo, sm, reg)) {
        strtoo = sm.suffix().str();//每次循环，把剩余未匹配的字符串重新加入str字符串变量
        i++;
    }
    regexst.idtize = i;

    //cout << regexst.idtize << endl;
    regexst.t = new string[i];

    i = 0;
    strtoo = str;
    while (regex_search(strtoo, sm, reg)) {
        for (int j = 0; j < sm.size(); ++j)
        {
            regexst.t[i] = sm[j];
            //cout << regexst.t[i] << " ";
        }
        //cout << endl;
        strtoo = sm.suffix().str();//每次循环，把剩余未匹配的字符串重新加入str字符串变量
        i++;
    }

    return 1;

}
int  regex_st(string str, string strreg)
{//返回-1表示被匹配字符串为空，返回-2匹配正则表达式为空，返回-10没有匹配的项目

    regex reg(strreg);//加载正则匹配的公式
    int i = 0;
    int j = 0;
    for (sregex_token_iterator it(str.begin(), str.end(), reg, -1), end; it != end; it++, i++) {
        if (it->str() != "") {//因为有可能前面第一个就是匹配字符串，或者中间有连续而无意义的匹配字符
            j++;
        }
    }
    //cout << "j:" << j << endl;
    regexst.idsize = j;
    regexst.s = new string[i];
    i = 0;
    j = 0;
    for (sregex_token_iterator it(str.begin(), str.end(), reg, -1), end; it != end; it++, i++) {
        if (it->str() != "") {
            regexst.s[j] = it->str();
            //cout << regexst.s[j] << endl;
            j++;
        }

    }

    //记数字符串里匹配正则的个数，最后的个数i赋值给regexst.idtize,idtize是t的个数
    smatch sm;
    string strtoo = str;
    i = 0;
    while (regex_search(strtoo, sm, reg)) {
        strtoo = sm.suffix().str();//每次循环，把剩余未匹配的字符串重新加入str字符串变量
        i++;
    }
    regexst.idtize = i;

    //cout << regexst.idtize << endl;
    regexst.t = new string[i];

    i = 0;
    strtoo = str;
    while (regex_search(strtoo, sm, reg)) {
        for (int j = 0; j < sm.size(); ++j)
        {
            regexst.t[i] = sm[j];
            //cout << regexst.t[i] << " ";
        }
        //cout << endl;
        strtoo = sm.suffix().str();//每次循环，把剩余未匹配的字符串重新加入str字符串变量
        i++;
    }

    return 1;

}
void delete_new_regex_st()
{
    delete[] regexst.s;
    delete[] regexst.t;
}
//分割字符串，分别存入数组，完成整表查询的功能
struct MySql_Sel {
    //真正开始写功能实现，目标，匹配行标，匹配列标
    //因为考虑到需要对空值作标记，想了想还是通过一串匹配字符完成，虽然会很占空间
    //数据极其脆弱，不可以有换行，数值的字符间可以有空格，数值前后不可以有空格
    int vregexsize;//保存列名的匹配字符数//列名的匹配字符会比行名多一位为的是分割最后一位列名与正文
    int vnamesize;//保存列名数
    string * vregex;//保存列名的匹配字符
    string * vdatatype;//保存数据类型
    string * vname;//保存列名
    int smrowsize;//保存行号数
    int smcolsize;//保存列号数
    string * srow;//srow存放行匹配字符串，行匹配字符只有行
    string ** scol;//scol存放列匹配字符串,列匹配字符是行*列
    string ** sm;//第二个数组参数表示行，第三个参数表示列
};
MySql_Sel mysqlsel;
int mysql_sel(string tabname)
{
    /*string  tabname
    列名:VNAMESIZE
    行号:ROWSIZE
    列号:COLSIZE
    */
    int i = 0;//i和j是用于循环的时候记次的
    int j = 0;
    string str, strtoo, strtootoo;//保存原始字符串和初次加工去除列名列标的字符串
    string strrow, strrowreg, strdatatype;//循环时，临时存放行字符串和和行字符串的匹配码;存放未匹配含数据类型的字符串

    string stra, strb;
    stra = "db\\" + tabname;
    strb = stra + ".txt";
    str = strget(strb);//调用自定义函数，获取txt文档内容，存为string字符串
    if (str == "false") return -1;
    //str = strget("db\\1.txt");

    /*处理列名*/
    regex_st(str, VNAMESIZE);//调用正则匹配的自定义函数，处理列名
                             //列名列数会比实际列名列数多一位，最后一位列名是匹配后余剩的字符串，将赋值给strtoo,再删除掉
    mysqlsel.vregexsize = regexst.idtize;//把匹配到的列数赋值给列名的匹配字符数
    mysqlsel.vnamesize = regexst.idtize;//把匹配到的列数赋值给列名数
    mysqlsel.smcolsize = regexst.idtize - 1;//列数是列匹配符数减一
    mysqlsel.vregex = new string[mysqlsel.vregexsize];//new动态分配数组大小，这是存放列名匹配码的数组
    mysqlsel.vname = new string[mysqlsel.vregexsize];//new动态分配数组大小，这是存放列名的数组
    mysqlsel.vdatatype = new string[mysqlsel.vregexsize];

    i = 0;
    while (1)
    {
        if (i == regexst.idtize) break;
        mysqlsel.vregex[i] = regexst.t[i];//循环，把正则匹配到的字符一一存入数组（列名和列名匹配码）
        mysqlsel.vname[i] = regexst.s[i];
        //cout << "匹配到的列名匹配符:"<< mysqlsel.vregex[i] << endl;
        //cout <<"匹配到的列名：" << mysqlsel.vname[i] << endl;
        i++;
    }
    //cout << "mysqlsel.vname[mysqlsel.vnamesize-2]" << mysqlsel.vname[mysqlsel.vnamesize - 2] << endl;
    //cout << "mysqlsel.vname[mysqlsel.vnamesize - 1]" << mysqlsel.vname[mysqlsel.vnamesize - 1] << endl;
    strtoo = mysqlsel.vname[mysqlsel.vnamesize - 1];//把第一次匹配裁切的字符余下部分加入strtoo
    mysqlsel.vname[mysqlsel.vnamesize - 1] = "";//把列名最后一位清空
                                                //cout << strtoo << endl;
                                                //cout << "一次匹配裁切的字符:" << strtoo << endl;

                                                //打补丁，处理数据类型

    i = 0;
    strdatatype = "";
    while (1)
    {    //一套循环，把所有列名匹配码全拼接到strdatatype，作为预处理的数据
        if (i == mysqlsel.vregexsize) break;
        strdatatype += mysqlsel.vregex[i];
        i++;
    }
    //cout << strdatatype << endl;

    delete[] regexst.s;
    delete[] regexst.t;
    //if(regex_st(strdatatype, "[A-Z]+")<0)return -3;
    regex_st(strdatatype, "[A-Z]+");
    if (regexst.idtize != 0) {
        i = 0;
        while (1)
        {
            if (i == regexst.idtize) break;
            mysqlsel.vdatatype[i] = regexst.t[i];
            //cout << i << ":" << mysqlsel.vdatatype[i] << endl;
            i++;
        }

    }

    if (strtoo == "") {}
    else {

        /*处理行*/
        string * prowregex;//临时的行匹配符存放位置
        string * prow;//临时的行数据存放位置
        string * pcolregex;//临时的列匹配符存放位置
        string * pcol;//临时的列数据存放位置

                      //关闭正则的数组空间//为免内存泄漏，及各种因为不及时删除内存空间引起的报错，故每次调用函数前都需要运行相应的释放空间代码
        delete[] regexst.s;
        delete[] regexst.t;
        regex_st(strtoo, ROWSIZE);//正则匹配，匹配行
        if (regexst.idtize == 0) {}
        else {
            mysqlsel.smrowsize = regexst.idsize;//这是行数
            prowregex = new string[mysqlsel.smrowsize];//new自定义数组大小，不用多说了
            prow = new string[mysqlsel.smrowsize];
            pcolregex = new string[mysqlsel.vnamesize - 1];//这四个都是临时存放数据的数组，这个函数里用完之后delete[] prowregex;删除
            pcol = new string[mysqlsel.vnamesize - 1];

            mysqlsel.srow = new string[mysqlsel.smrowsize];//存放行匹配码的一维数组

            mysqlsel.scol = new string*[mysqlsel.smrowsize];//存放列匹配码的二维数组，行*列才是列匹配码的数量
            mysqlsel.sm = new string*[mysqlsel.smrowsize];//最终结果，这里存放的是真正的数据，行数*列数

            for (i = 0; i < mysqlsel.smrowsize; i++) {//里面作为判断值的是行数，i小于行数继续执行
                mysqlsel.scol[i] = new string[mysqlsel.vnamesize - 1];//同样，把行号数赋值给列匹配码数组的每个维
                mysqlsel.sm[i] = new string[mysqlsel.vnamesize - 1];//把行号数赋值给每个维
            }

            i = 0;
            while (1)
            {
                if (i == mysqlsel.smrowsize) break;
                prowregex[i] = regexst.t[i];//把每一行的匹配码字符串存入临时匹配码数组
                prow[i] = regexst.s[i];//把每一行的待处理字符串存入临时行字符串数组
                i++;
            }

            i = 0;

            while (1)
            {
                if (i == mysqlsel.smrowsize) break;
                strrowreg = prowregex[i];//把行匹配码存入strrowreg字符串变量，其实这一步有点多此一举，但是任性一把，懒得改了
                mysqlsel.srow[i] = strrowreg;//存入行匹配字符串
                strrow = prow[i];//同样，把待处理的每行字符串存入，strrow字符串变量
                                 //cout << strrow << endl;
                if (strrow != "") {
                    //关闭正则的数组
                    delete[] regexst.s;
                    delete[] regexst.t;
                    regex_st(strrow, COLSIZE);//循环里调用正则匹配函数，这就是前面为什么要把正则匹配后的结果->未完
                                              //->赶紧赋值给其他变量的原因，它会被覆盖掉
                                              //cout << mysqlsel.vnamesize-1 << endl;
                    j = 0;//循环里面给j每次循环赋值，不能放外面否则要报错
                    while (1)
                    {
                        if (j == (mysqlsel.vnamesize - 1)) break;
                        //cout << regexst.s[j] << "    ";
                        mysqlsel.scol[i][j] = regexst.t[j];//把正则匹配的列匹配码一一赋值给scol二维数组
                        mysqlsel.sm[i][j] = regexst.s[j];//把正则匹配到的数值一一赋值给sm二维数组
                        j++;
                    }
                }

                //cout << endl;
                i++;
            }
            //cout << j<< endl;
            //mysqlsel.smcolsize = j;

            //显示验证是否完成数据的传递//这是一个用来测试用的循环，懒得删留着就留着吧
            i = 0;
            while (1)
            {
                if (i == mysqlsel.smrowsize) break;
                //cout << mysqlsel.srow[i] << "===";
                j = 0;
                while (1)
                {
                    if (j == (mysqlsel.vnamesize - 1)) break;
                    //cout << mysqlsel.scol[i][j]<< " |---| ";
                    //cout << mysqlsel.sm[i][j] << " |---| ";//
                    j++;
                }
                //cout << endl;
                i++;
            }

            delete[] prowregex;
            delete[] prow;
            delete[] pcolregex;
            delete[] pcol;
        }
    }
    //删除正则匹配申请的空间
    delete[] regexst.s;
    delete[] regexst.t;

    return 1;
}
void delete_new_sel()
{

    //关闭查询的数组

    delete[] mysqlsel.vregex;
    delete[] mysqlsel.vdatatype;
    delete[] mysqlsel.vname;
    delete[] mysqlsel.srow;

    //-----
    int i;
    for (i = 0; i < mysqlsel.smrowsize; i++) {//里面作为判断值的是行数，i小于行数继续执行
        delete[] mysqlsel.scol[i];//把二维数组里的空间一一销毁
        delete[] mysqlsel.sm[i];
    }

    delete[] mysqlsel.scol;
    delete[] mysqlsel.sm;

}
//毫无意义的测试函数，无视即可
void srun()
{
    //一个没什么大用的测试函数，测试数据传输成功不成功
    cout << "srun对mysqlsel的测试：" << endl;
    cout << "列名匹配符数量：" << mysqlsel.vregexsize << endl;
    cout << "列名数量：" << mysqlsel.vnamesize << endl;
    cout << "行数：" << mysqlsel.smrowsize << endl;
    cout << "列数：" << mysqlsel.smcolsize << endl;
    int j, i = 0;
    while (1)
    {
        if (i == mysqlsel.vregexsize) break;
        cout << "列名匹配符" << i << ":" << mysqlsel.vregex[i] << "    ";
        cout << "列名" << i << ":" << mysqlsel.vname[i] << endl;
        i++;
    }
    i = 0;
    while (1)
    {
        if (i == mysqlsel.smcolsize)break;
        cout << "数据类型" << i << ":" << mysqlsel.vdatatype[i] << endl;
        i++;
    }
    cout << endl;
    i = 0;
    while (1)
    {
        if (i == mysqlsel.smrowsize) break;
        cout << "行匹配符" << i << ":" << mysqlsel.srow[i] << endl;
        j = 0;
        while (1)
        {
            if (j == (mysqlsel.vnamesize - 1)) break;
            cout << "列匹配符" << i << ":" << mysqlsel.scol[i][j] << "    ";
            cout << "正文数据" << i << ":" << mysqlsel.sm[i][j] << endl;//
            j++;
        }
        cout << endl;
        i++;
    }

}

/*增删改
分解开来，可以细分成几个函数，然后统一到一起再做成一个总函数
第一个函数
新建表（其实就是新建txt文件），新建表的时候，新建一个指定名字的新txt文档，位于根目录下db文件夹内
该表内，首次创建设置列名和列名匹配符，匹配符中间加数字从0开始
第二个函数
新建行，读取整个表，为了避免一些莫名其妙的错误没有组合数组，直接把读取出来的字符串拿来用，通过循环覆盖输入表内（一种简单粗暴的笨办法）
第三个函数
删除某行数据，读取整个表，把其中一行抽取出来全部注为NULL空值（不一定是NULL也可以是其他不易冲突的字符串），然后重新覆盖回文件，注不修改匹配码（假装删掉了，其实只是删掉了数值）
第四个函数
删除某个数值，更简单，读取整个表，把其中一个数值改成NULL空值，重新覆盖回去
第五个函数
修改一个数值，读取整个表，根据条件，找到对应数值然后修改它，再覆盖回去
第六个函数（感觉可以和第五个合并）
修改多个数值

注：有必要做个小函数，实现查询某个列名对应第几列的功能，或者根据条件，单条数值这个以后细化
万一读取一个表的时候，要读取另一个表，所以麻烦点，每次读取数据后，把数据转移到另一个临时数组（不知道结构体变量可不可以互相赋值）
*/

//以下是正式的函数

//新建表
int private_sql::new_table(string tabname, string  colname)
{

    int i, j;
    int size;
    char si[50];
    string *strregid, *colstr, *datatype, strcom;
    string strpath, strcolname;
    string regexstr, stra, strb, strc, strd;

    //准备地址
    strpath = "db\\" + tabname;
    strpath = strpath + ".txt";
    ///
    //这里判断要新建的表是否存在
    int outsize, pathlength;
    char *path;
    outsize = strpath.length();//strb是本自定义函数的表地址
    pathlength = outsize;
    path = new char[outsize + 1];
    strcpy(path, strpath.c_str());//C++中把string字符串转化为字符数组的代码
    path[pathlength] = '\0';

    ifstream fin(path);
    if (fin)
    {
        std::cout << "文件已存在！" << endl;
        fin.close();
        return -1;
    }
    ///
    //delete[] regexst.s;
    //delete[] regexst.t;
    //放弃数据类型的想法，统一CHAR，自动填充CHAR
    strcolname = "";
    regex_st(colname, "[ ]+");
    j = regexst.idsize;
    i = 0;
    while (1)
    {
        if (i == j) break;
        strcolname += "CHAR";
        strcolname += " ";
        strcolname += regexst.s[i];
        strcolname += " ";
        i++;
    }
    cout << strcolname << endl;
    ///
    delete[] regexst.s;
    delete[] regexst.t;
    regex_st(strcolname, "[ ]+");

    size = regexst.idsize / 2;
    //cout << size << endl;
    strregid = new string[size + 1];
    colstr = new string[size];
    datatype = new string[size];

    i = 0;
    while (1)
    {
        if (i == size) break;
        colstr[i] = regexst.s[i * 2 + 1];
        datatype[i] = regexst.s[i * 2];
        i++;
    }

    //准备要输入的匹配字符串，切割组装
    regexstr = "[\*]";
    delete[] regexst.s;
    delete[] regexst.t;
    regex_st(vnameregex, regexstr);
    stra = regexst.s[0];
    strb = regexst.s[1];
    //cout << regexst.s[0] << endl;
    //cout << regexst.s[1] << endl;
    //cout << regexst.t[0] << endl;

    i = 0;
    strcom = "";
    while (1) {
        if (i == (size + 1)) break;
        //这里处理列匹配字符
        sprintf(si, "%d", i);
        strc = si;
        if (i < size) {
            strd = stra + datatype[i];
            strc = strd + strc;
        }
        else {
            strc = stra + strc;
        }
        strc = strc + strb;
        //cout << strc << endl;
        strregid[i] = strc;
        strcom = strcom + strregid[i];
        //cout << strregid[i] << endl;
        if (i == size) {}
        else {
            //这里处理列名
            strcom = strcom + colstr[i];
        }

        //fputc(c, fo);//fputc()输出函数，把单个字符输出到文件中
        i++;
    }
    //cout << strpath << endl;
    //cout << strcom << endl;
    /*//本想在这里加一个补丁，初始化的时候默认添加第一行，但是想到会影响后面的数据
    i = 0;
    while (1)
    {
    if (i == size) break;
    strcom+=colregextop
    i++;
    }
    */
    //strgive(strpath,strcom);
    //代替strgive的补丁
    if (1)
    {
        int outsize, strlength, pathlength;
        FILE *fo;
        //cout << strpath << endl;
        char *path, *ch;
        outsize = strpath.length();
        pathlength = outsize;
        path = new char[outsize + 1];
        outsize = strcom.length();
        strlength = outsize;
        ch = new char[outsize + 1];

        strcpy(path, strpath.c_str());//C++中把string字符串转化为字符数组的代码
        path[pathlength] = '\0';
        strcpy(ch, strcom.c_str());
        ch[strlength] = '\0';
        //
        //sprintf(path, "%s", strpath.c_str());//string字符串赋值给字符数组需要在后面加.c_str()
        //cout << path << endl;
        //sprintf(ch, "%s", strcom.c_str());

        fo = fopen(path, "w");
        if (fo == NULL) {//rb读取为二进制
            printf("该表不存在!");
        }

        fputs(ch, fo);//向文本文档输入字符串，用fputs()

        fclose(fo);
        delete[] path;
        delete[] ch;

    }

    //delete[] colname;
    delete[] strregid;
    delete[] regexst.s;
    delete[] regexst.t;
    return 1;
}

//新建行
int private_sql::new_row(string tabname, string sqlstr)
{
    //一行数据由，行匹配码（当前行+1），列匹配码，每列一个与列标保持一致，数据组成（没有数据的以NULL表示）
    int colid;
    ///
    //这里判断要新建列的表是否存在
    int coutsize, cpathlength;
    FILE *cfi;
    string strpath;
    char *cpath;
    strpath = "db\\" + tabname;
    strpath = strpath + ".txt";
    coutsize = strpath.length();
    cpathlength = coutsize;
    cpath = new char[coutsize + 1];
    strcpy(cpath, strpath.c_str());//C++中把string字符串转化为字符数组的代码
    cpath[cpathlength] = '\0';
    cfi = fopen(cpath, "r");
    if (cfi == NULL) {//rb读取为二进制
        cout << "该表不存在!" << endl;
        return -1;
    }
    fclose(cfi);
    delete[] cpath;
    ///

    int i, j, z;
    string *newdataname, *newsm;
    string newstrdatatype, newstrsm, strcom, stra, strb;
    i = mysql_sel(tabname);
    //cout << "mysql_sel()的返回值："<<i <<endl ;
    i = 0;
    while (1)
    {
        if (i == mysqlsel.vnamesize) break;
        if (mysqlsel.vname[i] == "id") {
            colid = i;
        }
        i++;
    }

    regex_st(sqlstr, "[ ]+");
    //cout << regexst.idsize << endl;
    //if ((regexst.idsize / 2) != mysqlsel.smcolsize) return -1;//判断输入的字符数量是否符合规则
    if (regexst.idsize <= 1) return -1;
    if (regexst.idsize % 2 == 0) {}
    else return -2;
    newdataname = new string[mysqlsel.smcolsize + 1];
    newsm = new string[mysqlsel.smcolsize + 1];
    //cout << "列数：" << mysqlsel.smcolsize << endl;

    //校验输入的列名数量是否有超
    if ((regexst.idsize / 2) > mysqlsel.smcolsize) return -2;
    //校验输入的列名是否有重复
    i = 0;
    z = 0;
    while (1)
    {

        if (i == (regexst.idsize / 2)) break;
        j = 0;
        while (1)
        {
            if (j == (regexst.idsize / 2)) break