Qt数字与字母混合的字符串自增

Qt实现数字和字母混合的字符串自增

有时候想要一串字母和数字混合的字符串能够以1或者n的增量不断增加，下面代码可以实现此功能，如果有bug，欢迎指正:

#define isNum(str)                  QRegExp(QString("[0-9]{%1}"   ).arg(str.size())).exactMatch(str)
#define isLower(str)                QRegExp(QString("[a-z]{%1}"   ).arg(str.size())).exactMatch(str)
#define isUpper(str)                QRegExp(QString("[A-Z]{%1}"   ).arg(str.size())).exactMatch(str)
#define isNumAndLower(str)          QRegExp(QString("[0-9a-z]{%1}").arg(str.size())).exactMatch(str)
#define isNumAndUpper(str)          QRegExp(QString("[0-9A-Z]{%1}").arg(str.size())).exactMatch(str)
#define isLowerAndUpper(str)        QRegExp(QString("[A-Za-z]{%1}").arg(str.size())).exactMatch(str)
#define isNumAndLowerAndUpper(str)  QRegExp(QString("[0-9A-Za-z]{%1}").arg(str.size())).exactMatch(str)

enum IncreasingSymbol {
    NoSymbol = 0,           //没有自增字符
    Number = 1,             //数字字符
    LowerChar = 2,          //小写字母
    UpperChar = 3,          //大写字母
    NumAndLowerChar = 4,    //数+小
    NumAndUpperChar = 5,    //数+大
    LowerAndUpperChar = 6,  //小+大
    NumAndLowAndUpChar = 7, //数+小+大
};


/// \brief increment    输入混合字符串，返回自增后的字符串
/// \param sBegin       起始字符串如: ABCDabcd1234
/// \param sEnd         结束字符串如: ABCDabce1234
/// \param sRange       自增包含符号:
///                     数字:012346789
///                     小写字母:abcdefghijklmnopqrstuvwxyz
///                     大写字母:ABCDEFGHIJKLMNOPQRSTUVWXYZ
///                     数字+大写:0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
///                     数字+小写:0123456789abcdefghijklmnopqrstuvwxyz
///                     数字+小写+大写:0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
/// \param iIncrease    自增量(1~9)
/// \param iType        自增类型见枚举 IncreasingSymbol
/// \return

