C++字符串分割续

//.h文件

#pragma once


#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>


using namespace std;


enum {CHAR_COUNT = 255};

class ZzToolClass
{
public:
ZzToolClass(void);
~ZzToolClass(void);


public:
/***-------------------------字符串分割函数----------------------------***/
/*****************
* 函数： int SplitFromSingleChar(string str, string split, vector<string > &vStr);
* 功能： 分割str字符串
* 参数说明： str：需要分割字符串； split:分割的字符串字符； vStr：分割后的字符串
* 返回值：函数执行成功，返回分割得到的字符串的个数, 如果失败，返回 0 。
* 例如：str = "my name is<hello,word> : test[string](string.)world";
*       split = " ,;:!?.<>[]()'";  //split中的每一个字符都是分隔符
* 说明：函数的形参没有并不是strng &const str, 是为了方便传入char* 的实参
*****/
int SplitFromSingleChar(string str, string split, vector<string > &vStr);


/*****************
* 函数：int SplitFromGropChar(string str, string split, vector<string > &vStr);
* 功能：分割str字符串
* 参数说明： str：需要分割字符串； split:分割的字符串字符； vStr：分割后的字符串
* 返回值：函数执行成功，返回分割得到的字符串的个数 ，如果失败，返回 0 。
* 例如：str = "my##eedsfa##";
*       split = "##"; //split整个是分隔符 
*
*****/
int SplitFromGropChar(string str, string split, vector<string > &vStr);

/*****************
* 函数：int SplitFromMultiGropChar(string str, vector<string > split, vector<string >&vStr);
* 功能：用分割符集合分割str字符串
* 参数说明：str：需要分割字符串； split:分割的字符串字符集合； vStr：分割后的字符串
* 返回值：函数执行成功，返回分割得到的字符串的个数 ，如果失败，返回 0 。
* 例如：str = "my##eedsfa##";
*       split[0] = "##"; //split[0]整个是分隔符 
*       split[1] = "||"; //split[1]整个是分隔符 
*       split[2] = ","; //split[2]整个是分隔符 
*
*****/
int SplitFromMultiGropChar(string str, vector<string > split, vector<string > &vStr);


/***------------------------字符个数统计----------------------------***/
map<char, int> CalChar(char* pCh);


private:
void InitBuffer(int* &pBuffer, int n = 2);
void ClearBuffer(int* &pBuffer);


/*****************
* 函数：bool IsSplit(string str, vector<string > &vStr, int num);
* 功能：判断str是否已被分割
* 参数说明：str：需要分割字符串； vStr：存放分割后的字符串集合； num：分割前vStr的大小
* 返回值：分割成功返回 true, 否则 为false 。
*****/
bool IsSplit(string str, vector<string > &vStr, int num);


private:
int* pBuffer;
};


//.cpp  文件

#include "StdAfx.h"
#include "ZzToolClass.h"




ZzToolClass::ZzToolClass(void)
{
InitBuffer(pBuffer);
}




ZzToolClass::~ZzToolClass(void)
{
ClearBuffer(pBuffer);
}




void ZzToolClass::InitBuffer(int* &pBuffer, int n)
{
pBuffer = new int[n];
memset(pBuffer, 0, n);
}




void ZzToolClass::ClearBuffer(int* &pBuffer)
{
if(pBuffer == NULL)
return;

delete [] pBuffer;
pBuffer = NULL;
}




int ZzToolClass::SplitFromSingleChar(string str, string split, vector<string > &vStr)
{
string::size_type pos = 0;
string::size_type numBegin = 0;
str += split.substr(0, 1);    //确保待分割的字符串末尾有分隔符
while((pos = str.find_first_of(split, pos))!= string::npos )
{
if( pos!= 0 && string::npos == str.substr(pos - 1, 1).find_first_of(split))
{
vStr.push_back(str.substr(numBegin, pos - numBegin ));
}
++pos;
numBegin = pos;
}
return vStr.size();
}




int ZzToolClass::SplitFromGropChar(string str, string split, vector<string >&vStr)
{
string::size_type pos = 0;
string::size_type numBegin = 0;
string::size_type length = str.length(); //str的实际长度
str += split;    //确保待分割的字符串末尾有分隔符
while((pos = str.find_first_of(split, pos))!= string::npos )
{
if(pos != length + 1  && 0 == (str.substr(pos, split.length())).compare(split)) 
{
if(!(str.substr(numBegin, pos - numBegin)).empty())
{
vStr.push_back(str.substr(numBegin, pos - numBegin ));
}


pos += split.length();
numBegin = pos;
}
else
{
++pos ;
}
}
return vStr.size();
}




int ZzToolClass::SplitFromMultiGropChar(string str, vector<string > split, vector<string >&vStr)
{
if(split.size() <= 0)
return 0;


//第一次分割
if(0 == SplitFromGropChar(str, *split.begin(), vStr))
return 0;

int num = 0;
if(split.size() >= 2)
{
for(vector<string >::size_type i = 1; i<split.size(); ++i)
{
for(vector<string >::size_type j = 0; j<vStr.size(); ++j)
{   
num = vStr.size();
SplitFromGropChar(vStr[j], split[i], vStr);
IsSplit(vStr[j], vStr, num);
}
}
}


return vStr.size();
}




bool ZzToolClass::IsSplit(string str, vector<string >&vStr, int num)
{
if(0 == str.compare((*(vStr.end()-1)))) //没有分割成子串
{
vStr.erase(vStr.end() -1); //删除末尾元素
return false;
}

//字符串被分割了，删除vStr中源字符串，将分割后的字符串插入源字符串的位置
vector<string >::iterator it = find(vStr.begin(), vStr.end(), str);
int n = 0;
if(it != vStr.end())
{   
n = vStr.size() - num;
vStr.insert(it, vStr.end() - n, vStr.end());
vStr.erase(vStr.end() - n, vStr.end());
vector<string >::iterator it01 = find(vStr.begin(), vStr.end(), str);
vStr.erase(it01);
return true;
}
}





map<char, int> ZzToolClass::CalChar(char* pCh)
{
int a[CHAR_COUNT] = {0};
int num = strlen(pCh);
for(int i = 0; i < num; ++i)
    {
      a[pCh[i]]++;
    }

map<char, int> countMap;
for(int j = 0; j<CHAR_COUNT; ++j)
{
   if(a[j] != 0)
{
countMap.insert(map<char, int>::value_type(j, a[j]));
}
}


return countMap;
}