C++ 常用自定义函数

---

 

1 字符串分割

 

输入 : 一个指定分隔符的字符串
输出 : 被分割符分割的字符串

coding

void string_split(const string &str, const char splitChar, vector<string> &vecStr)
{
    int len = str.length();

    if (len == 0)
    {
        return;
    }

    int index = str[0] == splitChar ? 1 : 0;
    int startIndex = index;

    for (; index < len; index++)
    {
        if (str[index] == splitChar)
        {
            vecStr.push_back(str.substr(startIndex, index - startIndex));
            startIndex = index + 1;
        }

        if (index == len - 1 && str[index] != splitChar)
        {
            vecStr.push_back(str.substr(startIndex, index - startIndex));
        }
    }
}

void string_split_test()
{
    string str = "|abc|def|ghi|";
    vector<string> vecStr;
    string_split(str, '|', vecStr);

    vector<string>::const_iterator iter = vecStr.begin();
    while (iter != vecStr.end())
    {
        cout << *iter++ << endl;
    }
}

// 将字符串 strText按strSplit分割 
static int32 split_valToList(const string &strText,
                             const string &strSplit,
                             std::set<int32> &listVal,
                             const bool isTrim = true)
{
    if (strText.empty() || strSplit.empty())
    {
        return -1;
    }

    std::string::size_type splitLen = strSplit.length();
    std::string::size_type startIndex = 0;
    // 第一个就是分割符 则跳过
    if (strText.find(strSplit, 0) == 0)
    {
        startIndex += splitLen;
    }

    std::string::size_type endIndex = 0;
    std::string splitStr;
    std::string::size_type iVal;
    while ((endIndex = strText.find(strSplit, startIndex)) != std::string::npos)
    {
        splitStr = strText.substr(startIndex, endIndex - startIndex);
        if (isTrim)
            splitStr = trimBothExt(splitStr);
        iVal = atoi(splitStr.c_str());
        listVal.insert(iVal);
        startIndex = endIndex + splitLen;
    }
    // startIndex没有越界  说明字符串不是以strSplit结尾
    // 如果字符串以strSplit结尾 则在while循环中已经完成了截取
    if (startIndex < strText.length())
    {
        splitStr = strText.substr(startIndex);
        if (isTrim)
            splitStr = trimBothExt(splitStr);
        iVal = atoi(splitStr.c_str());
        listVal.insert(iVal);
    }
    return 0;
}

 

---

 

2 秒数转换成时间

 

输入 : 距离1970年1月1日的毫秒数
输出 : 年月日

const int32 month_days[2][13] =
    {
        {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, // 平年每月天数
        {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}  // 闰年每月天数

};

static int32 getDate(int32 days)
{
    int32 year = 1970;
    if (days > 14610)
    {
        // 2010年距离1970年 14610天
        days -= 14610;
        year = 2010;
    }
    else if (days > 10957)
    {
        // 2000年距离 1970年 10957天
        days -= 10957;
        year = 2000;
    }

    // 年份分摊天数 够一年天数 则年份 +1 天数 - 一年天数
    while (year <= 2100)
    {
        if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) // 闰年
        {
            // 剩余天数超过 366 天
            if (days > 366)
            {
                days -= 366;
                year++;
            }
            else
            {
                break;
            }
        }
        else
        {
            if (days > 365)
            {
                days -= 365;
                year++;
            }
            else
            {
                break;
            }
        }
    }
    // 因为传进来的天数少一天 因此加 1
    //days += 1;
    
    int32 mon = 1;

    int flag = 0; // 平年标记
    if (year % 4 == 0 && year % 400 != 0 || year % 400 == 0)
    {
        flag = 1; // 闰年标记
    }
    
    // 计算月份数
    while (mon <= 12)
    {
        if (days > month_days[flag][mon])
        {
            days -= month_days[flag][mon];
            ++mon;
        }
        else
        {
           break; 
        }
    }

    cout << "mon" << mon << endl;
    return year * 10000 + mon * 100 + days;
}

static int64 timeToDateTime_int64(const string &strTime)
{
    double time_zone = 8;
    int64 time = atoll(strTime.c_str());
    int64 tmp_time = time + int32(time_zone * 3600);
    // 当前时间距离1970年有多少天
    int32 days = tmp_time / 86400;
    // 转换成日期
    int32 date = getDate(days + 1);
    int32 sec = tmp_time - days * 86400;
    int32 hour = sec / 3600;
    int32 min = (sec - hour * 3600) / 60;
    sec -= (hour * 3600 + min * 60);

    return date * 1000000LL + hour * 10000LL + min * 100LL + sec;
}

 

---

 

3 子字符串出现的位置

 

输入 : 字符串1,字符串2
输出 : 字符串2在字符串1中出现的位置,如果没有出现过 则输出 -1

 

暴力匹配
 

coding

/**
 * @name:
 * @msg: 字符串s2 在字符串s1 中出现的位置 暴力匹配
 * @param {string&} s1
 * @param {string&} s2
 * @return {*}
 */
static int32 get_index(const string &s1, const string &s2)
{
    if (&s1 == NULL || &s2 == NULL || s2.length() < 1 && s1.length() < s2.length())
    {
        return -1;
    }

    int32 L1 = s1.length();
    int32 L2 = s2.length();
    int32 i1 = 0;
    int32 i2 = 0;
    int32 retIndex = 0; // 匹配s1开始的位置

    while (i1 < L1 && i2 < L2)
    {
        if (s1[i1] == s2[i2])
        {
            ++i1;
            ++i2;
        }
        else // 以retIndex开头是匹配不出来的 要从 retIndex的下一个开始
        {
            i1 = ++retIndex;
            i2 = 0;
        }
    }

    return i2 == L2 ? retIndex : -1;
}

 

