STL字符串常用方法扩展

前言

STL作为一个标准模版库，很多容器和算法都是很实用的，接口也相对比较友好，而且在实现上也比较轻量级。相对boost来说，要轻量得多，相对loki来说，使用的模版语法不会那么晦涩难懂，基本还是能看的，相对ATL来说，功能要更通用。

但是STL里面的string，使用过的都知道，很多常用方法没有内置，导致每每使用都会想起CString和AtlString的强大来，而混用这些字符串对象，对于一个有洁癖的程序员来说，往往是很不爽的。在工作过程中，因为有些场景不能使用CString和AtlString，针对STL的string，通过基本函数的方式，实现（积累）了一些常用用法，这里简单分享给大家。

常用方法集

大小写转换

Trim

移除子串

替换子串

StartWith & EndWith

字符串反转

容器字符串连接

字符串分割

代码

/* -------------------------------------------------------------------------
//  文件名      ：  QMStlStrUtil.h
//  创建者      ：  magic
//  创建时间    ：  2015/9/1 17:09:32
//  功能描述    ：  STL字符串通用方法（大小写，trim，替换，删除，连接，分割，反转等）
//
//  $Id: $
// -----------------------------------------------------------------------*/
#ifndef __QMSTLSTRUTIL_H__
#define __QMSTLSTRUTIL_H__

#include <string>
#include <numeric>
#include <algorithm>
// -------------------------------------------------------------------------

