迷途知返

#ifndef _STR_H_
#define _STR_H_
#include <string>
#include <cmath>
#include <cctype>
//#include <algorithm>
#include "Array.h"
#ifndef sint
#define sint string::size_type
#endif
#ifndef ints
#define ints Array<int,int>
#endif
#ifndef strings
#define strings Array<int,string>
#endif
using namespace std;
 
/*****************
 * string addslashes ( string str )
 *
 * 返回字符串，该字符串为了数据库查询语句等的需要在某些字符前加上了反斜线。
 * 这些字符是单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）。
 * /     
string addslashes(const string &str){
    string temp = "";
    for(sint i=0; i!=str.size(); i++){
        if(str[i]==chr(39) || str[i]==chr(34) || str[i]==chr(92) || str[i]==chr(0)){
            temp += '\\' ;
            temp += str[i];
        } else temp += str[i];
    }
    return temp;
}
*/
 
/*****************
 *    string rtrim ( string str [, string charlist] )
 *
 *  This function returns a string with whitespace stripped from the end of str.
 *  Without the second parameter, rtrim() will strip these characters:
 *  " " (ASCII 32 (0x20)), an ordinary space. 
 *  "\t" (ASCII 9 (0x09)), a tab.
 *  "\n" (ASCII 10 (0x0A)), a new line (line feed).
 *  "\r" (ASCII 13 (0x0D)), a carriage return.
 *  "\0" (ASCII 0 (0x00)), the NUL-byte. 
 */ 
string rtrim(const string &str, const string &charlist = " \t\n\r\0"){
    string s = str;
    for(sint i=0; i!=charlist.size(); i++){
        if( s.rfind(charlist[i])==s.size()-1 ){ 
            s=rtrim(s.substr(0,s.size()-1)); 
        }    
    }
    return s;
}
 
/***********
 * string chr ( int ascii )
 *  
 * 返回相对应于 ascii 所指定的单个字符。
 */ 
char chr(const int &asc){
    return (char)asc;
}
 
/***********
 * int ord ( string string )
 *  
 * Returns the ASCII value of the first character of string.
 */
int ord(const char &c){
    return (int)c;
} 
 
/***********
 * return the ascii of the first char of str
 */  
int ord(const string &str){
    return (int)str[0];
} 
 
/***********
 * int asc(string string)
 * This is an alias of ord 
 */ 
int asc(const char &c){
    return ord(c);
} 
int asc(const string &str){
    return ord(str);
}
 
/************
 * mixed count_chars ( string string  )
 * 
 * 统计 string 中每个字节值（0..255）出现的次数。
 */  
ints count_chars(const string &str){
    ints is(256,0);
    for(sint i=0; i!=str.size(); i++){
        is[ord(str[i])] ++ ;
    }
    return is;
}
 
/*************
 * array explode ( string separator, string string [, int limit] )
 *  
 * 此函数返回由字符串组成的数组，每个元素都是 string 的一个子串，
 *  它们被字符串 separator 作为边界点分割出来。
 */   
strings explode(const string &separator, const string &str){
    string s = str;
    strings ss;
    sint pos;
    do{
        pos = s.find(separator);
        ss += make_pair(ss.size(),string(s,0,s.find_first_of(separator)));
        s = s.substr(pos+separator.size());
    } while ( pos!=string::npos );
    return ss;
}
 
strings split(const string &separator, const string &str){
    return explode(separator, str);
}
 
strings str_split(const string &separator, const string &str){
    return explode(separator, str);
}
 
/**************
 * string implode ( string glue, array pieces )
 *  
 * Returns a string containing a string representation of all the array
 * elements in the same order, with the glue string between each element. *
 */    
string implode(const string &glue, strings &ss){
    string s = ss[0] ;
    for(sint i=1; i!=ss.size(); i++){
        s += glue + ss[i];
    }
    return s;
}
 
string join(const string &glue, strings &ss){
    return implode(glue,ss);
}
 
/*****************
 *    string ltrim ( string str [, string charlist] )
 *
 *  This function returns a string with whitespace stripped from the beginning of str.
 *  Without the second parameter, rtrim() will strip these characters:
 *  " " (ASCII 32 (0x20)), an ordinary space. 
 *  "\t" (ASCII 9 (0x09)), a tab.
 *  "\n" (ASCII 10 (0x0A)), a new line (line feed).
 *  "\r" (ASCII 13 (0x0D)), a carriage return.
 *  "\0" (ASCII 0 (0x00)), the NUL-byte.
 *  "\x0B" (ASCII 11 (0x0B)), a vertical tab.  
 */ 
string ltrim(const string &str, const string &charlist=" \t\n\r\0"){
    string s = str;
    for(sint i=0; i!=charlist.size(); i++){
        if(s.find(charlist[i])==0){s=ltrim(s.substr(1));}    
    }
    return s;
}
 
