c++ 字串分割函式stringsplit

阿新 • • 發佈：2019-01-21

新版：

/*

 stringsplit.hpp

 sdragonx 2006-06-16 00:43:16
 revise 2018/7/28 19:42

 function list:

 size_t stringsplit(container, const char_type*, size_t, char_type, bool)
 size_t stringsplit(container, const char_type*, size_t, const char_type*, size_t, bool)

 這是個模板函式，支援標準庫裡面的各種容器，和標準字串。
 這次更新，為了平臺相容性，削減到只剩兩個核心函式。
 測試了3款編譯器，編譯通過 (gcc7.2.0、c++builder6.0、C++Builder2010)

 例如：
 std::string s = "abc,,123";
 std::vector<std::string> ls;
 stringsplit(ls, s.c_str(), s.length(), ',', true);
 如果repeat == true，s就被分割成為3個字串，第二個字串是空的
 如果repeat == false，s就被分割成2個字串

 支援多個分割符：
 std::string s = "abc,|123|456";
 std::string spliter = ",|";
 std::vector<std::string> ls;
 stringsplit(ls, s.c_str(), s.length(), spliter.c_str(), spliter.size(), true);

 也支援其他容器，例如：
 std::list<std::string> ls;
 stringsplit(ls, s.c_str(), s.size(), ',', true);

 std::deque<std::string> ls;
 stringsplit(ls, s.c_str(), s.size(), ',', true);

 基礎的兩個函式，是以C字串格式寫的，也支援其他型別的字串，
 只要這個字串有建構函式String(const char*, size_t length)就行

 const char* s = "a,b,,c";
 std::vector<std::string> ls;
 stringsplit(ls, s, strlen(s), ',', true);

*/

#ifndef STRINGSPLIT_HPP_200606161656
#define STRINGSPLIT_HPP_200606161656

#include <algorithm>

namespace cgl{

//
// size_t stringsplit<char_type>(container, const char_type*, size_t, char_type, bool)
//
template<typename char_type, class container>
size_t stringsplit(
    container& ls,
    const char_type* str,
    size_t size,
    char_type spliter,
    bool repeat = true)
{
    typedef const char_type* const_iterator;
    typedef typename container::value_type string_type;

    const_iterator begin = str;
    const_iterator end = begin + size;
    const_iterator first = begin;
    const_iterator second;
    
    for( ; first<end; )
    {
        second = std::find<const_iterator>(first, end, spliter);
        if(first == second){
            if(repeat)ls.push_back(string_type());
        }
        else{
            ls.push_back(string_type(first, second - first));
    	}
        first = second+1;
    }
    if(repeat)
    {
        if(second == end-1){
        	ls.push_back(string_type());
        }
    }
    return ls.size();
}

//
// size_t stringsplit<char_type>(container, const char_type*, size_t, const char_type*, size_t, bool)
//
template<typename char_type, typename container>
size_t stringsplit(container& ls,
    const char_type* str,
    size_t size,
    const char_type* spliter,
    size_t spliter_size,
    bool repeat = true)
{
    typedef typename container::value_type string_type;
    typedef const char_type* const_iterator;
	
    const_iterator end = str + size;
    const_iterator first = str;
    const_iterator second;
    
    for( ; first<end; )
    {
        second = std::find_first_of<const_iterator>(first, end, spliter, spliter + spliter_size);
        if(first == second){
            if(repeat)ls.push_back(string_type());
        }
        else{
        	ls.push_back(string_type(first, second));
        }
        first = second+1;
    }
    if(repeat)
    {
        if(second == end-1){
        	ls.push_back(string_type());
        }
    }
    return ls.size();
}

/*

以下擴充套件函式作為參考
有的平臺std::iterator是一個類，有點就是char*指標
各個平臺實現方式不一樣，暫時無法統一


//
// size_t stringsplit<string_type>(container, const_iterator, const_iterator, char_type, bool)
//
template<typename string_type, typename container>
size_t stringsplit(
    container& ls,
    typename string_type::const_iterator begin,
    typename string_type::const_iterator end,
    typename string_type::value_type spliter,
    bool repeat = true)
{
    return stringsplit(ls, &*begin, end - begin, spliter, repeat);
}

//
// size_t stringsplit<string_type>(container, string_type, char, bool)
//
template<typename string_type, typename container>
size_t stringsplit(
    container& ls,
    const string_type& str,
    typename string_type::value_type spliter,
    bool repeat = true)
{
    return stringsplit(ls, str.c_str(), str.size(), spliter, repeat);
}

//
// size_t stringsplit<string_type>(container, const_iterator, const_iterator, const_iterator, const_iterator, bool)
//
template<typename string_type, typename container>
size_t stringsplit(
    container& ls,
    typename string_type::const_iterator begin,
    typename string_type::const_iterator end,
    typename string_type::const_iterator spliter_begin,
    typename string_type::const_iterator spliter_end,
    bool repeat = true)
{
    return stringsplit(ls, &*begin, end - begin, &*spliter_begin, spliter_end - spliter_begin, repeat);
}

//
// size_t stringsplit<string_type>(container, string_type, string_type, bool)
//
template<typename string_type, typename container>
size_t stringsplit(
    container& ls,
    const string_type& str,
    const string_type& spliter,
    bool repeat = true)
{
    return stringsplit(ls, str.c_str(), str.size(), spliter.c_str(), spliter.size(), repeat);
}
*/

}; // end namespace cgl;