namespace Util
{

namespace StlStr
{

//////////////////////////////////////////////////////////////////////////
// 字符串大小写转换
//
// -------------------------------------------------------------------------
// 函数     : ToUpperT
// 功能     : 转换成大写
// 返回值   : inline void
// 参数     : std::basic_string<CharT>& s
// 附注     :
// -------------------------------------------------------------------------
template<typename CharT>
inline void ToUpper(std::basic_string<CharT>& s);

template<>
inline void ToUpper(std::basic_string<char>& s)
{
    transform(s.begin(), s.end(), s.begin(), toupper);
}

template<>
inline void ToUpper(std::basic_string<wchar_t>& s)
{
    transform(s.begin(), s.end(), s.begin(), toupper);
}

// -------------------------------------------------------------------------
// 函数     : ToUpperT
// 功能     : 转换成大写
// 返回值   : inline std::basic_string<CharT>
// 参数     : const std::basic_string<CharT>& s
// 附注     : 重载版本，参数为const
// -------------------------------------------------------------------------
template<typename CharT>
inline std::basic_string<CharT> ToUpperT(const std::basic_string<CharT>& s)
{
    std::basic_string<CharT> str(s);
    transform(str.begin(), str.end(), str.begin(), toupper);
    return str;
}

// -------------------------------------------------------------------------
// 函数     : ToLowerT
// 功能     : 转换成小写
// 返回值   : inline void
// 参数     : std::basic_string<CharT>& s
// 附注     :
// -------------------------------------------------------------------------
template<typename CharT>
inline void ToLower(std::basic_string<CharT>& s);

template<>
inline void ToLower(std::basic_string<char>& s)
{
    transform(s.begin(), s.end(), s.begin(), tolower);
}

template<>
inline void ToLower(std::basic_string<wchar_t>& s)
{
    transform(s.begin(), s.end(), s.begin(), tolower);
}

// -------------------------------------------------------------------------
// 函数     : ToLowerT
// 功能     : 转换成小写
// 返回值   : inline std::basic_string<CharT>
// 参数     : const std::basic_string<CharT>& s
// 附注     : 重载版本，参数为const
// -------------------------------------------------------------------------
template<typename CharT>
inline std::basic_string<CharT> ToLowerT(const std::basic_string<CharT>& s)
{
    std::basic_string<CharT> str(s);
    transform(str.begin(), str.end(), str.begin(), tolower);
    return str;
}

//////////////////////////////////////////////////////////////////////////
// 移除字符串前后空白符
//
//////////////////////////////////////////////////////////////////////////
// 空白符枚举
//
// "\0" - NULL
// "\t" - 制表符
// "\n" - 换行
// "\x0B" - 垂直制表符
// "\r" - 回车
// " " - 空格
//
//////////////////////////////////////////////////////////////////////////
// TrimLeft
//
template<typename CharT>
inline void TrimLeft(std::basic_string<CharT>& s);

template<>
inline void TrimLeft(std::basic_string<char>& s)
{
    const char* p = " \t\n\r\x0b";
    s.erase(0, s.find_first_not_of(p));
}

template<>
inline void TrimLeft(std::basic_string<wchar_t>& s)
{
    const wchar_t* p = L" \t\n\r\x0b";
    s.erase(0, s.find_first_not_of(p));
}

template<typename CharT>
inline void TrimLeftEx(std::basic_string<CharT>& s, const std::basic_string<CharT>& charlist);

template<>
inline void TrimLeftEx(std::basic_string<char>& s, const std::basic_string<char>& charlist)
{
    s.erase(0, s.find_first_not_of(charlist));
}

template<>
inline void TrimLeftEx(std::basic_string<wchar_t> &s, const std::basic_string<wchar_t>& charlist)
{
    s.erase(0, s.find_first_not_of(charlist));
}

//////////////////////////////////////////////////////////////////////////
// TrimRight
//
template<typename CharT>
inline void TrimRight(std::basic_string<CharT>& s);

template<>
inline void TrimRight(std::basic_string<char>& s)
{
    const char* p = " \t\n\r\x0b";
    s.erase(s.find_last_not_of(p) + 1);
}

template<>
inline void TrimRight(std::basic_string<wchar_t>& s)
{
    const wchar_t* p = L" \t\n\r\x0b";
    s.erase(s.find_last_not_of(p) + 1);
}

template<typename CharT>
inline void TrimRightEx(std::basic_string<CharT>& s, const std::basic_string<CharT>& charlist);

template<>
inline void TrimRightEx(std::basic_string<char>& s, const std::basic_string<char>& charlist)
{
    s.erase(s.find_last_not_of(charlist) + 1);
}

template<>
inline void TrimRightEx(std::basic_string<wchar_t> &s, const std::basic_string<wchar_t>& charlist)
{
    s.erase(s.find_last_not_of(charlist) + 1);
}

//////////////////////////////////////////////////////////////////////////
// Trim
//
template<typename CharT>
inline void Trim(std::basic_string<CharT>& s);

template<>
inline void Trim(std::basic_string<char>& s)
{
    const char* p = " \t\n\r\x0b";
    s.erase(0, s.find_first_not_of(p));
    s.erase(s.find_last_not_of(p) + 1);
}

template<>
inline void Trim(std::basic_string<wchar_t>& s)
{
    const wchar_t* p = L" \t\n\r\x0b";
    s.erase(0, s.find_first_not_of(p));
    s.erase(s.find_last_not_of(p) + 1);
}

template<typename CharT>
inline void TrimEx(std::basic_string<CharT>& s, const std::basic_string<CharT>& charlist);

template<>
inline void TrimEx(std::basic_string<char>& s, const std::basic_string<char>& charlist)
{
    s.erase(0, s.find_first_not_of(charlist));
    s.erase(s.find_last_not_of(charlist) + 1);
}

template<>
inline void TrimEx(std::basic_string<wchar_t> &s, const std::basic_string<wchar_t>& charlist)
{
    s.erase(0, s.find_first_not_of(charlist));
    s.erase(s.find_last_not_of(charlist) + 1);
}

//////////////////////////////////////////////////////////////////////////
// Erase 删除字符串里面的某个特殊字符
// add by magic 2015/9/7 17:43:10
//
template<typename CharT>
inline void Erase(std::basic_string<CharT>& s, const CharT& chErase);

template<>
inline void Erase(std::basic_string<char>& s, const char& chErase);

template<>
inline void Erase(std::basic_string<wchar_t>& s, const wchar_t& chErase);

template<typename CharT>
void Erase(std::basic_string<CharT>& s, const std::basic_string<CharT>& strErase);

template<>
void Erase(std::basic_string<char>& s, const std::basic_string<char>& strErase);

template<>
void Erase(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& strErase);

//////////////////////////////////////////////////////////////////////////
// Replace 替换子串为另外的子串
//
template<typename CharT>
void Replace(std::basic_string<CharT>& s, const std::basic_string<CharT>& src, const std::basic_string<CharT>& dest);

template<>
void Replace(std::basic_string<char>& s, const std::basic_string<char>& src, const std::basic_string<char>& dest);

template<>
void Replace(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& src, const std::basic_string<wchar_t>& dest);

//////////////////////////////////////////////////////////////////////////
// StartWith & EndWith
//
template<typename CharT>
inline bool StartWith(std::basic_string<CharT>& s, const std::basic_string<CharT>& head);

template<>
inline bool StartWith(std::basic_string<char>& s, const std::basic_string<char>& head)
{
    if (s.size() < head.size())
        return false;

    return (0 == s.compare(0, head.size(), head));
}

template<>
inline bool StartWith(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& head)
{
    if (s.size() < head.size())
        return false;

    return (0 == s.compare(0, head.size(), head));
}

template<typename CharT>
inline bool EndWith(std::basic_string<CharT>& s, const std::basic_string<CharT>& tail);

template<typename CharT>
inline bool EndWith(std::basic_string<char>& s, const std::basic_string<char>& tail)
{
    if (s.size() < tail.size())
        return false;

    return (0 == s.compare(s.size() - tail.size(), tail.size(), tail));
}

template<typename CharT>
inline bool EndWith(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& tail)
{
    if (s.size() < tail.size())
        return false;

    return (0 == s.compare(s.size() - tail.size(), tail.size(), tail));
}

template<typename CharT>
bool StartWithI(std::basic_string<CharT>& s, const std::basic_string<CharT>& head);

template<>
bool StartWithI(std::basic_string<char>& s, const std::basic_string<char>& head);

template<>
bool StartWithI(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& head);

template<typename CharT>
bool EndWithI(std::basic_string<CharT>& s, const std::basic_string<CharT>& tail);

template<>
bool EndWithI(std::basic_string<char>& s, const std::basic_string<char>& tail);

template<>
bool EndWithI(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& tail);

//////////////////////////////////////////////////////////////////////////
// 字符串反转
//
template<typename CharT>
inline void Reverse(std::basic_string<CharT>& s);

template<>
inline void Reverse(std::basic_string<char>& s)
{
    std::reverse(s.begin(), s.end());
}

template<>
inline void Reverse(std::basic_string<wchar_t>& s)
{
    std::reverse(s.begin(), s.end());
}

template<typename CharT>
inline std::basic_string<CharT> Reverse(const std::basic_string<CharT>& s);

template<>
inline std::basic_string<char> Reverse(const std::basic_string<char>& s)
{
    std::basic_string<char> _s(s.rbegin(), s.rend());
    return _s;
}

template<>
inline std::basic_string<wchar_t> Reverse(const std::basic_string<wchar_t>& s)
{
    std::basic_string<wchar_t> _s(s.rbegin(), s.rend());
    return _s;
}

//////////////////////////////////////////////////////////////////////////
// 容器字符串连接
//
template<typename CharT, template<typename S, typename Q = std::allocator<S> > class Container>
inline std::basic_string<CharT> Join(const Container<std::basic_string<CharT> >& c);

template<template<typename S, typename Q = std::allocator<S> > class Container>
inline std::basic_string<char> Join(const Container<std::basic_string<char> >& c)
{
    return std::accumulate(c.begin(), c.end(), std::basic_string<char>());
}

template<template<typename S, typename Q = std::allocator<S> > class Container>
inline std::basic_string<wchar_t> Join(const Container<std::basic_string<wchar_t> >& c)
{
    return std::accumulate(c.begin(), c.end(), std::basic_string<wchar_t>());
}

//////////////////////////////////////////////////////////////////////////
// 字符串分割
//
// -------------------------------------------------------------------------
// 函数     : Split
// 功能     : 分割STL标准字符串
// 返回值   : void
// 参数     : Container<std::basic_string<CharT> >& v 存放分割结果
// 参数     : const std::basic_string<CharT>& s 待分割字符串
// 参数     : const std::basic_string<CharT>& c 分割字符串
// 附注     :
// -------------------------------------------------------------------------
template<typename CharT, template<typename S, typename Q = std::allocator<S> > class Container>
void Split(Container<std::basic_string<CharT> >& v, const std::basic_string<CharT>& s, const std::basic_string<CharT>& c);

template<template<typename S, typename Q = std::allocator<S> > class Container>
void Split(Container<std::basic_string<char> >& v, const std::basic_string<char>& s, const std::basic_string<char>& c)
{
    if (0 == c.length())
        return;

    std::basic_string<char>::size_type pos1 = 0;
    std::basic_string<char>::size_type pos2 = 0;

    pos1 = 0;
    pos2 = s.find(c);
    while (std::basic_string<char>::npos != pos2)
    {
        v.push_back(s.substr(pos1, pos2 - pos1));

        pos1 = pos2 + c.size();
        pos2 = s.find(c, pos1);
    }

    if (pos1 != s.length())
    {
        v.push_back(s.substr(pos1));
    }
}

template<template<typename S, typename Q = std::allocator<S> > class Container>
void Split(Container<std::basic_string<wchar_t> >& v, const std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& c)
{
    if (0 == c.length())
        return;

    std::basic_string<wchar_t>::size_type pos1 = 0;
    std::basic_string<wchar_t>::size_type pos2 = 0;

    pos1 = 0;
    pos2 = s.find(c);
    while (std::basic_string<wchar_t>::npos != pos2)
    {
        v.push_back(s.substr(pos1, pos2 - pos1));

        pos1 = pos2 + c.size();
        pos2 = s.find(c, pos1);
    }

    if (pos1 != s.length())
    {
        v.push_back(s.substr(pos1));
    }
}

} // End Namespace StlStr

} // End Namespace Util