//trim a string
string trim(const string& str){
    string s=str;
    //trim left
    s = ltrim(str);
    //trim right
    s = rtrim(s);
    return s;
}
 
/**************
 * string str_replace(string search, string replace, string subject[ , int &count])
 *
 * This function returns a string with all occurrences of search 
 *  in subject replaced with the given replace value. 
 *  The amount of occurrences will be stored in count if given  
 */    
string str_replace(const string &search, const string &replace, const string &subject, int &count){
    strings ss = split(search, subject);
    count = ss.size() - 1;
    return join(replace, ss);
}
 
string str_replace(const string &search, const string &replace, const string &subject){
    strings ss = split(search, subject);
    return join(replace, ss);
}
 
/***************
 * string strtolower(string string)
 *  
 * Make a string lowercase
 */  
string strtolower(const string &str){
    string s = "";
    for(sint i=0; i!=str.size(); i++){
        s += tolower(str[i]);
    }
    return s;
}
 
/***************
 * string strtoupper(string string)
 *  
 * Make a string uppercase
 */  
string strtoupper(const string &str){
    string s = "";
    for(sint i=0; i!=str.size(); i++){
        s += toupper(str[i]);
    }
    return s;
}
 
/**************
 * string str_ireplace(string search, string replace, string subject[ , int &count])
 *
 * Case-insensitive str_replace
 */ 
string str_ireplace(const string &search, const string &replace, const string &subject, int &count){
    ints is(subject.size(),0);
    for(sint i=0; i!=subject.size(); i++){
        if(isupper(subject[i])) is[i] = 1;
    }
    string str = strtolower(subject);
    string srh = strtolower(search);
    strings ss = split(srh, str);
    count = ss.size() - 1;
    strings rs(ss.size(),string(""));
    sint pos = 0;
    for(sint i=0; i!=ss.size(); i++){
        for(sint j=0; j!=ss[i].size(); j++){
            if(is[pos]) rs[i] = strtoupper(ss[i]);
            else rs[i] = ss[i];
            pos++;
        }
        pos += search.size();
    }
    return join(replace, rs);
}
 
string str_ireplace(const string &search, const string &replace, const string &subject){
    ints is(subject.size(),0);
    for(int i=0; i!=subject.size(); i++){
        if(isupper(subject[i])) is[i] = 1;
    }
    string str = strtolower(subject);
    string srh = strtolower(search);
    strings ss = split(srh, str);
    strings rs(ss.size(),string(""));
    sint pos = 0;
    for(int i=0; i!=ss.size(); i++){
        for(sint j=0; j!=ss[i].size(); j++){
            if(is[pos]) rs[i] = strtoupper(ss[i]);
            else rs[i] = ss[i];
            pos++;
        }
        pos += search.size();
    }
    return join(replace, rs);
}
 
/***************
 * string str_repeat ( string input, int multiplier )
 * 
 * Returns input_str repeated multiplier times. 
 * multiplier has to be greater than or equal to 0. 
 * If the multiplier is set to 0, the function will return an empty string. 
 */   
string str_repeat(const string &input, const int &mult){
    string s = "";
    for(int i=0; i<mult; i++){
        s += input;
    }
    return s;
}
 
/***************
 * string str_shuffle ( string str )
 * 
 * str_shuffle() shuffles a string.
 */
string str_shuffle(const string &str){
    string s = "";
    ints subscripts;
    for(sint i=0; i!=str.size(); i++) subscripts[i] = i;
    while(!subscripts.empty()){
        srand(time(NULL));
        int r = rand() % subscripts.size();
        s += str[subscripts[r]];
        subscripts.erase(subscripts[r]);
    }
    return s;
} 
 
/***************
 * int str_word_count(string string)
 *
 * Counts the number of words inside string.
 */ 
int str_word_count(const string &str){
    strings ss = split(" ", str);
    int count = 0;
    for(sint i=0; i!=ss.size(); i++){
        if(!ss[i].empty()) count++;
    }
    return count;
}
 
/****************
 * string strstr ( string haystack, string needle )
 * 
 * Returns part of haystack string from the first occurrence of needle to the end of haystack. 
 */
string strstr(const string &haystack, const string &needle){
    return haystack.substr(haystack.find_first_of(needle));
}
 
string strchr(const string &haystack, const string &needle){
    return strstr(haystack, needle);
}
 
/*****************
 * int stripos ( string haystack, string needle)
 *
 * stripos --  Find position of first occurrence of a case-insensitive string 
 */    
sint stripos(const string &haystack, const string &needle){
    return strtolower(haystack).find_first_of(strtolower(needle));
}
 