QString increment(QString sBegin, QString sEnd, QString sRange, int iIncrease, int iType) {
    //1. 判断各数据是否合法
    if (sBegin.isEmpty() || sEnd.isEmpty() || sRange.isEmpty()) return "";
    if (sBegin >= sEnd) return sEnd;

    //2. 获取数字/小写字母/大写字母 的开始字符和结束字符
    char beginNum, beginLower, beginUpper, endNum, endLower, endUpper;
    findBeginAndEndChar(sRange, beginNum, beginLower, beginUpper, endNum, endLower, endUpper);

    //3. 进行累加操作
    int iSize = sBegin.size();
    while (iSize > 0) {
        //3.1 获取最后一个字符进行累加, (目前只做一位的累加)
        char last = sBegin[iSize - 1].toLatin1();
        last += ((iSize == sBegin.size()) ? iIncrease : 1);

        switch (iType) {
        //3.2 只有数字的累加
        case Number: {
            //3.2.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while(last >= beginNum && last < endNum && !sRange.contains(last)) {
                last++;
            }

            //3.2.2 判断最后一位累加后是否大于数字结束符号，如果大于，本位取差值，并且进位
            //      如果不大于，则直接返回累加结果
            if (last > endNum) {
                char tmp = last - endNum + beginNum - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }
        } break;

        //3.3 只有小写字母的累加
        case LowerChar: {
            //3.3.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while(last >= beginLower && last < endLower && !sRange.contains(last)) {
                last++;
            }

            //3.3.2 判断最后一位累加后是否大于大写字母结束符号，如果大于，本位取差值，并且进位
            //      如果不大于，则直接返回累加结果
            if (last > endLower) {
                char tmp = last - endLower + beginLower - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }
        } break;

        //3.4 只有小写字母的累加
        case UpperChar: {
            //3.4.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while(last >= beginUpper && last < endUpper && !sRange.contains(last)) {
                last++;
            }

            //3.4.2 判断最后一位累加后是否大于小写字母结束符号，如果大于，本位取差值，并且进位
            //      如果不大于，则直接返回累加结果
            if (last > endUpper) {
                char tmp = last - endUpper + beginUpper - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }
        } break;

        //3.5 只有数字和小写字母的累加
        case NumAndLowerChar: {
            //3.5.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while((last >= beginNum && last < endNum && !sRange.contains(last))
                  || (last >= beginLower && last < endLower && !sRange.contains(last))) {
                last++;
            }

            //3.5.2 判断最后一位累加后是否大于数字结束符，如果大于则延续到小写字母起始值，
            //      判断最后一位累加后是否大于小写字母结束符，如果大于则延续到数字起始值，并且进位
            //      否则返回累加得到的结果
            if (last >= beginNum && last > endNum && last < beginLower) {   //到达数字结尾符
                char tmp = last - endNum + beginLower - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                return sBegin >= sEnd ? sEnd : sBegin;
            } else if (last > endLower) {   //到达小写字母结尾符
                char tmp = last - endLower + beginNum - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }
        } break;

        //3.6 只有数字和大写字母的累加
        case NumAndUpperChar: {
            //3.6.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while((last >= beginNum && last < endNum && !sRange.contains(last))
                  || (last >= beginUpper && last < endUpper && !sRange.contains(last))) {
                last++;
            }

            //3.6.2 判断最后一位累加后是否大于数字结束符，如果大于则延续到大写字母起始值，
            //      判断最后一位累加后是否大于大写字母结束符，如果大于则延续到数字起始值，并且进位
            //      否则返回累加得到的结果
            if (last > endNum && last < beginUpper) {   //到达数字结尾符
                char tmp = last - endNum + beginUpper - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                return sBegin >= sEnd ? sEnd : sBegin;
            } else if (last > endUpper) {   //到达大写字母结尾符
                char tmp = last - endUpper + beginNum - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }
        } break;

        //3.7 只有小写字母和大写字母的累加
        case LowerAndUpperChar: {
            //3.7.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while((last >= beginUpper && last < endUpper && !sRange.contains(last))
                  || (last >= beginLower && last < endLower && !sRange.contains(last))) {
                last++;
            }

            //3.7.2 判断最后一位累加后是否大于大写字母结束符，如果大于则延续到小写字母起始值，
            //      判断最后一位累加后是否大于小写字母结束符，如果大于则延续到大写字母起始值，并且进位
            //      否则返回累加得到的结果
            if (last > endUpper && last < beginLower) {   //到达大写字母结尾符
                char tmp = last - endUpper + beginLower - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                return sBegin >= sEnd ? sEnd : sBegin;
            } else if (last > endLower) {   //到达小写字母结尾符
                char tmp = last - endLower + beginUpper - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }
        } break;

        //3.8 数字和小写字母和大写字母的累加
        case NumAndLowAndUpChar: {
            //3.8.1 查找在递增范围符号中是否存在该字符，不存在则继续往后找
            while ((last >= beginNum && last < endNum && !sRange.contains(last))
                || (last >= beginUpper && last < endUpper && !sRange.contains(last))
                || (last >= beginLower && last < endLower && !sRange.contains(last))) {
                last++;
            }

            //3.8.2 判断最后一位累加后是否大于数字结束符，如果大于则延续到大写字母起始值，
            //      判断最后一位累加后是否大于大写字母结束符，如果大于则延续到小写字母起始值，
            //      判断最后一位累加后是否大于小写字母结束符，如果大于则延续到数字起始值，并且进位
            //      否则返回累加得到的结果
            if (last > endNum && last < beginUpper) {   //到达数字结尾符
                char tmp = last - endNum + beginUpper - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                return sBegin >= sEnd ? sEnd : sBegin;
            } else if (last > endUpper && last < beginLower) {   //到达大写字母结尾符
                char tmp = last - endUpper + beginLower - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                return sBegin >= sEnd ? sEnd : sBegin;
            } else if (last > endLower) {   //到达小写字母结尾符
                char tmp = last - endLower + beginNum - 1;
                sBegin[iSize - 1] = tmp;    //本位取差值
                iSize--;    //进位继续计算
            } else {
                sBegin[iSize - 1] = last;   //累加得到的结果
                return sBegin >= sEnd ? sEnd : sBegin;
            }

        } break;
        default: break;
        }
    }

    return sBegin >= sEnd ? sEnd : sBegin;
}

/
/// \brief findBeginChar    输入字符自增包含符号，查找起始字符
/// \param begin    起始字符,如'0'
/// \param end      结束字符,如'9'
/// \param range    自增包含符号,如:0123456789...
/// \param ret      输出参数,查找到的结果
/
void findBeginChar(char begin, char end, QString range, char &ret) {
    //从begin到end寻找起始值
    while (begin <= end) {
        if (range.contains(begin)) {
            ret = begin;
            break;
        }
        begin++;
    }
}

/
/// \brief findEndChar  输入字符自增包含符号，查找结束字符
/// \param begin        起始字符,如'0'
/// \param end          结束字符,如'9'
/// \param range        自增包含符号,如:0123456789...
/// \param ret          输出参数,查找到的结果
///
void findEndChar(char begin, char end, QString range, char &ret) {
    //从end到begin寻找结束值
    while (end >= begin) {
        if (range.contains(end)) {
            ret = end;
            break;
        }
        end--;
    }
}

/
/// \brief findBeginAndEndChar   输入字符自增包含符号，查找数字/小写字母/大写字母的起始/结束字符
/// \param sRange           自增包含符号,如:0123456789...
/// \param beginNum         输出参数，数字起始字符
/// \param beginLower       输出参数，小写起始字符
/// \param beginUpper       输出参数，大写起始字符
/// \param endNum           输出参数，数字结束字符
/// \param endLower         输出参数，小写结束字符
/// \param endUpper         输出参数，大写结束字符

void findBeginAndEndChar(QString sRange, char &beginNum, char &beginLower
                    , char &beginUpper, char &endNum, char &endLower, char &endUpper) {
    beginNum = beginLower = beginUpper = '#';

    //1. 查找数字的起始和结束字符
    findBeginChar('0', '9', sRange, beginNum);
    findEndChar('0', '9', sRange, endNum);

    //2. 查找大写字母的起始和结束字符
    findBeginChar('A', 'Z', sRange, beginUpper);
    findEndChar('A', 'Z', sRange, endUpper);

    //3. 查找小写字母的起始和结束字符
    findBeginChar('a', 'z', sRange, beginLower);
    findEndChar('a', 'z', sRange, endLower);
}

推荐一个免费分享程序得网站：https://www.chengxuunion.com/