#endif //STRINGSPLIT_HPP_200606161656

以前的舊版：

/*

 stringsplit.hpp

 sdragonx 2006-06-16 00:43:16
 revise  2016.07.18 19:04

*/

#ifndef STRINGSPLIT_HPP_200606161656
#define STRINGSPLIT_HPP_200606161656

#include <algorithm>

namespace cgl{

template<typename char_type, template<typename> class string_type, template<typename> class container>
size_t stringsplit(
	container< string_type<char_type> >& ls,
	typename string_type<char_type>::const_iterator begin,
	typename string_type<char_type>::const_iterator end,
	char_type spliter,
	bool repeat = true)
{
    if(end <= begin)
    {
    	return 0;
    }

    typename string_type<char_type>::const_iterator first = begin;
    typename string_type<char_type>::const_iterator second;
    
    for( ; first<end; )
    {
        second = std::find<string_type<char_type>::const_iterator>(first, end, spliter);
        if(first == second){
            if(repeat)ls.push_back(string_type<char_type>());
        }
        else{
            ls.push_back(string_type<char_type>(first, second));
    	}
        first = second+1;
    }
    if(repeat)
    {
        if(second == end-1){
        	ls.push_back(string_type<char_type>());
        }
    }
    return ls.size();
}

template<typename char_type, template<typename> class string_type, template<typename> class container>
size_t stringsplit(
	container< string_type<char_type> >& ls,
    typename string_type<char_type>::const_iterator begin,
    typename string_type<char_type>::const_iterator end,
    typename string_type<char_type>::const_iterator spliter_begin,
    typename string_type<char_type>::const_iterator spliter_end,
    bool repeat = true)
{
    if(end <= begin || spliter_end<=spliter_begin)
    {
    	return 0;
    }

    typename string_type<char_type>::const_iterator first = begin;
    typename string_type<char_type>::const_iterator second;
    
    for( ; first<end; )
    {
        second = std::find_first_of<string_type<char_type>::const_iterator>(first, end, spliter_begin, spliter_end);
        if(first == second){
            if(repeat)ls.push_back(string_type<char_type>());
        }
        else{
        	ls.push_back(string_type<char_type>(first, second));
        }
        first = second+1;
    }
    if(repeat)
    {
        if(second == end-1){
        	ls.push_back(string_type<char_type>());
        }
    }
    return ls.size();
}

template<typename char_type, template<typename> class string_type, template<typename> class container>
size_t stringsplit(container< string_type<char_type> > &strs,
	const string_type<char_type>& str, char_type spliter, bool repeat = true)
{
    return stringsplit(strs, str.begin(), str.end(), spliter, repeat);
}

template<typename char_type, template<typename> class string_type, template<typename> class container>
size_t stringsplit(container< string_type<char_type> > &strs,
	const char_type* str, size_t length, char_type spliter, bool repeat = true)
{
    return stringsplit(strs, str, str+length, spliter, repeat);
}

template<typename char_type, template<typename> class string_type, template<typename> class container>
size_t stringsplit(container< string_type<char_type> > &strs,
	const string_type<char_type>& str, const string_type<char_type>& spliter, bool repeat = true)
{
    return stringsplit(strs, str.begin(), str.end(), spliter.begin(), spliter.end(), repeat);
}

template<typename char_type, template<typename> class string_type, template<typename> class container>
size_t stringsplit(container< string_type<char_type> > &strs,
	const char_type* str, size_t length, const char_type* spliter, size_t splength, bool repeat = true)
{
    return stringsplit(strs, str, str+length, spliter, spliter+splength, repeat);
}

}; // end namespace cgl;

#endif //STRINGSPLIT_HPP_200606161656

c++ 字串分割函式stringsplit