// -------------------------------------------------------------------------
// $Log: $

#endif /* __QMSTLSTRUTIL_H__ */

/* -------------------------------------------------------------------------
//  文件名      ：  QMStlStrUtil.cpp
//  创建者      ：  magic
//  创建时间    ：  2015/9/1 17:09:36
//  功能描述    ：
//
//  $Id: $
// -----------------------------------------------------------------------*/

#include "stdafx.h"
#include "QMStlStrUtil.h"

// -------------------------------------------------------------------------

namespace Util
{

namespace StlStr
{

template<>
inline void Erase(std::basic_string<char>& s, const char& chErase)
{
    s.erase(remove_if(s.begin(), s.end(), bind2nd(std::equal_to<char>(), chErase)), s.end());
}

template<>
inline void Erase(std::basic_string<wchar_t>& s, const wchar_t& chErase)
{
    s.erase(remove_if(s.begin(), s.end(), bind2nd(std::equal_to<wchar_t>(), chErase)), s.end());
}

template<>
void Erase(std::basic_string<char>& s, const std::basic_string<char>& strErase)
{
    std::basic_string<char>::size_type pos = 0;
    while (true)
    {
        pos = s.find(strErase, pos);
        if (std::basic_string<char>::npos == pos)
            break;

        s.erase(pos, strErase.size());
    }
}

template<>
void Erase(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& strErase)
{
    std::basic_string<wchar_t>::size_type pos = 0;
    while (true)
    {
        pos = s.find(strErase, pos);
        if (std::basic_string<wchar_t>::npos == pos)
            break;

        s.erase(pos, strErase.size());
    }
}

template<>
void Replace(std::basic_string<char>& s, const std::basic_string<char>& src, const std::basic_string<char>& dest)
{
    std::basic_string<char>::size_type pos = 0;
    while (true)
    {
        pos = s.find(src, pos);
        if (std::basic_string<char>::npos == pos)
            break;

        s.replace(pos, src.size(), dest);
        pos += src.size();
    }
}

template<>
void Replace(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& src, const std::basic_string<wchar_t>& dest)
{
    std::basic_string<wchar_t>::size_type pos = 0;
    while (true)
    {
        pos = s.find(src, pos);
        if (std::basic_string<wchar_t>::npos == pos)
            break;

        s.replace(pos, src.size(), dest);
        pos += src.size();
    }
}

template<>
bool StartWithI(std::basic_string<char>& s, const std::basic_string<char>& head)
{
    if (s.size() < head.size())
        return false;

    std::basic_string<char> _s = s.substr(0, head.size());
    std::basic_string<char> _head = head;
    ToLower(_s);
    ToLower(_head);

    return (0 == _s.compare(0, _head.size(), _head));
}

template<>
bool StartWithI(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& head)
{
    if (s.size() < head.size())
        return false;

    std::basic_string<wchar_t> _s = s.substr(0, head.size());
    std::basic_string<wchar_t> _head = head;
    ToLower(_s);
    ToLower(_head);

    return (0 == _s.compare(0, _head.size(), _head));
}

template<>
bool EndWithI(std::basic_string<char>& s, const std::basic_string<char>& tail)
{
    if (s.size() < tail.size())
        return false;

    std::basic_string<char> _s = s.substr(s.size() - tail.size(), tail.size());
    std::basic_string<char> _tail = tail;
    ToLower(_s);
    ToLower(_tail);

    return (0 == _s.compare(0, _tail.size(), _tail));
}

template<>
bool EndWithI(std::basic_string<wchar_t>& s, const std::basic_string<wchar_t>& tail)
{
    if (s.size() < tail.size())
        return false;

    std::basic_string<wchar_t> _s = s.substr(s.size() - tail.size(), tail.size());
    std::basic_string<wchar_t> _tail = tail;
    ToLower(_s);
    ToLower(_tail);

    return (0 == _s.compare(0, _tail.size(), _tail));
}

} // End Namespace StlStr

} // End Namespace Util
// -------------------------------------------------------------------------
// $Log: $

