字符分割的方法有哪些

不知道你想问什么？是说格式化字串吗？还是正则表达式？
格式化常用的：
..字串里的占位符
用法：string.Foramt("是个","宝宝","好孩子");//得到：宝宝是个好孩子

"yyyy-MM-dd HH:mm:ss"、"yyyy/MM/dd HH:mm:ss"... 日期时间格式化，更多请参考 DateTimeFormatInfo 类
用法：DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");//得到当前时间且格式化为（示例）：2009-2-12 13:38:30

".00"数字格式化，更多请参考 NumberFormatInfo 类
用法：3.1415926f.ToString(".00");//得到：3.14

正则表达式常用的：

字符类
说明

[ 字符分组 ]
（正字符分组。） 匹配指定字符分组内的任何字符。

字符分组由串连的一个或多个原义字符、转义符、字符范围或字符类组成。

例如，若要指定所有元音字母，使用 [aeiou]. 若要指定所有标点符号和十进制数字符，使用代码 [\p\d]。

[^ 字符分组 ]
（负字符分组。） 匹配不在指定字符分组内的任何字符。

字符分组由串连的一个或多个原义字符、转义符、字符范围或字符类组成。前导符 (^) 是强制的，指示字符分组为负字符分组，而不是正字符分组。

例如，若要指定除元音字母以外的所有字符，使用 [^aeiou]. 若要指定除标点符号和十进制数字符以外的所有字符，使用 [^\p\d]。

[ 第一个字符 - 最后一个字符 ]
（字符范围。） 匹配字符范围中的任何字符。

字符范围是一系列连续的字符，定义的方法是：指定系列中的第一个字符，连字符 (-)，然后指定系列中的最后一个字符。如果两个字符具有相邻的 Unicode 码位，则这两个字符是连续的。可以串连两个或更多字符范围。

例如，若要指定从“0”至“9”的十进制数范围、从“a”至“f”的小写字母范围，以及从“A”至“F”的大写字母范围，使用 [0-9a-fA-F]。

.
（句点字符。） 匹配除 \n 以外的任何字符。如果已用 Singleline 选项做过修改，则句点字符可与任何字符匹配。有关更多信息，请参见正则表达式选项。

请注意，正字符分组或负字符分组中的句点字符（方括号内的句点）将被视为原义句点字符，而非字符类。

\p
匹配通过名称（例如 Ll、Nd、Z、IsGreek 和 IsBoxDrawing）指定的 Unicode 通用类别或命名块中的任何字符。

\P
匹配不在名称中指定的 Unicode 通用类别或命名块中的任何字符。

\w
与任何单词字符匹配。等效于 Unicode 通用类别 [\p\p\p\p\p\p\p]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为，则 \w 等效于 [a-zA-Z_0-9]。

\W
与任何非单词字符匹配。等效于 Unicode 通用类别 [^\p\p\p\p\p\p\p]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为，则 \W 等效于 [^a-zA-Z_0-9]。

\s
与任何空白字符匹配。等效于转义符和 Unicode 通用类别 [\f\n\r\t\v\x85\p]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为，则 \s 等效于 [ \f\n\r\t\v]。

\S
与任何非空白字符匹配。等效于转义符和 Unicode 通用类别 [^\f\n\r\t\v\x85\p]。如果通过 ECMAScript 选项指定了符合 ECMAScript 的行为，则 \S 等效于 [^ \f\n\r\t\v]。

\d
与任何十进制数字匹配。对于 Unicode 类别的 ECMAScript 行为，等效于 \p，对于非 Unicode 类别的 ECMAScript 行为，等效于 [0-9]。

\D
与任何非数字字符匹配。对于 Unicode 类别的 ECMAScript 行为，等效于 \P，对于非 Unicode 类别的 ECMAScript 行为，等效于 [^0-9] 。

限定符
说明

*
指定零个或更多个匹配；例如 \w* 或 (abc)*。等效于 。

+
指定一个或多个匹配；例如 \w+ 或 (abc)+。等效于 。

?
指定零个或一个匹配；例如 \w? 或 (abc)?。等效于 。

指定恰好 n 个匹配；例如 (pizza)。

指定至少 n 个匹配；例如 (abc)。

指定至少 n 个但不多于 m 个匹配。

*?
指定尽可能少地使用重复的第一个匹配（等效于 lazy *）。

+?
指定尽可能少地使用重复但至少使用一次（等效于 lazy +）。

??
指定使用零次重复（如有可能）或一次重复 (lazy ?)。

?
等效于 (lazy )。

?
指定尽可能少地使用重复但至少使用 n 次 (lazy )。

?
指定介于 n 次和 m 次之间、尽可能少地使用重复 (lazy )。

#include "stdafx.h"
#include
#include
#include
#include
int Token(const char* pSep, char* pStr, std::set& refset)
{
for(char* outer = strtok(pStr, pSep) ; NULL != outer; outer =
strtok(NULL, pSep))
{
printf( "oken: %s\n", outer );
refset.insert(outer);
}
return 0;
}
int Token(int pSep, char* pStr, std::set& refset)
{
char* str=pStr;
char* pSub=strchr(str,pSep);
char subStrBuf[128]={'\0'};
while(NULL!=pSub)
{
strncpy(subStrBuf, str, pSub-str);
refset.insert(subStrBuf);
printf( "oken: %s\n", subStrBuf );
str = pSub+1;
pSub=strchr(str,pSep);
}
if(NULL==pSub && strlen(str)>0)
{
strncpy(subStrBuf, str, strlen(str));
refset.insert(subStrBuf);
printf( "oken: %s\n", subStrBuf );
}
return 0;
}
int Token(char ch, char* pStr, std::set& refset)
{
std::string str=pStr;
int pos=str.find(ch);
std::string subStr;
while(-1!=pos)
{
subStr=str.substr(0,pos);
refset.insert(subStr);
printf( "oken: %s\n", subStr.c_str());
str=str.substr(pos+1, str.size());
pos=str.find(ch);
}
if(pos == -1 && str.size()>0)
{
refset.insert(str);
printf( "oken: %s\n", str.c_str());
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
printf( "==================方式一==================\n");
char str1[]="127.0.0.1:10;127.0.0.2:20;127.0.0.3:30";
std::set tempset;
Token(";", str1, tempset);
printf( "==================方式二==================\n");
char str2[]="127.0.0.1:10;127.0.0.2:20;127.0.0.3:30";
std::set tempset2;
Token(';', str2, tempset2);
printf( "==================方式三==================\n");
char str3[]="127.0.0.1:10;127.0.0.2:20;127.0.0.3:30";
std::set tempset3;
Token(';', str3, tempset3);
system("pause");
return 0;
}

我新装的系统，还没装C#呢，下面给你点提示。
分割字符串
Split 方法将字符串分隔后返回字符串数组。
Split使用方法一：
string str = "abcdefghigkceofuecto";
string[] sArray = str.Split('c');
foreach (string i in sArray)
Console.WriteLine(i.ToString()+"
");
输出下面的结果：
ab
defghigk
eofue
to

太多了，我理解成怎么讲字符分隔吧。有函数可以直接做
我知道的python 、vb、javascript、asp ：split
php是explode
c、c++没有这个函数要自己写

分隔字符串，还可以按长度分片。

还有基于连通域的方法