新版： /* stringsplit.hpp sdragonx 2006-06-16 00:43:16 revise 2018/7/28 19:42 function list: size_t stringsplit(container, const c

字串分割函式的C++實現

#include <iostream> #include <string> #include <vector> #include <algorithm> #include <fstream> using

c語言的split字串分割函式strtok的使用

c語言也有類似其他語言的split字串分割函式，就是strtok 標頭檔案：#include <string.h>定義函式：char * strtok(char *s, const char *delim);函式說明：strtok()用來將字串分割成一個個片段。

C語言字串分割函式split實現

#include <stdlib.h> #include <string.h> #include <stdio.h> /* 用delimiter中的每一個分隔符分割str字串,這並不會改變str中的字元,然後返回一個字串陣列. 字串陣列中的字串有可能是以'\0'開頭的空串

C 語言字串分割函式 p = strtok(NULL, " ");

原始碼： #include <stdio.h> #include<string.h> int main() { char str[] = "經度:111°11’11'' 緯度: 30°30'30''"; char *p; char a[]=" "

C++ string型別的split字串分割函式

std::vector<std::string> split(const std::string& s, const std::string& delim) { std::vector<std::string>

ive函式 -- split 字串分割函式

hive字串分割函式 split(str, regex) - Splits str around occurances that match regexTime taken: 0.769 seconds, Fetched: 1 row(s) 返回值為一個數組 a.基本用法：例1： spl

c# 字串分割問題

，假設string s是待分割的字串分割 s 字串的時候，我們需要一個標記來解決需要分割什麼字元，可以在split裡直接寫或者寫一個數組放到split中。分割好之後當然是多個字串，那麼我們需要string[] ans陣列來存放分割好的字元。那麼程式就是 string[] ans = s.

SQL Server自定義字串分割函式——Split

我相信大部分人都碰到過，處理資料的時候，欄位的值是以 ',' （逗號）分隔的形式，所以我也不能避免。然後我才知道，sql 是沒有類似於 C# 和 Javascript 這種分割字串的方法。（ Split ）所以我自己定義了一個 sql 函式（多宣告表值函式），程式碼如下：

C字串——庫函式系列（strlen、strcat、strcpy、strcmp）

一定義：字串：字串是由零個或者多個字元組成的有限序列；子串：字串中任意個連續的字元組成的子序列，並規定空串是任意串的子串，字串本身也是子串之一；“abcdefg”，”abc“就是其子串，但是“ade”不屬於子串範圍。子序列：不要求字元連續，但是其順序與其在主串中相一致；上例中，“abc

c++字串查詢函式實現

int find(const char*str,const char*sub_str) { //這裡就沒有判斷指標是否是NULL了 //保留起始地址以計算位置 const char *temp_str = str; //預設返回結果 int ret = -

C++字串處理函式

C++字串處理函式轉載自c/c++字串處理大集合 C++： <string> string str; 1. 字串長度 len = str.length(); len = str.size(); 2. 字串比較可

C/C++ 字串處理函式

C語言中的字串處理函式： 1. 字串長度 extern int strlen(char *s); //返回s的長度，不包括結束符NULL。該函式以結束符為判斷字串長度結束的標誌。註釋：沒有memsize函式或是memlen函式嗎？ 2. 字串比較 extern int strcmp(char

Python字串分割函式

Python學習之字串分割設計一個函式把一個含有空格的字串分割成幾個字串 def splice1(temp): temp=temp.strip() while temp.find(' ')!=-1: temp1=temp[:temp.fi

strtok、strtok_s、strtok_r 字串分割函式

1、strtok函式函式原型：char * strtok (char *str, const char * delimiters); 引數：str，待分割的字串（c-string）；delimiters，分割符字串。該函式用來將字串分割成一個個片段。引數str指

strtok、strtok_r 字串分割函式

1.一個應用例項 typedef struct person{ char name[25]; char sex[10]; char age[4]; }Person; 需從字串 char buffer[INFO_MAX_

c字串轉換函式atoi、atof、atol

c開發中會常會借用一些函式來完成數字到字串、字串到數字的轉換功能，下面列舉幾個常用到的字串轉換函式： 1. atof 函式原型： double atof(const char *nptr) 標

hive函式 -- split 字串分割函式

hive字串分割函式 split(str, regex) - Splits str around occurances that match regex Time taken: 0.769 seconds, Fetched: 1 row(s) 返回值為一個數組 a.基本用法

Java 字串分割函式 split() 在分割以“.”為分隔符時出現的問題

Java 中字串的操作是很重要的一個環節，java 自帶了很多的關於字串的操作。其中 spilt() 作為分割函式，用到的情況很多。但是是否遇到當以“.” 作為分割符時，不能分割的情況呢。我想應

【C語言】字串函式strtok 按照指定字串分割

C語言字串函式 strtok() 函式原型 char *strtok(char *str,const char *delimiters); 引數 str，待分割的字串 delimiters，分隔符字串該函式用來將字串str分割成一個個片段。引數str指

c++ 字串分割函式stringsplit

相關推薦