STL字符串常用方法扩展的更多相关文章

python基础3 字符串常用方法
一. 基础数据类型总览 int:用于计算,计数,运算等. 1,2,3,100...... str:'这些内容[]' 用户少量数据的存储,便于操作. bool: True, False,两种状态 ...
2018.03.26 Python-Pandas 字符串常用方法
import numpy as np import pandas as pd 1 #字符串常用方法 - strip s = pd.Series([' jack ','jill',' jease ',' ...
day2 -- 字符串常用方法、列表、字典
1.字符串常用方法 name = "Convict abc" count(): print(name.count("c")) # 2 find(): print ...
OC中的字符串常用方法
OC中的字符串常用方法 OC中对字符串进行操作使用了Foundation框架中的NSString类(不可变).NSMutableString类(可变). NSString 1.创建字符串 [objc] ...
python 字符串常用方法
字符串常用方法 capitalize() String.capitalize() 将字符串首字母变为大写 name = 'xiaoming' new_name = name.capitalize() ...
es6 字符串的扩展和数值的扩展
es6字符串的扩展 1. es6新增的一些方法 1.1 includes 判断是否包括在内,返回一个 true or false 1.2 statsWith 判断是否以什么开头,返回一个 true o ...
Python基础二_操作字符串常用方法、字典、文件读取
一.字符串常用方法: name.captitalize() #字符串首字母大写 name.center(50,'*') ...
ES6字符串相关扩展
变量的解构赋值 // 数组的解构赋值 let [a,b,c] = [1,2,3]; //1,2,3 let [a,b,c] = [,123,]; //undefined 123 undefined l ...
ES6的新特性（4）——字符串的扩展
字符串的扩展 ES6 加强了对 Unicode 的支持,并且扩展了字符串对象. 字符的 Unicode 表示法 JavaScript 允许采用\uxxxx形式表示一个字在\u0000~\uFFFF之间 ...