/*****************
 * int strlen ( string string )\
 * 
 * Returns the length of the given string.
 */
sint strlen(const string &str){
    return str.size();
}  
 
/*****************
 * int strpos ( string haystack, string needle)
 *
 * strpos --  Find position of first occurrence of a string 
 */    
sint strpos(const string &haystack, const string &needle){
    return haystack.find_first_of(needle);
}
 
/*****************
 * int strrchr ( string haystack, string needle)
 *
 * strrchr --  Find position of last occurrence of a string 
 */    
sint strrchr(const string &haystack, const string &needle){
    return haystack.find_last_of(needle);
}
 
/*****************
 * string strrev ( string string )
 * 
 * Returns string, reversed. 
 */   
string strrev(const string &str){
    string s = "";
    for(int i=str.size()-1; i>=0; i--){
    // type of i here must be int, not sint(string::size_type), 
    // because the last i is -1
        s += str[i];
    }
    return s;
}
 
/*****************
 * int strripos ( string haystack, string needle)
 *
 * strripos --  Find position of last occurrence of a case-insensitive string 
 */    
sint strripos(const string &haystack, const string &needle){
    return strtolower(haystack).find_last_of(strtolower(needle));
}
 
/*****************
 * int strrpos ( string haystack, string needle)
 *
 * strrpos --  Find position of last occurrence of a string 
 */    
sint strrpos(const string &haystack, const string &needle){
    return haystack.find_last_of(needle);
}
 
//for int
string num2str(const int &num, const string &format = "%d"){
/*    int temp = num;
    string str = "";
    string flag; 
    if( temp==0 ) return "0";
    flag = temp<0 ? "-" : "";
    temp = abs(temp);
    while( temp!=0 ){
        str = char( int(temp % 10)+48 ) + str;
        temp = (int)temp/10;
    }
    return flag+str;
*/
    char s[32];
    sprintf(s, format.c_str(), num);
    return string(s);
}
 
// for float
string num2str(const double &num, const string &format = "%f"){
/*    int ipart = (int)num;
    double fpart = num - (double)ipart;
    cout << fpart << endl;
    if( ipart<0 ) fpart = -fpart;
    string s = num2str(ipart);
    s += ".";
    s += num2str((int)(fpart*pow(10,(double)fracdigital)));
    return s;
*/
    char s[32];
    sprintf(s, format.c_str(), num);
    return string(s);
}
 
/*************
 * string left(string str, int n)
 *
 * return a string containing left n chars of str
 */   
string left(const string &str, const int &n){
    return str.substr(0,n);
}
 
/*************
 * string right(string str, int n)
 *
 * return a string containing right n chars of str
 */   
string right(const string &str, const int &n){
    return str.substr(str.size()-n);
}
 
/*************
 * string substr(string str, int pos[, int n])
 *
 * return a string containing n chars from pos of str
 */  
string substr(const string &str, const int &pos, const unsigned &n){
    int p = pos, s = str.size();
    if( p<=-s || p>=s ){
        cerr << "Warning: substr: invalid parameter pos " 
             << p << ", str.size() = " 
             << s << endl;
        return "";
    }
    if( p<0 ) p += s;
    return str.substr(p,n);
}
 
string substr(const string &str, const int &pos){
    return substr(str,pos,str.size()-pos);
}
 
string mid(const string &str, const int &pos, const unsigned &n){
    return substr(str,pos,n);
}
 
/*************
 * double str2num(const string &str)
 *
 * convert a string to a double 
 */   
double str2num(const string &str){
    strings ss = split(".",str);
    bool flag = true;
    double s = 0.;
    if(ss.size()>2){
        cerr << "Warning: str2num: too many points in " << str << ", preserve the first one." << endl;
        for(sint i=2; i<ss.size(); i++)
            ss[1] += ss[i];
    }
    if( left(ss[0],1)=="-" ){
        flag = false;
        ss[0] = ss[0].substr(1);
    } else if( left(ss[0],1)=="+" ){ 
        ss[0] = ss[0].substr(1);
    }
    string ss0 = "";
    for(string::size_type i=0; i<ss[0].size(); i++){
        if(isdigit(ss[0][i])) ss0 += ss[0][i];
    }
    for(sint i=0; i<ss0.size(); i++){
        if(isdigit(ss0[i])) s += ((int)ss0[i]-48)*pow(10.,(double)(ss0.size()-i-1));
    }
    if(ss.size()>1){
        int n = 0;
        for(sint i=0; i<ss[1].size(); i++){
            if(isdigit(ss[1][i])) s += ((int)ss[1][i]-48)*pow(10.,(double)(-1-n));
            else n--;
            n++;
        }
    }
    return flag?s:-s;
}
 
#endif