substr头文件？substr截取字符串
各位老铁们好，相信很多人对substr头文件都不是特别的了解，因此呢，今天就来为大家分享下关于substr头文件以及substr截取字符串的问题知识，还望可以帮助大家，解决大家的一些困惑，下面一起来看看吧！
scala 中rdd类型用什么头文件
1.RDD介绍：
RDD，弹性分布式数据集，即分布式的元素集合。在spark中，对所有数据的操作不外乎是创建RDD、转化已有的RDD以及调用RDD操作进行求值。在这一切的背后，Spark会自动将RDD中的数据分发到集群中，并将操作并行化。
Spark中的RDD就是一个不可变的分布式对象集合。每个RDD都被分为多个分区，这些分区运行在集群中的不同节点上。RDD可以包含Python，Java，Scala中任意类型的对象，甚至可以包含用户自定义的对象。
用户可以使用两种方法创建RDD：读取一个外部数据集，或在驱动器程序中分发驱动器程序中的对象集合，比如list或者set。
RDD的转化操作都是惰性求值的，这意味着我们对RDD调用转化操作，操作不会立即执行。相反，Spark会在内部记录下所要求执行的操作的相关信息。我们不应该把RDD看做存放着特定数据的数据集，而最好把每个RDD当做我们通过转化操作构建出来的、记录如何计算数据的指令列表。数据读取到RDD中的操作也是惰性的，数据只会在必要时读取。转化操作和读取操作都有可能多次执行。
2.创建RDD数据集
（1）读取一个外部数据集
val input=sc.textFile(inputFileDir)
（2）分发对象集合，这里以list为例
val lines=sc.parallelize(List("hello world","this is a test"));
3.RDD操作
（1）转化操作
实现过滤器转化操作：
val lines=sc.parallelize(List("error:a","error:b","error:c","test"));
val errors=lines.filter(line=> line.contains("error"));
errors.collect().foreach(println);
输出：
error:a
error:b
error:c
可见，列表list中包含词语error的表项都被正确的过滤出来了。
（2）合并操作
将两个RDD数据集合并为一个RDD数据集
接上述程序示例：
val lines=sc.parallelize(List("error:a","error:b","error:c","test","warnings:a"));
val errors=lines.filter(line=> line.contains("error"));
val warnings=lines.filter(line=> line.contains("warnings"));
val unionLines=errors.union(warnings);
unionLines.collect().foreach(println);
输出：
error:a
error:b
error:c
warning:a
可见，将原始列表项中的所有error项和warning项都过滤出来了。
（3）获取RDD数据集中的部分或者全部元素
①获取RDD数据集中的部分元素.take(int num)返回值List<T>
获取RDD数据集中的前num项。
/**
* Take the first num elements of the RDD. This currently scans the partitions*one by one*, so
* it will be slow if a lot of partitions are required. In that case, use collect() to get the
* whole RDD instead.
*/
def take(num: Int): JList[T]
程序示例：接上
unionLines.take(2).foreach(println);
输出：
error:a
error:b
可见，输出了RDD数据集unionLines的前2项
②获取RDD数据集中的全部元素.collect()返回值 List<T>
程序示例：
val all=unionLines.collect();
all.foreach(println);
遍历输出RDD数据集unionLines的每一项
4.向spark传递函数
在scala中，我们可以把定义的内联函数、方法的引用或静态方法传递给Spark，就像Scala的其他函数式API一样。我们还要考虑其他一些细节，必须所传递的函数及其引用的数据需要是可序列化的（实现了Java的Serializable接口）。除此之外，与Python类似，传递一个对象的方法或者字段时，会包含对整个对象的引用。我们可以把需要的字段放在一个局部变量中，来避免包含该字段的整个对象。
class searchFunctions(val query:String){
def isMatch(s: String): Boolean={
s.contains(query)
}
def getMatchFunctionReference(rdd: RDD[String]):RDD[String]={
//问题： isMach表示 this.isMatch,因此我们需要传递整个this
rdd.filter(isMatch)
}
def getMatchesFunctionReference(rdd: RDD[String]):RDD[String]={
//问题： query表示 this.query,因此我们需要传递整个this
rdd.flatMap(line=> line.split(query))
}
def getMatchesNoReference(rdd:RDD[String]):RDD[String]={
//安全，只把我们需要的字段拿出来放入局部变量之中
val query1=this.query;
rdd.flatMap(x=>x.split(query1)
)
}
}
5.针对每个元素的转化操作：
转化操作map()接收一个函数，把这个函数用于RDD中的每个元素，将函数的返回结果作为结果RDD中对应的元素。关键词：转化
转化操作filter()接受一个函数，并将RDD中满足该函数的元素放入新的RDD中返回。关键词：过滤
示例图如下所示：
①map()
计算RDD中各值的平方
val rdd=sc.parallelize(List(1,2,3,4));
val result=rdd.map(value=> value*value);
println(result.collect().mkString(","));
输出：
1,4,9,16
filter()
②去除RDD集合中值为1的元素：
val rdd=sc.parallelize(List(1,2,3,4));
val result=rdd.filter(value=> value!=1);
println(result.collect().mkString(","));
结果：
2,3,4
我们也可以采取传递函数的方式，就像这样：
函数：
def filterFunction(value:Int):Boolean={
value!=1
}
使用：
val rdd=sc.parallelize(List(1,2,3,4));
val result=rdd.filter(filterFunction);
println(result.collect().mkString(","));
③有时候，我们希望对每个输入元素生成多个输出元素。实现该功能的操作叫做flatMap()。和map()类似，我们提供给flatMap()的函数被分别应用到了输入的RDD的每个元素上。不过返回的不是一个元素，而是一个返回值序列的迭代器。输出的RDD倒不是由迭代器组成的。我们得到的是一个包含各个迭代器可以访问的所有元素的RDD。flatMap()的一个简单用途是将输入的字符串切分成单词，如下所示：
val rdd=sc.parallelize(List("Hello world","hello you","world i love you"));
val result=rdd.flatMap(line=> line.split(""));
println(result.collect().mkString("
"));
输出：
hello
world
hello
you
world
i
love
you
6.集合操作
RDD中的集合操作
函数
用途
RDD1.distinct()
生成一个只包含不同元素的新RDD。需要数据混洗。
RDD1.union(RDD2)
返回一个包含两个RDD中所有元素的RDD
RDD1.intersection(RDD2)
只返回两个RDD中都有的元素
RDD1.substr(RDD2)
返回一个只存在于第一个RDD而不存在于第二个RDD中的所有元素组成的RDD。需要数据混洗。
集合操作对笛卡尔集的处理：
RDD1.cartesian(RDD2)
返回两个RDD数据集的笛卡尔集
程序示例：生成RDD集合{1,2}和{1,2}的笛卡尔集
val rdd1=sc.parallelize(List(1,2));
val rdd2=sc.parallelize(List(1,2));
val rdd=rdd1.cartesian(rdd2);
println(rdd.collect().mkString("
"));
输出：
(1,1)
(1,2)
(2,1)
(2,2)
7.行动操作
(1)reduce操作
reduce()接收一个函数作为参数，这个函数要操作两个RDD的元素类型的数据并返回一个同样类型的新元素。一个简单的例子就是函数+，可以用它来对我们的RDD进行累加。使用reduce(),可以很方便地计算出RDD中所有元素的总和，元素的个数，以及其他类型的聚合操作。
以下是求RDD数据集所有元素和的程序示例：
val rdd=sc.parallelize(List(1,2,3,4,5,6,7,8,9,10));
val results=rdd.reduce((x,y)=>x+y);
println(results);
输出：55
(2)fold()操作
接收一个与reduce()接收的函数签名相同的函数，再加上一个初始值来作为每个分区第一次调用时的结果。你所提供的初始值应当是你提供的操作的单位元素，也就是说，使用你的函数对这个初始值进行多次计算不会改变结果（例如+对应的0，*对应的1，或者拼接操作对应的空列表）。
程序实例：
①计算RDD数据集中所有元素的和：
zeroValue=0;//求和时，初始值为0。
val rdd=sc.parallelize(List(1,2,3,4,5,6,7,8,9,10));
val results=rdd.fold(0)((x,y)=>x+y);
println(results);
②计算RDD数据集中所有元素的积：
zeroValue=1；//求积时，初始值为1。
val rdd=sc.parallelize(List(1,2,3,4,5,6,7,8,9,10));
val results=rdd.fold(1)((x,y)=>x*y);
println(results);
(3)aggregate()操作
aggregate()函数返回值类型不必与所操作的RDD类型相同。
与fold()类似，使用aggregate()时，需要提供我们期待返回的类型的初始值。然后通过一个函数把RDD中的元素合并起来放入累加器。考虑到每个节点是在本地进行累加的，最终，还需要提供第二个函数来将累加器两两合并。
以下是程序实例：
val rdd=sc.parallelize(List(1,2,3,4,5,6,7,8,9,10));
val result=rdd.aggregate((0,0))(
(acc,value)=>(acc._1+value,acc._2+1),
(acc1,acc2)=>(acc1._1+acc2._1, acc1._2+acc2._2)
)
val average=result._1/result._2;
println(average)
输出：5
最终返回的是一个Tuple2<int,int>对象，他被初始化为(0,0),当遇到一个int值时，将该int数的值加到Tuple2对象的_1中，并将_2值加1，如果遇到一个Tuple2对象时，将这个Tuple2的_1和_2的值归并到最终返回的Tuple2值中去。
表格：对一个数据为{1,2,3,3}的RDD进行基本的RDD行动操作
函数名目的示例结果
collect()返回RDD的所有元素 rdd.collect(){1,2,3,3}
count() RDD的元素个数 rdd.count() 4
countByValue()各元素在RDD中出现的次数 rdd.countByValue(){(1,1),
(2,1),
(3,2)
}
take(num)从RDD中返回num个元素 rdd.take(2){1,2}
top(num)从RDD中返回最前面的num个元素 rdd.takeOrdered(2)(myOrdering){3,3}
takeOrdered(num)
(ordering)从RDD中按照提供的顺序返回最前面的num个元素
rdd.takeSample(false,1)非确定的
takeSample(withReplacement,num,[seed])从RDD中返回任意一些元素 rdd.takeSample(false,1)非确定的
reduce(func)并行整合RDD中所有数据 rdd.reduce((x,y)=> x+y)
9
fold(zero)(func)和reduce()一样，但是需要提供初始值 rdd.fold(0)((x,y)=> x+y)
9
aggregate(zeroValue)(seqOp,combOp)和reduce()相似，但是通常返回不同类型的函数 rdd.aggregate((0,0))
((x,y)=>
(x._1+y,x._2+1),
(x,y)=>
(x._1+y._1,x._2+y._2)
)(9,4)
foreach(func)对RDD中的每个元素使用给定的函数 rdd.foreach(func)无
8.持久化缓存
因为Spark RDD是惰性求值的，而有时我们希望能多次使用同一个RDD。如果简单地对RDD调用行动操作，Spark每次都会重算RDD以及它的所有依赖。这在迭代算法中消耗格外大，因为迭代算法常常会多次使用同一组数据。
为了避免多次计算同一个RDD，可以让Spark对数据进行持久化。当我们让Spark持久化存储一个RDD时，计算出RDD的节点会分别保存它们所求出的分区数据。
出于不同的目的，我们可以为RDD选择不同的持久化级别。默认情况下persist()会把数据以序列化的形式缓存在JVM的堆空间中
不同关键字对应的存储级别表
级别
使用的空间
cpu时间
是否在内存
是否在磁盘
备注
MEMORY_ONLY
高
低
是
否
直接储存在内存
MEMORY_ONLY_SER
低
高
是
否
序列化后储存在内存里
MEMORY_AND_DISK
低
中等
部分
部分
如果数据在内存中放不下，溢写在磁盘上
MEMORY_AND_DISK_SER
低
高
部分
部分
数据在内存中放不下，溢写在磁盘中。内存中存放序列化的数据。
DISK_ONLY
低
高
否
是
直接储存在硬盘里面
程序示例：将RDD数据集持久化在内存中。
val rdd=sc.parallelize(List(1,2,3,4,5,6,7,8,9,10)).persist(StorageLevel.MEMORY_ONLY);
println(rdd.count())
println(rdd.collect().mkString(","));
RDD还有unpersist()方法，调用该方法可以手动把持久化的RDD从缓存中移除。
9.不同的RDD类型
在scala中，将RDD转为由特定函数的RDD（比如在RDD[Double]上进行数值操作），是由隐式转换来自动处理的。这些隐式转换可以隐式地将一个RDD转为各种封装类，比如DoubleRDDFunctions（数值数据的RDD）和PairRDDFunctions(键值对RDD),这样我们就有了诸如mean()和variance()之类的额外的函数。
示例程序：
val rdd=sc.parallelize(List(1.0,2.0,3.0,4.0,5.0));
println(rdd.mean());
其实RDD[T]中并没有mean()函数，只是隐式转换自动将其转换为DoubleRDDFunctions。
c++ string 怎么用
用法和步骤：
1.定义和构造初始化
string提供了很多构造函数，可以以多种方式来初始化string字符串。
2.赋值，拼接字符串
string重载了=++=等多种运算符，让字符串组合拼接更简单。
3.访问字符操作
string可以按数组方式，以下标来访问。还可以用at()函数访问指定的字符。
4.可以使用 STL的接口
可以把 string理解为一个特殊的容器，容器中装的是字符。
5.比较操作==!=>>=<<= compare等
string的比较操作，按字符在字典中的顺序进行逐一比较。在字典前面的字符小于后面的字符。
6.查找 find rfind
string中除了find、rfind，还有find_first_of等函数也提供了强大的查找功能。
7.除了string中的find函数外，char[]数组也有强大的查找函数
C++中有strstr、strchr等也有查找功能。函数说明如下：
char*strstr( const char*str, const char*substr);返回指针，指向substr在字符串str中首次出现的位置。
char*strchr( const char*str, int ch);返回指针，指向 str中字符ch首次出现的位置。
8.与 char[ ]的相互转换
copy()，返回指针，赋值给char[ ]数组名；
c_str()，返回 const类型的指针；
data()，将内容以字符数组的形式返回。
9.分割字符串
常用 strtok和 substr来分割字符串。
10.string大小分配函数
capacity()，返回容器在它已经分配的内存中可以容纳多少元素；
resize(Container::size_type n)，强制把容器改为容纳n个元素。
11.string中的字符替换、删除操作。
12.char[ ]常用的比较、拼接字符串功能
任意字符查找：char*strpbrk( const char*str1, const char*str2);
内存拷贝：void*memcpy( void*to, const void*from, size_t count);
如果 to和 from重叠，则函数行为不确定。memset()对内存初始化。如：memset( array,'\0', sizeof(array));这是将数组的所以元素设置成零的很方便的方法。
注意事项：
1.使用string，必须要包含头文件string.h
2.C++中，最好使用string来代替char[ ]
lpctstr和cstring的区别
CString LPCTSTR区别联系
CString是一个动态TCHAR数组，BSTR是一种专有格式的字符串（需要用系统提供的函数来操纵，LPCTSTR只是一个常量的TCHAR指针。
CString是一个完全独立的类，动态的TCHAR数组，封装了+等操作符和字符串操作方法。
typedef OLECHAR FAR* BSTR;
typedef const char* LPCTSTR;
vc++中各种字符串的表示法
首先char*是指向ANSI字符数组的指针，其中每个字符占据8位（有效数据是除掉最高位的其他7位），这里保持了与传统的C,C++的兼容。
LP的含义是长指针(long pointer)。LPSTR是一个指向以‘\0’结尾的ANSI字符数组的指针，与char*可以互换使用，在win32中较多地使用LPSTR。
而LPCSTR中增加的‘C’的含义是“CONSTANT”（常量），表明这种数据类型的实例不能被使用它的API函数改变，除此之外，它与LPSTR是等同的。
1.LP表示长指针,在win16下有长指针(LP)和短指针(P)的区别,而在win32下是没有区别的,都是32位.所以这里的LP和P是等价的.
2.C表示const
3.T是什么东西呢,我们知道TCHAR在采用Unicode方式编译时是wchar_t,在普通时编译成char.
为了满足程序代码国际化的需要，业界推出了Unicode标准，它提供了一种简单和一致的表达字符串的方法，所有字符中的字节都是16位的值，其数量也可以满足差不多世界上所有书面语言字符的编码需求，开发程序时使用Unicode（类型为wchar_t)是一种被鼓励的做法。
LPWSTR与LPCWSTR由此产生，它们的含义类似于LPSTR与LPCSTR，只是字符数据是16位的wchar_t而不是char。
然后为了实现两种编码的通用，提出了TCHAR的定义：
如果定义_UNICODE，声明如下：
typedef wchar_t TCHAR;
如果没有定义_UNICODE，则声明如下：
typedef char TCHAR;
LPTSTR和LPCTSTR中的含义就是每个字符是这样的TCHAR。
CString类中的字符就是被声明为TCHAR类型的，它提供了一个封装好的类供用户方便地使用。
LPCTSTR:
#ifdef _UNICODE
typedef const wchar_t* LPCTSTR;
#else
typedef const char* LPCTSTR;
#endif
VC常用数据类型使用转换详解
先定义一些常见类型变量借以说明
int i= 100;
long l= 2001;
float f=300.2;
double d=12345.119;
char username[]="女侠程佩君";
char temp[200];
char*buf;
CString str;
_variant_t v1;
_bstr_t v2;
一、其它数据类型转换为字符串
短整型(int)
itoa(i,temp,10);//将i转换为字符串放入temp中,最后一个数字表示十进制
itoa(i,temp,2);//按二进制方式转换
长整型(long)
ltoa(l,temp,10);
二、从其它包含字符串的变量中获取指向该字符串的指针
CString变量
str="2008北京奥运";
buf=(LPSTR)(LPCTSTR)str;
BSTR类型的_variant_t变量
v1=(_bstr_t)"程序员";
buf= _com_util::ConvertBSTRToString((_bstr_t)v1);
三、字符串转换为其它数据类型
strcpy(temp,"123");
短整型(int)
i= atoi(temp);
长整型(long)
l= atol(temp);
浮点(double)
d= atof(temp);
四、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:
整数(int)
str.Format("%d",i);
浮点数(float)
str.Format("%f",i);
字符串指针(char*)等已经被CString构造函数支持的数据类型可以直接赋值
str= username;
五、BSTR、_bstr_t与CComBSTR
CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。
char*转换到BSTR可以这样: BSTR b=_com_util::ConvertStringToBSTR("数据");//使用前需要加上头文件comutil.h
反之可以使用char*p=_com_util::ConvertBSTRToString(b);
六、VARIANT、_variant_t与 COleVariant
VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;//指明整型数据
va.lVal=a;//赋值
对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:
unsigned char bVal; VT_UI1
short iVal; VT_I2
long lVal; VT_I4
float fltVal; VT_R4
double dblVal; VT_R8
VARIANT_BOOL boolVal; VT_BOOL
SCODE scode; VT_ERROR
CY cyVal; VT_CY
DATE date; VT_DATE
BSTR bstrVal; VT_BSTR
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char FAR* pbVal; VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2
long FAR* plVal; VT_BYREF|VT_I4
float FAR* pfltVal; VT_BYREF|VT_R4
double FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL
SCODE FAR* pscode; VT_BYREF|VT_ERROR
CY FAR* pcyVal; VT_BYREF|VT_CY
DATE FAR* pdate; VT_BYREF|VT_DATE
BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR
IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH
SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*
VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT
void FAR* byref; VT_BYREF
_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal=(long)i;
COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：
COleVariant v3="字符串", v4=(long)1999;
CString str=(BSTR)v3.pbstrVal;
long i= v4.lVal;
七、其它
对消息的处理中我们经常需要将WPARAM或LPARAM等32位数据(DWORD)分解成两个16位数据(WORD),例如：
LPARAM lParam;
WORD loValue= LOWORD(lParam);//取低16位
WORD hiValue= HIWORD(lParam);//取高16位
对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
WORD wValue;
BYTE loValue= LOBYTE(wValue);//取低8位
BYTE hiValue= HIBYTE(wValue);//取高8位
如何将CString类型的变量赋给char*类型的变量
1、GetBuffer函数：
使用CString::GetBuffer函数。
char*p;
CString str="hello";
p=str.GetBuffer(str.GetLength());
str.ReleaseBuffer();
将CString转换成char*时
CString str("aaaaaaa");
strcpy(str.GetBuffer(10),"aa");
str.ReleaseBuffer();
当我们需要字符数组时调用GetBuffer(int n),其中n为我们需要的字符数组的长度.使用完成后一定要马上调用ReleaseBuffer();
还有很重要的一点就是,在能使用const char*的地方,就不要使用char*
2、memcpy：
CString mCS=_T("cxl");
char mch[20];
memcpy(mch,mCS,20);
3、用LPCTSTR强制转换：尽量不使用
char*ch;
CString str;
ch=(LPSTR)(LPCTSTR)str;
CString str="good";
char*tmp;
sprintf(tmp,"%s",(LPTSTR)(LPCTSTR)str);
4、
CString Msg;
Msg=Msg+"abc";
LPTSTR lpsz;
lpsz= new TCHAR[Msg.GetLength()+1];
_tcscpy(lpsz, Msg);
char* psz;
strcpy(psz,lpsz);
CString类向const char*转换
char a[100];
CString str("aaaaaa");
strncpy(a,(LPCTSTR)str,sizeof(a));
或者如下:
strncpy(a,str,sizeof(a));
以上两种用法都是正确地.因为strncpy的第二个参数类型为const char*.所以编译器会自动将CString类转换成const char*.
CString转LPCTSTR(const char*)
CString cStr;
const char*lpctStr=(LPCTSTR)cStr;
LPCTSTR转CString
LPCTSTR lpctStr;
CString cStr=lpctStr;
将char*类型的变量赋给CString型的变量
可以直接赋值，如：
CString myString="This is a test";
也可以利用构造函数，如：
CString s1("Tom");
将CString类型的变量赋给char []类型(字符串)的变量
1、sprintf()函数
CString str="good";
char tmp[200];
sprintf(tmp,"%s",(LPCSTR)str);
(LPCSTR)str这种强制转换相当于(LPTSTR)(LPCTSTR)str
CString类的变量需要转换为(char*)的时,使用(LPTSTR)(LPCTSTR)str
然而，LPCTSTR是const char*,也就是说，得到的字符串是不可写的！将其强制转换成LPTSTR去掉const，是极为危险的！
一不留神就会完蛋！要得到char*,应该用GetBuffer()或GetBufferSetLength()，用完后再调用ReleaseBuffer()。
2、strcpy()函数
CString str;
char c[256];
strcpy(c, str);
char mychar[1024];
CString source="Hello";
strcpy((char*)&mychar,(LPCTSTR)source);
关于CString的使用
1、指定 CString形参
对于大多数需要字符串参数的函数，最好将函数原型中的形参指定为一个指向字符(LPCTSTR)而非 CString的 const指针。
当将形参指定为指向字符的 const指针时，可将指针传递到 TCHAR数组（如字符串 ["hi there"]）或传递到 CString对象。
CString对象将自动转换成 LPCTSTR。任何能够使用 LPCTSTR的地方也能够使用 CString对象。
2、如果某个形参将不会被修改，则也将该参数指定为常数字符串引用（即 const CString&）。如果函数要修改该字符串，
则删除 const修饰符。如果需要默认为空值，则将其初始化为空字符串 [""]，如下所示：
void AddCustomer( const CString& name, const CString& address, const CString& comment="");
3、对于大多数函数结果，按值返回 CString对象即可。
串的基本运算
对于串的基本运算，很多高级语言均提供了相应的运算符或标准的库函数来实现。
为叙述方便，先定义几个相关的变量：
char s1[20]="dir/bin/appl",s2[20]="file.asm",s3[30],*p;
int result;
下面以C语言中串运算介绍串的基本运算
1、求串长
int strlen(char*s);//求串s的长度
【例】printf("%d",strlen(s1));//输出s1的串长12
2、串复制
char*strcpy(char*to,*from)；//将from串复制到to串中，并返回to开始处指针
【例】strcpy(s3,s1);//s3="dir/bin/appl",s1串不变
3、联接
char*strcat(char*to,char*from);//将from串复制到to串的末尾，
//并返回to串开始处的指针
【例】strcat(s3,"/");//s3="dir/bin/appl/"
strcat(s3,s2);//s3="dir/bin/appl/file.asm"
4、串比较
int strcmp(char*s1,char*s2);//比较s1和s2的大小，
//当s1<s2、s1>s2和s1=s2时，分别返回小于0、大于0和等于0的值
【例】result=strcmp("baker","Baker");//result>0
result=strcmp("12","12");//result=0
result=strcmp("Joe","joseph")//result<0
5、字符定位
char*strchr(char*s,char c);//找c在字符串s中第一次出现的位置，
//若找到，则返回该位置，否则返回NULL
【例】p=strchr(s2,'.');//p指向"file"之后的位置
if(p) strcpy(p,".cpp");//s2="file.cpp"
注意：
①上述操作是最基本的，其中后 4个操作还有变种形式：strncpy，strncath和strnchr。
②其它的串操作见C的<string.h>。在不同的高级语言中，对串运算的种类及符号都不尽相同
③其余的串操作一般可由这些基本操作组合而成
【例】求子串的操作可如下实现：
void substr(char*sub,char*s,int pos,int len){
//s和sub是字符数组，用sub返回串s的第pos个字符起长度为len的子串
//其中0<=pos<=strlen(s)-1,且数组sub至少可容纳len+1个字符。
if(pos<0||pos>strlen(s)-1||len<0)
Error("parameter error!");
strncpy(sub,&s[pos],len);//从s[pos]起复制至多len个字符到sub
OK，关于substr头文件和substr截取字符串的内容到此结束了，希望对大家有所帮助。