随机推荐

jQuery 遍历 – 祖先
祖先是父.祖父或曾祖父等等. 通过 jQuery,您能够向上遍历 DOM 树,以查找元素的祖先. 向上遍历 DOM 树这些 jQuery 方法很有用,它们用于向上遍历 DOM 树: parent() ...
20160222.CCPP体系详解(0032天)
程序片段(01):宽字符.c+字符串与内存四区.c 内容概要:宽窄字符 ///宽字符.c #include <stdio.h> #include <stdlib.h> #inc ...
Android简易实战教程--第三十五话《音乐播放》
已经好几天不更新博客了,今天轻松一点模拟个简单的"音乐播放器".1分钟看完~ 整个简单布局,加几个控制按钮: <LinearLayout xmlns:android=&quo ...
iOS 滚动视图的复用问题解决方案
LazyScroll是什么 LazyScrollView 继承自ScrollView,目标是解决异构(与TableView的同构对比)滚动视图的复用回收问题.它可以支持跨View层的复用,用易用方式来 ...
shell命令执行hive脚本（hive交互，hive的shell编程）
Hive执行方式 Hive的hql命令执行方式有三种: 1.CLI 方式直接执行 2.作为字符串通过shell调用hive –e执行(-S开启静默,去掉"OK","Tim ...
Cocos2D与SpriteBuilder的问题在哪提问
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请多提意见,如果觉得不错请多多支持点赞.谢谢! hopy ;) 我们知道Cocos2D的教程中文版的非常少,注意我没有说Coc ...
剑指Offer——求职必备神器
剑指Offer--求职必备神器前言不管是公司网申.银行招聘.面试等等,"谈谈你的职业规划"."以往工作中遇到了哪些棘手问题?你是如何解决的?".&quo ...
全文检索 Lucene(3)
看完前两篇博客之后,想必大家对于Lucene的使用都有了一个比较清晰的认识了.如果对Lucene的知识点还是有点模糊的话,个人建议还是先看看这两篇文章. 全文检索 Lucene(1) 全文检索 Luc ...
Java中Excel导入功能实现、excel导入公共方法_POI -
这是一个思路希望能帮助到大家:如果大家有更好的解决方法希望分享出来公司导入是这样做的每个到导入的地方 @Override public List<DataImportMessage> ...
Cocos2D中Node的userObject实例变量使用时一个要注意的地方
大熊猫猪·侯佩原创或翻译作品.欢迎转载,转载请注明出处. 如果觉得写的不好请告诉我,如果觉得不错请多多支持点赞.谢谢! hopy ;) 我们知道在Cocos2D中,CCNode对象有一个ivar为us ...

STL字符串常用方法扩展

前言

常用方法集

代码

STL字符串常用方法扩展的更多相关文章

随机推荐

热门专题