KMP算法

 
coding

/**
 * @name:
 * @msg: kmp算法获取前缀数组
 * @param {string&} str
 * @param {int} nextArr
 * @return {*}
 */
static void getNextArr(const string &str, int nextArr[])
{
    if (&str == NULL)
    {
        return;
    }

    int32 strLen = str.length();

    if (strLen == 0)
    {
        return;
    }

    if (strLen == 1)
    {
        nextArr[0] = -1;
        return;
    }

    nextArr[0] = -1;
    nextArr[1] = 0;

    int32 index = 2;
    int preIndex = 0;

    while (index < strLen)
    {
        if (str[index - 1] == str[preIndex])
        {
            nextArr[index++] = preIndex++;
        }
        else if (preIndex > 0)
        {
            preIndex = nextArr[preIndex];
        }
        else
        {
            nextArr[index++] = -1;
        }
    }
}

/**
 * @name: 
 * @msg: 返回字符串 s2 在 s1中出现的位置 如果没有s1没有包含s2 返回 -1
 * @param {string} &s1
 * @param {string} &s2
 * @return {*}
 */
static int32 getIndexKmp(const string &s1, const string &s2)
{
    if (&s1 == NULL || &s2 == NULL || s2.length() < 1 || s1.length() < s2.length())
    {
        return -1;
    }

    int32 *nextArr = new int[s2.length()];
    getNextArr(s2, nextArr);

    int32 i1 = 0;
    int32 i2 = 0;

    while(i1 < s1.length() && i2 < s2.length())
    {
        if(s1[i1] == s2[i2])
        {
            ++i1;
            ++i2;
        }
        else if (nextArr[i2] == -1)
        {
            i1++;
        }
        else
        {
            i2 = nextArr[i2];
        }
    }
    delete[] nextArr;
    return i2 == s2.length() ? i1 - s2.length() : -1;
}

 

---

 

4 字符串转换成小写

 

输入 : 还有小写字母的字符串
输出 : 都是大写字母的字符串

 

static void to_lower(string &s)
{
    if (&s == NULL || s.length() < 1)
        return;
    for (int32 index = 0; index < s.length(); index++)
    {
        if (s[index] >= 'A' && s[index] <= 'Z')
        {
            s[index] += 32;
        }
    }
}

 

---

 

5 字符串转换成大写

 

输入 : 还有小写字母的字符串
输出 : 都是大写字母的字符串
 

static void to_upper(string &s)
{
    if (&s == NULL || s.length() < 1)
    {
        return;
    }
    for (int32 index = 0; index < s.length(); index++)
    {
        if (s[index] >= 'a' && s[index] <= 'z')
        {
            s[index] -= 32;
        }
    }
}

 

---

 

6 去掉字符串两边的空格

 

/**
 * @name:
 * @msg: 去除字符串两边的空格
 * @param {string&} str
 * @return {*}
 */
static void trimBoth(string &str)
{
    if (str.length() == 0 || &str == NULL)
    {
        return;
    }

    int32 leftIndex = 0;
    int32 rightIndex = str.length() - 1;
    for (; str[leftIndex] == ' ' && leftIndex < str.length(); leftIndex++)
    {
    }

    for (; rightIndex > -1 && str[rightIndex] == ' '; rightIndex--)
    {
    }
    if (leftIndex >= rightIndex)
    {
        str = "";
        return;
    }
    str = str.substr(leftIndex, rightIndex - leftIndex + 1);
}

// 另外一种写法
static std::string trimBothExt(const std::string &str)
{
    // 查找到第一个不是空格的位置
    std::string::size_type startPos = str.find_first_not_of(' ');
    // 没有空格则直接返回
    if (startPos == std::string::npos)
    {
        return str;
    }

    std::string::size_type endPos = str.find_last_not_of(' ');
    if (endPos != std::string::npos)
    {
        return str.substr(startPos, endPos - startPos + 1);
    }
    // 字符串后面没有空格
    return str.substr(startPos);
}

 

---

 

7 数字转换成字符串

 

template <typename T>
static void Swap_(T *t1, T *t2)
{
    T temp = *t1;
    *t1 = *t2;
    *t2 = temp;
}

static char *itoa_(int64 num, char *pstr, int base = 10)
{
    const char charTable[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    int index = 0;
    if (num == 0)
    {
        pstr[index++] = '0';
        pstr[index] = '\0';
        return pstr;
    }

    if (num < 0)
    {
        pstr[index++] = '-';
        num = -num;
    }

    while (num)
    {
        pstr[index++] = charTable[num % base];
        num /= base;
    }
    pstr[index--] = '\0';
    int startIndex = pstr[0] == '-' ? 1 : 0;
    while (startIndex < index)
    {
        Swap_(&pstr[startIndex++], &pstr[index--]);
    }
    return pstr;
}

 

---

 

8 字符串转换成数字

 

static int64 atoi_(const char *str)
{
    if (str == NULL || strlen(str) == 0 || *str == '\0')
    {
        return 0;
    }
    // 跳过所有空格
    int index = 0;
    for (; index < strlen(str) && *str == ' '; index++)
    {
        str++;
    }

    if (index == strlen(str))
    {
        return 0;
    }

    int flag = 1;
    if (*str == '-')
    {
        flag = -1;
        str++;
    }
    long long llRet = 0;
    while (*str)
    {
        if (*str >= '0' && *str <= '9')
        {
            llRet = llRet * 10 + (*str - '0') * flag;
            cout << "[DEBUG] --llRet : " << llRet << endl;
            if (llRet > LLONG_MAX)
            {
                llRet = LLONG_MAX;
            }
            else if (llRet < LLONG_MIN)
            {
                llRet = LLONG_MIN;
            }
        }
        else
        {
            break;
        }
        str++;
    }
    return llRet;
}