C++中针对C语言中处理字符串的难题，在标准库中设计了string类，因此现在编程中涉及到字符串的处理，就可以直接使用string类了。
之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。
首先，为了在我们的程序中使用string类型，我们必须包含头文件。如下：
#include
1．声明一个C++字符串
声明一个字符串变量很简单：
string Str;
这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str 初始化为一个空字符串。String类的构造函数和析构函数如下：
a) string s; //生成一个空字符串s
b) string s(str) //拷贝构造函数生成str的复制品
c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值
d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值
e) string s(cstr) //将C字符串作为s的初值
f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。
g) string s(num,c) //生成一个字符串，包含num个c字符
h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值
i) s.~string() //销毁所有字符，释放内存
都很简单，我就不解释了。
2．字符串操作函数
这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。
a) =,assign() //赋以新值
b) swap() //交换两个字符串的内容
c) +=,append(),push_back() //在尾部添加字符
d) insert() //插入字符
e) erase() //删除字符
f) clear() //删除全部字符
g) replace() //替换字符
h) + //串联字符串
i) ==,!=,<,<=,>,>=,compare() //比较字符串
j) size(),length() //返回字符数量
k) max_size() //返回字符的可能最大个数
l) empty() //判断字符串是否为空
m) capacity() //返回重新分配之前的字符容量
n) reserve() //保留一定量内存以容纳一定数量的字符
o) [ ], at() //存取单一字符
p) >>,getline() //从stream读取某值
q) << //将谋值写入stream
r) copy() //将某值赋值为一个C_string
s) c_str() //将内容以C_string返回
t) data() //将内容以字符数组形式返回
u) substr() //返回某个子字符串
v)查找函数
w)begin() end() //提供类似STL的迭代器支持
x) rbegin() rend() //逆向迭代器
y) get_allocator() //返回配置器
下面详细介绍：
2.1 C++字符串和C字符串的转换
C++提供的由C++字符串得到对应的C_string的方法是使用data()、c_str()和copy()，其中，data()以字符数组的形式返回字符串内容，但并不添加’\0’。c_str()返回一个以‘\0’结尾的字符数组，而copy()则把字符串的内容复制或写入既有的c_string或字符数组内。C++字符串并不以’\0’结尾。我的建议是在程序中能使用C++字符串就使用，除非万不得已不选用c_string。由于只是简单介绍，详细介绍掠过，谁想进一步了解使用中的注意事项可以给我留言(到我的收件箱)。我详细解释。
2.2 大小和容量函数
一个C++字符串存在三种大小：a)现有的字符数，函数是size()和length()，他们等效。Empty()用来检查字符串是否为空。b)max_size() 这个大小是指当前C++字符串最多能包含的字符数，很可能和机器本身的限制或者字符串所在位置连续内存的大小有关系。我们一般情况下不用关心他，应该大小足够我们用的。但是不够用的话，会抛出length_error异常c)capacity()重新分配内存之前 string所能包含的最大字符数。这里另一个需要指出的是reserve()函数，这个函数为string重新分配内存。重新分配的大小由其参数决定，默认参数为0，这时候会对string进行非强制性缩减。
还有必要再重复一下C++字符串和C字符串转换的问题，许多人会遇到这样的问题，自己做的程序要调用别人的函数、类什么的（比如数据库连接函数Connect(char*,char*)），但别人的函数参数用的是char*形式的，而我们知道，c_str()、data()返回的字符数组由该字符串拥有，所以是一种const char*,要想作为上面提及的函数的参数，还必须拷贝到一个char*,而我们的原则是能不使用C字符串就不使用。那么，这时候我们的处理方式是：如果此函数对参数(也就是char*)的内容不修改的话，我们可以这样
Connect((char*)UserID.c_str(), (char*)PassWD.c_str()),但是这时候是存在危险的，因为这样转换后的字符串其实是可以修改的（有兴趣地可以自己试一试），所以我强调除非函数调用的时候不对参数进行修改，否则必须拷贝到一个char*上去。当然，更稳妥的办法是无论什么情况都拷贝到一个char*上去。同时我们也祈祷现在仍然使用C字符串进行编程的高手们（说他们是高手一点儿也不为过，也许在我们还穿开裆裤的时候他们就开始编程了，哈哈…）写的函数都比较规范，那样我们就不必进行强制转换了。
2.3元素存取
我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效（有效索引0~str.length()），如果索引失效，会引起未定义的行为。而at()会检查，如果使用at()的时候索引无效，会抛出out_of_range异常。
有一个例外不得不说，const string a;的操作符[]对索引值是a.length()仍然有效，其返回值是’\0’。其他的各种情况，a.length()索引都是无效的。举例如下：
const string Cstr(“const string”);
string Str(“string”);
Str[3]; //ok
Str.at(3); //ok
Str[100]; //未定义的行为
Str.at(100); //throw out_of_range
Str[Str.length()] //未定义行为
Cstr[Cstr.length()] //返回‘\0’
Str.at(Str.length());//throw out_of_range
Cstr.at(Cstr.length()) ////throw out_of_range
我不赞成类似于下面的引用或指针赋值：
char& r=s[2];
char* p= &s[3];
因为一旦发生重新分配，r,p立即失效。避免的方法就是不使用。
2．4比较函数
C++字符串支持常见的比较操作符（>,>=,<,<=,==,!=），甚至支持string与C-string 的比较(如 str<”hello”)。在使用>,>=,<,<=这些操作符的时候是根据“当前字符特性”将字符按字典顺序进行逐一得比较。字典排序靠前的字符小，比较的顺序是从前向后比较，遇到不相等的字符就按这个位置上的两个字符的比较结果确定两个字符串的大小。同时，string(“aaaa”) 另一个功能强大的比较函数是成员函数compare()。他支持多参数处理，支持用索引值和长度定位子串来进行比较。他返回一个整数来表示比较结果，返回值意义如下：0-相等〉0-大于 <0-小于。举例如下：
string s(“abcd”);
https://www.doczj.com/doc/7212658806.html,pare(“abcd”); //返回0
https://www.doczj.com/doc/7212658806.html,pare(“dcba”); //返回一个小于0的值
https://www.doczj.com/doc/7212658806.html,pare(“ab”); //返回大于0的值
https://www.doczj.com/doc/7212658806.html,pare(s); //相等
https://www.doczj.com/doc/7212658806.html,pare(0,2,s,2,2); //用”ab”和”cd”进行比较小于零
https://www.doczj.com/doc/7212658806.html,pare(1,2,”bcx”,2); //用”bc”和”bc”比较。
怎么样？功能够全的吧！什么？还不能满足你的胃口？好吧，那等着，后面有更个性化的比较算法。先给个提示，使用的是STL的比较算法。什么？对STL一窍不通？靠，你重修吧！
2．5 更改内容
这在字符串的操作中占了很大一部分。
首先讲赋值，第一个赋值方法当然是使用操作符=，新值可以是string(如：s=ns) 、
c_string(如：s=”gaint”)甚至单一字符（如：s=’j’）。还可以使用成员函数assign()，这个成员函数可以使你更灵活的对字符串赋值。还是举例说明吧：
s.assign(str); //不说
s.assign(str,1,3);//如果str是”iamangel”就是把”ama”赋给字符串
s.assign(str,2,string::npos);//把字符串str从索引值2开始到结尾赋给s
s.assign(“gaint”); //不说
s.assign(“nico”,5);//把’n’‘I’‘c’‘o’‘\0’赋给字符串
s.assign(5,’x’);//把五个x赋给字符串
把字符串清空的方法有三个：s=””;s.clear();s.erase();(我越来越觉得举例比说话让别人容易懂！)。
string提供了很多函数用于插入（insert）、删除（erase）、替换（replace）、增加字符。
先说增加字符（这里说的增加是在尾巴上），函数有 +=、append()、push_back()。举例如下：
s+=str;//加个字符串
s+=”my name is jiayp”;//加个C字符串
s+=’a’;//加个字符
s.append(str);
s.append(str,1,3);//不解释了同前面的函数参数assign的解释
s.append(str,2,string::npos)//不解释了
s.append(“my name is jiayp”);
s.append(“nico”,5);
s.append(5,’x’);
字符串操作是一个不小的主题,在标准C++中,string字符串类成为一个标准,之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下的需要.
主要内容:
1,主要函数的实现
2,常用函数
3.CString与char []的相互转换
4,将NULL字节放入CString中
vc中最主要函数不易理解。
CString::CString(char *p)
{
int n=strlen(p);
m_data = new char[n+1];
strcpy(m_data,p);
}
CString::CString(CString &other)
{
int n=strlen(other.m_data);
m_data = new char[n+1];
strcpy(m_data,other.m_data);
}
CString& CString::operator = (CString& other)
{
delete[] m_data;
int n=strlen(other.m_data);
m_data = new char[n+1];
strcpy(m_data,other.m_data);
return *this;
}
String::~String()
{
delete [] m_data;
}
Collate，Compare 与一个字符长指针所指的字符串进行比较，与strcmp 相同，它们的区别是，分别调用_tcscoll，_tcsicmp。
Delete
int Delete( int nIndex, int nCount = 1 )
返回值是被删除前的字符串的长度，nIndex是第一个被删除的字符，nCount是一次删除几个字符。根据我实验得出的结果：当nCount>字符串的长度时会出错，当nCount过大，没有足够的字符删除时，此函数不执行。
FindOneOf
int FindOneOf(LPCTSTR lpszCharSet)const;
此函数的功能是在查找lpszCharSet中的任意一个字符，查到一个就把位置返回，没有查到返回0。如：
CString str = "0123456789";
int x = str.FindOneOf("31");
x的值是1。
Find
int Find(TCHAR ch)const;
int Find(LPCTSTR lpszSub)const;
int Find( TCHAR ch, int nStart ) const;
int Find( LPCTSTR pstr, int nStart ) const;
返回值查找到的序号，ch待搜索的字符，lpszSub待搜索的字符子串，nStart 从那里开始搜索。如：
CString str = "0123456789";
int x = str.Find("34",4);
返回的值是-1.
GetAt
TCHAR GetAt(int nIndex)const;
返回标号为nIndex的字符，你可以把字符串理解为一个数组，GetAt类似于[].注意nIndex 的范围，如果不合适会有调试错误。
Insert
int Insert( int nIndex, TCHAR ch )
int Insert( int nIndex, LPCTSTR pstr )返回修改后的长度，nIndex字符（或字符串）插入后的标号。
Left
CString Left(int nCount)const;
返回的字符串的前nCount个字符。
Right与Left类似
MakeLower ，MakeUpper改变字符的大小写
MakeReverse字符倒置，如：
CString str = "X0123456789";
str.MakeReverse();
str变为"9876543210X"
+=
const CString&operator+=(const CString&string);
const CString&operator+=(TCHAR ch);
const CString&operator+=(LPCTSTR lpsz);
将参数合并到自己身上。
如：CString str = "0123456789";
str+="ha";
str为"0123456789ha"；
str[]
TCHAR operator[](int nIndex)const;
象处理字符数组一样处理字符串。
注意是只读的。
CString str = "0123456789";
str[0]='x';
是错误的。
TrimLeft,TrimRight
void TrimLeft( );
void CString::TrimLeft( TCHAR chTarget );
void CString::TrimLeft( LPCTSTR lpszTargets );
void TrimRight( );
void CString::TrimRight( TCHAR chTarget );
void CString::TrimRight( LPCTSTR lpszTargets );
CString str = "\n\t a";
str.TrimLeft();
str为“a”;
如果没有参数,从左删除字符(\n\t空格等),至到遇到一个非此类字符.
当然你也可以指定删除那些字符.
如果指定的参数是字符串,那么遇上其中的一个字符就删除. CString str = "abbcadbabcadb ";
str.TrimLeft("ab");
结果"cadbabcadb "
int CString::Remove( TCHAR ch );
ch删除的字符.
返回删除字符的个数,有多个时都会删除.
CString 与char []之间的转换.
char str[100] = ”str”;
CString sstr = “sstr”;
str.Format(“%s”,str);
str = LPCTSTR sstr;
strcpy(str,(LPCTSTR)sstr);
如果是赋值,则要:
CString s(_T("This is a test "));
LPTSTR p = s.GetBuffer();
// 在这里添加使用p的代码
if(p != NULL) *p = _T('\0');
s.ReleaseBuffer();
// 使用完后及时释放，以便能使用其它的CString成员函数
str的值变了.
将NULL字节放入CString中
1,CString str("abc\0""def", 7);
str +="g";
int nLength = str.GetLength();
nLength为8.
2,CString str("My name is hedan!");
str.SetAt(5, 0);
int nLength = str.GetLength();
注意:不是所有的CString成员函数都可以，在使用时一定要小心。
实例:动态配置数据源
CString strDsn,strDBQ;
strDsn = "DSN=test";
strDBQ.Format("DBQ=%s",strSourceMDBName);
CString strConnect = strDsn + " " + strDBQ ;
strConnect.SetAt(strDsn.GetLength(),'\0');
SQLConfigDataSource(NULL, ODBC_ADD_SYS_DSN, "Microsoft Access Driver (*.mdb)", strConnect);
TrimLeft方法的意义是：从字符串左边看起，遇到括号中出现的字符（参数）全部截去，直到出现第一个括号中未出现的字符时停止截除，即使后面又出现了参数中有的字符也不会截去了。TrimLeft方法的意义是：从字符串左边看起，遇到括号中出现的字符（参数）全部截去，直到出现第一个括号中未出现的字符时停止截除，即使后面又出现了参数中有的字符也不会截去了。
TrimRight方法类似。
去除当前字符串的前导和后缀空格字符TrimLeft()、TrimRight()
Trim()
功能删除字符串首部和尾部的空格。
语法Trim ( string )
参数string：string类型，指定要删除首部和尾部空格的字符串返回值String。函数执行成功时返回删除了string字符串首部和尾部空格的字符串，发生错误时返回空字符串（""）。如果任何参数的值为NULL，Trim()函数返回NULL。
int Compare( LPCTSTR lpsz ) const;
返回值字符串一样返回0
小于lpsz 返回-1
大于lpsz 返回1
区分大小字符
CString s1( " abc" );
CString s2( " abd" );
ASSERT( https://www.doczj.com/doc/7212658806.html,pare( s2 ) == -1 );
ASSERT( https://www.doczj.com/doc/7212658806.html,pare( " abe" ) == -1 );
CString::CompareNoCase
int CompareNoCase( LPCTSTR lpsz ) const;
返回值字符串一样返回0
小于lpsz 返回-1
大于lpsz 返回1
不区分大小字符
CString::Collate
int Collate( LPCTSTR lpsz ) const;
同CString::Compare
CString::CollateNoCase
int CollateNocase( LPCTSTR lpsz ) const;
同CString::CompareNoCase
CString::CString
CString( );
CString( const CString& stringSrc );
CString( TCHAR ch, int nRepeat = 1 );
CString( LPCTSTR lpch, int nLength );
CString( const unsigned char* psz );
CString( LPCWSTR lpsz );
CString( LPCSTR lpsz );
例子最容易说明问题
CString s1;
CString s2( " cat" );
CString s3 = s2;
CString s4( s2 + " " + s3 );
CString s5( 'x' ); // s5 = " x"
CString s6( 'x', 6 ); // s6 = " xxxxxx"
CString s7((LPCSTR)ID_FILE_NEW); // s7 = " Create a new document" CString city = " Philadelphia" ;
int Delete( int nIndex, int nCount = 1);
返回值是被删除前的字符串的长度
nIndex是第一个被删除的字符，nCount是一次删除几个字符。根据我实验得出的结果：当nCount> 要删除字符串的最大长度(GetCount() - nIndex)时会出错，当nCount过大，没有足够的字符删除时，此函数不执行。
例子
CString str1,str2,str3;
char a;
str1 = " nihao" ;
str2 = " nIhao" ;
int x;
// int i=(str1 == str2);
str1.Delete(2,3);
如果nCount(3) > GetCount() - nIndex (5-2)就会执行错误
CString::Empty
Void Empty( );
没有返回值清空操作;
例子
CString s( " abc" );
s.Empty();
ASSERT( s.GetLength( ) == 0 );
CString::Find
int Find( TCHAR ch ) const;
int Find( LPCTSTR lpszSub ) const;
int Find( TCHAR ch, int nStart ) const;
int Find( LPCTSTR lpszSub, int nStart ) const;
返回值不匹配的话返回-1; 索引以0 开始
nStar 代表以索引值nStart 的字符开始搜索,
即为包含以索引nStart字符后的字符串
例子
CString s( " abcdef" );
ASSERT( s.Find( 'c' ) == 2 );
ASSERT( s.Find( " de" ) == 3 );
Cstring str(“The stars are aligned”);
Ing n = str.Find('e',5);
ASSERT(n == 12)
CString::FindOneOf
int FindOneOf( LPCTSTR lpszCharSet ) const;
返回值不匹配的话返回-1; 索引以0 开始
注意::返回此字符串中第一个在lpszCharSet中也包括字符并且从零开始的索引值
例子
CString s( " abcdef" );
ASSERT( s.FindOneOf( " xd" ) == 3 ); // 'd' is first match.
CString::Format
void Format( LPCTSTR lpszFormat, ... );
void Format( UINT nFormatID, ... );
lpszFormat 一个格式控制字符串
nFormatID 字符串标识符
例子
CString str;
Str.Format(“%d”,13);
此时Str为13
CString::GetAt
TCHAR GetAt( int nIndex ) const;
返回标号为nIndex的字符，你可以把字符串理解为一个数组，GetAt类似于[].注意nIndex的范围，如果不合适会有调试错误。
CString::GetBuffer
LPTSTR GetBuffer( int nMinBufLength );
返回值
一个指向对象的（以空字符结尾的）字符缓冲区的LPTSTR 指针。
参数
nMinBufLength
字符缓冲区的以字符数表示的最小容量。这个值不包括一个结尾的空字符的空间。
说明
此成员函数返回一个指向CString 对象的内部字符缓冲区的指针。返回的LPTSTR 不是const，因此可以允许直接修改CString 的内容。如果你使用由GetBuffer 返回的指针来改变字符串的内容，你必须在使用其它的CString 成员函数之前调用ReleaseBuffer 函数。
在调用ReleaseBuffer 之后，由GetBuffer 返回的地址也许就无效了，因为其它的CString 操作可能会导致CString 缓冲区被重新分配。如果你没有改变此CString 的长度，则缓冲区不会被重新分配。当此CString 对象被销毁时，其缓冲区内存将被自动释放。
注意，如果你自己知道字符串的长度，则你不应该添加结尾的空字符。但是，当你用ReleaseBuffer 来释放该缓冲区时，你必须指定最后的字符串长度。如果你添加了结尾的空字符，你应该给ReleaseBuffer 的长度参数传递-1 ，ReleaseBuffer 将对该缓冲区执行strlen 来确定它的长度。
下面的例子说明了如何用CString::GetBuffer。
// CString::GetBuffer 例子
CString s( " abcd" );
#ifdef _DEBUG
afxDump < < " CString s " < < s < < " \n" ;
#endif
LPTSTR p = s.GetBuffer( 10 );
strcpy( p, " Hello" ); // 直接访问CString 对象。
s.ReleaseBuffer( );
#ifdef _DEBUG
afxDump < < " CString s " < < s < < " \n" ;
#endif
CString::GetLength
int GetLength( ) const;
返回值
返回字符串中的字节计数。
说明
此成员函数用来获取这个CString 对象中的字节计数。这个计数不包括结尾的空字符。
对于多字节字符集（MBCS），GetLength 按每一个8 位字符计数；即，在一个多字节字符中的开始和结尾字节被算作两个字节。
示例
下面的例子说明了如何使用CString::GetLength。
// CString::GetLength 示例
CString s( " abcdef" );
ASSERT( s.GetLength() == 6 );
CString::Insert
int Insert( int nIndex, TCHAR ch );
int Insert( int nIndex, LPCTSTR pstr );
返回修改后的长度，nIndex是字符（或字符串）插入后的索引号例子
C String str( “HockeyBest”);
int n = str.Insert( 6, “is” );
ASSERT( n == str.GetLength( ) );
printf( “1: %s\n”, ( LPCTSTR ) str );
n = str.Insert( 6, ' ' );
ASSERT( n == str.GetLength( ) );
printf ( “2: %s\n”, (LPCTSTR) STR );
n = str.Insert(555, …1?);
ASSERT( n == str.GetLength ( ) );
printf ( “3: %s\n”, ( LPCTSTR ) str );
输出
1. Hockeyis Best
2. Hockey is Best
3. Hockey is Best!
CString::IsEmpty
BOOL IsEmpty( ) const;
返回值
如果CString 对象的长度为0，则返回非零值；否则返回0。
说明
此成员函数用来测试一个CString 对象是否是空的。
下面的例子说明了如何使用CString::IsEmpty。
// CString::IsEmpty 示例
CString s;
ASSERT( s.IsEmpty() );
请参阅CString::GetLength
CString::Left
CString Left( int nCount ) const;
throw( CMemoryException );
返回的字符串是前nCount个字符。
例子
CString s( _T(" abcdef" ) );
ASSERT( s.Left(2) == _T(" ab" ) );
CString::LoadString
BOOL LoadString( UINT nID );
throw( CMemoryException );
返回值
如果加载资源成功则返回非零值；否则返回0。
nID 一个Windows 字符串资源ID。
说明此成员函数用来读取一个由nID 标识的Windows 字符串资源，并放入一个已有CString 对象中。示例
下面的例子说明了如何使用CString::LoadString。
// CString::LoadString 示例
#define IDS_FILENOTFOUND 1
CString s;
if (! s.LoadString( IDS_FILENOTFOUND ))
CString::MakeLower
void MakeLower( );
改变字符的小写
CString::MakeReverse
void MakeReverse( );
字符倒置
CString::MakeUpper
void MakeUpper( );
改变字符的大写
CString::Mid
CString Mid( int nFirst ) const;
CString Mid( int nFirst, int nCount ) const;
nCount代表要提取的字符数, nFirst代表要提取的开始索引位置
CString s( _T(" abcdef" ) );
ASSERT( s.Mid( 2, 3 ) == _T(" cde" ) );
CString::ReleaseBuffer
void ReleaseBuffer( int nNewLength = -1 );
参数
nNewLength
此字符串的以字符数表示的新长度，不计算结尾的空字符。如果这个字
符串是以空字符结尾的，则参数的缺省值－1 将把CString 的大小设置为
字符串的当前长度。
说明
使用ReleaseBuffer 来结束对由GetBuffer 分配的缓冲区的使用。如果你知道缓冲区中的字符串是以空字符结尾的，则可以省略nNewLength 参数。如果字符
串不是以空字符结尾的，则可以使用nNewLength 指定字符串的长度。在调用ReleaseBuffer 或其它CString 操作之后，由GetBuffer 返回的地址是无效的。示例
下面的例子说明了如何使用CString::ReleaseBuffer。
// CString::ReleaseBuffer 示例
CString s;
s = " abc" ;
LPTSTR p = s.GetBuffer( 1024 );
strcpy(p, " abc" ); // 直接使用该缓冲区
ASSERT( s.GetLength() == 3 ); // 字符串长度= 3
s.ReleaseBuffer(); // 释放多余的内存，现在p 无效。
ASSERT( s.GetLength() == 3 ); // 长度仍然是3
CString::Remove
int CString::Remove ( TCHAR ch );
返回值
返回从字符串中移走的字符数。如果字符串没有改变则返回零。
参数
ch
要从一个字符串中移走的字符。
说明
此成员函数用来将ch 实例从字符串中移走。与这个字符的比较是区分大小写
的。
示例
// 从一个句子中移走小写字母'c':
CString str (“This is a test.”);
int n = str.Remove( 't' );
ASSERT( n == 2 );
ASSERT( str ==“This is a es. ” );
CString::Replace
int Replace( TCHAR chOld, TCHAR chNew );
int Replace( LPCTSTR lpszOld, LPCTSTR lpszNew );
返回值
返回被替换的字符数。如果这个字符串没有改变则返回零。
参数
chOld
要被chNew 替换的字符。
chNew
要用来替换chOld 的字符。
lpszOld
一个指向字符串的指针，该字符串包含了要被lpszNew 替换的字符。
lpszNew
一个指向字符串的指针，该字符串包含了要用来替换lpszOld 的字符。
说明
此成员函数用一个字符替换另一个字符。函数的第一个原形在字符串中用chNew 现场替换chOld。函数的第二个原形用lpszNew 指定的字符串替换lpszOld 指定的子串。
在替换之后，该字符串有可能增长或缩短；那是因为lpszNew 和lpszOld 的长度不需要是相等的。两种版本形式都进行区分大小写的匹配。
示例
// 第一个例子，old 和new 具有相同的长度。
CString strZap( “C - -” );
int n = strZap.Replace('-', '+' );
ASSERT( n == 2 );
ASSERT(strZap == “C++” );
// 第二个例子，old 和new 具有不同的长度。
CString strBang( “Everybody likes ice hockey” );
n = strBang.Replace( “hockey”, “golf” );
ASSERT( n ==1 );
n = strBang.Replace ( “likes” , “plays” );
ASSERT( n == 1 );
n = strBang.Replace( “ice”, NULL );
ASSERT( n == 1 );
ASSERT( strBang == “Everybody plays golg” );
// 注意，现在在你的句子中有了一个额外的空格。
// 要移走这个额外的空格，可以将它包括在要被替换的字符串中，例如，“ice ”。
CString::ReverseFind
int ReverseFind( TCHAR ch ) const;
返回值
返回此CString 对象中与要求的字符匹配的最后一个字符的索引；如果没有找
到需要的字符则返回-1。
参数
ch
要搜索的字符。
说明
此成员函数在此CString 对象中搜索与一个子串匹配的最后一个字符。此函数
类似于运行时函数strrchr。
示例
// CString::ReverseFind 示例
CString s( " abcabc" );
ASSERT( s.ReverseFind( 'b' ) == 4 );
CString::Right
CString Right( int nCount ) const;
throw( CMemoryException );
返回的字符串是最后nCount个字符。
CString s( _T(" abcdef" ) );
ASSERT( s.Right(2) == _T(" ef" ) );
CString:: SetAt
void SetAt( int nIndex, TCHAR ch );
你可以把字符串理解为一个数组，SetAt类似于[].注意nIndex的范围，如果不合适会有调试错误。Ch 更替字符, 把nIndex位置上的字符变成ch
CString s( " abc" );
s.MakeReverse();
ASSERT( s == " cba" );
CString::TrimLeft
void TrimLeft( );
void CString::TrimLeft( TCHAR chTarget );
如果没有参数,从左删除字符(\n\t空格等),至到遇到一个非此类字符. 当然你也可以指定删除那些字符. 如果指定的参数是字符串,那么遇上其中的一个字符就删除.
\n 换行符
\t TAB字符
CString str = " \n\t a" ;
str.TrimLeft();
str为“a”;
CString str = " abbcadbabcadb " ;
str.TrimLeft(" ab" );
结果" cadbabcadb "
str.TrimLeft(" ac" );
结果" bcadbabcadb "
CString::TrimRight
void TrimRight( );
void CString::TrimRight( TCHAR chTarget );
void CString::TrimRight( LPCTSTR lpszTargets );
>
CString位于头文件afx.h中。
CString 是一种很有用的数据类型。它们很大程度上简化了MFC中的许多操作，使得MFC在做字符串操作的时候方便了很多。不管怎样，使用CString有很多特殊的技巧，特别是对于纯C背景下走出来的程序员来说有点难以学习。这篇文章就来讨论这些技巧。
使用CString可以让你对字符串的操作更加直截了当。这篇文章不是CString的完全手册，但囊括了大部分常见基本问题。
这篇文章包括以下内容：
CString 对象的连接
格式化字符串（包括int 型转化为CString ）
CString 型转化成int 型
CString 型和char* 类型的相互转化
char* 转化成CString
CString 转化成char* 之一：使用LPCTSTR强制转化
CString 转化成char* 之二：使用CString对象的GetBuffer方法
CString 转化成char* 之三: 和控件的接口
CString 型转化成BSTR 型；
BSTR 型转化成CString 型；
VARIANT 型转化成CString 型；
载入字符串表资源；
CString 和临时对象；
CString 的效率；
总结
下面我分别讨论。
[编辑本段]
1、CString 对象的连接
能体现出CString 类型方便性特点的一个方面就是字符串的连接，使用CStrin
If语句相关训练 1. （标识符命名）下面几个变量中，那些是对的那些是错的错的请说明理由（CDF） A. ILoveJava B. $20 C. learn@java D. E. Hello_World F. 2tigers 答：标识符中不能有@，不能含有点号，开头只能是字母和$ 2. （Java 程序的编译与运行）假设有如下程序： package public class HelloWorld{ public static void main(String args[]){ "Hello World"); } } 问： 1）假设这个代码存在文件中，那这个程序能够编译通过为什么 如果编译不通过，应该如何改进 答：不能，含有public的类文件名必须要和类名一致；应将改写成 2）假设这个.java 文件放在C:\javafile\目录下，CLASSPATH=.，则生成的.class 文件应该放在什么目录下如何运行 答：.class应该存放在C:\javafile\目录下 3. （if 语句）读入一个整数，判断其是奇数还是偶数 public class Test { int n; If(n%2==0){ 是偶数”); }else{ 是奇数”); } } 4. （操作符）有如下代码： int a = 5; int b = (a++) + (--a) +(++a); 问执行完之后，b 的结果是多少 答：16 解析a先把5赋值给b让后再自增1相当于（b=5+(--6)+(++5)）
5. （基本类型的运算）一家商场在举行打折促销，所有商品都进行8 折优惠。一 位程序员把这个逻辑写成： short price = ...; （操作符）有如下代码： a = (a>b)a:b; 请问这段代码完成了什么功能。 答：这段代码的作用是取最大值，当a>b成立时，a=a;当a>b不成立时，a=b; 8. （if 语句）读入一个整数，表示一个人的年龄。如果小于6 岁，则输出“儿童”，6 岁到13 岁，输出“少儿”；14 岁到18 岁，输出“青少年”；18 岁到35 岁，输出“青年”；35 岁到50 岁，输出“中年”；50 岁以上输出“中老年”。 答：public class AgeTest { public static void main(String[] args) { int n=12; if(n<6){
都是一些非常非常基础的题，是我最近参加各大IT公司笔试后靠记忆记下来的，经过整理献给与我一样参加各大IT校园招聘的同学们，纯考Java基础功底，老手们就不用进来了，免得笑话我们这些未出校门的孩纸们，但是IT公司就喜欢考这些基础的东西，所以为了能进大公司就~~~当复习期末考吧。花了不少时间整理，在整理过程中也学到了很多东西，请大家认真对待每一题~~~ 下面都是我自己的答案非官方，仅供参考，如果有疑问或错误请一定要提出来，大家一起进步啦~~~ 1. 下面哪些是Thread类的方法（） A start() B run() C exit() D getPriority() 答案：ABD 解析：看Java API docs吧：https://www.doczj.com/doc/7212658806.html,/javase/7/docs/api/，exit()是System类的方法，如System.exit(0)。 2. 下面关于https://www.doczj.com/doc/7212658806.html,ng.Exception类的说法正确的是（） A 继承自Throwable B Serialable CD 不记得，反正不正确 答案：A 解析：Java异常的基类为https://www.doczj.com/doc/7212658806.html,ng.Throwable，https://www.doczj.com/doc/7212658806.html,ng.Error和https://www.doczj.com/doc/7212658806.html,ng.Exception继承Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承RuntimeException。扩展：错误和异常的区别(Error vs Exception) 1) https://www.doczj.com/doc/7212658806.html,ng.Error: Throwable的子类，用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的，就根本不该出现的。 https://www.doczj.com/doc/7212658806.html,ng.Exception: Throwable的子类，用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件，而非严重错误，并且鼓励用户程序去catch它。 2) Error和RuntimeException及其子类都是未检查的异常（unchecked exceptions），而所有其他的Exception 类都是检查了的异常（checked exceptions）. checked exceptions: 通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。 unchecked exceptions: 通常是如果一切正常的话本不该发生的异常，但是的确发生了。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。因此， 面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。 RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等。
Java中String类的方法详解 JJava中String 类的方法及说明 String : 字符串类型 一、构造函数 String(byte[ ]bytes )：通过byte数组构造字符串对象。 String(char[ ]value )：通过char数组构造字符串对象。 String(Sting original )：构造一个original的副本。即：拷贝一个original。 String(StringBuffer buffer )：通过StringBuffer数组构造字符串对象。例如： byte[] b = {'a','b','c','d','e','f','g','h','i','j'}; char[] c = {'0','1','2','3','4','5','6','7','8','9'}; String sb = new String(b); //abcdefghij String sb_sub = new String(b,3/*offset*/,2/*length*/); //de String sc = new String(c); //0123456789 String sc_sub = new String(c,3,2); //34 String sb_copy = new String(sb); //abcdefghij System.out.println("sb:"+sb); System.out.println("sb_sub:"+sb_sub); System.out.println("sc:"+sc); System.out.println("sc_sub:"+sc_sub); System.out.println("sb_copy:"+sb_copy); 输出结果：sb:abcdefghij sb_sub:de sc:0123456789 sc_sub:34 sb_copy:abcdefghij 二、方法： 说明：①、所有方法均为public。 ②、书写格式： [修饰符] <返回类型><方法名([参数列表])> 0.public static int parseInt(String s) public static byte parseByte(String s) public static boolean parseBoolean(String s) public static short parseShort(String s) public static long parseLong(String s) public static double parseDouble(String s) 例如:可以将“数字”格式的字符串，转化为相应的基本数据类型 int i=Integer.pareInt(“123”)
C++ string 详解 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用= 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 好了，进入正题……… 首先，为了在我们的程序中使用string类型，我们必须包含头文件
C++ string介绍 char*的字符串和C++标准程序库中的string类相比，后者不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 好了，进入正题………- 首先，为了在我们的程序中使用string类型，我们必须包含头文件。如下： #include //注意这里不是string.h string.h是C字符串头文件 1．声明一个C++字符串 声明一个字符串变量很简单： string Str; 这样我们就声明了一个字符串变量，但既然是一个类，就有构造函数和析构函数。上面的声明没有传入参数，所以就直接使用了string的默认的构造函数，这个函数所作的就是把Str初始化为一个空字符串。String类的构造函数和析构函数如下： a) string s; //生成一个空字符串s b) string s(str) //拷贝构造函数生成str的复制品 c) string s(str,stridx) //将字符串str内“始于位置stridx”的部分当作字符串的初值 d) string s(str,stridx,strlen) //将字符串str内“始于stridx且长度顶多strlen”的部分作为字符串的初值 e) string s(cstr) //将C字符串作为s的初值 f) string s(chars,chars_len) //将C字符串前chars_len个字符作为字符串s的初值。 g) string s(num,c) //生成一个字符串，包含num个c字符 h) string s(beg,end) //以区间beg;end(不包含end)内的字符作为字符串s的初值 i) s.~string() //销毁所有字符，释放内存 都很简单，我就不解释了。 2．字符串操作函数 这里是C++字符串的重点，我先把各种操作函数罗列出来，不喜欢把所有函数都看完的人可以在这里找自己喜欢的函数，再到后面看他的详细解释。 a) =,assign() //赋以新值
Java基础语句作业详解及答案 1.编写程序，用数组实现乘法小九九的存储和输出。【提示：采用多个一维数组。】 public class Multipation { public static void main(String[] args) { // TODO Auto-generated method stub int x[][]=new int[9][9]; for(int i=0;i<9;i++){ for(int j=0;j<9;j++){ if(i>=j){ int m=i+1; int n=j+1; x[i][j]=m*n; System.out.print(m+"*"+n+"="+x[i][j]); } } System.out.println(); } } }
2. 定义一个类Student，属性为学号、姓名和成绩；方法为增加记录SetRecord和得到记录GetRecord。SetRecord给出学号、姓名和成绩的赋值，GetRecord通过学号得到考生的成绩。public class Student { /** *@param args */ private int ID; private String name; private float score; public void SetRecord(int ID,String name,float score){ this.ID=ID; https://www.doczj.com/doc/7212658806.html,=name; this.score=score; } public float getRecord(int ID){ if(ID==this.ID) return this.score; else return -1; } public static void main(String[] args) { // TODO Auto-generated method stub Student s=new Student(); s.SetRecord(0,"alex",100); float Sco=s.getRecord(0); System.out.print(Sco); } }
Java注解(Annotation)
(1) Annotation(注释)是JDK5.0及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。 元数据的作用 如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类： 编写文档：通过代码里标识的元数据生成文档。 代码分析：通过代码里标识的元数据对代码进行分析。 编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。 基本内置注释 @Override Java代码 1. package com.iwtxokhtd.annotation; 2. /** 3. * 测试Override注解 4. * @author Administrator 5. * 6. */ 7. public class OverrideDemoTest { 8. 9. //@Override 10. public String tostring(){ 11. return "测试注释"; 12. } 13. } package com.iwtxokhtd.annotation; /** * 测试Override注解 * @author Administrator * */ public class OverrideDemoTest { //@Override
https://www.doczj.com/doc/7212658806.html,/bidepan2023/blog/item/5f49bda4468e91f09052eedc.ht ml LUA string库详解 2009-01-09 18:33 string.byte (s [, i]) Returns the internal numerical code of the i-th character of s, or nil if the index is out of range. If i is absent, then it is assumed to be 1. i may be negative. Note that numerical codes are not necessarily portable across platforms. string.char (i1, i2, ...) Receives 0 or more integers. Returns a string with length equal to the number of arguments, in which each character has the internal numerical code equal to its correspondent argument. Note that numerical codes are not necessarily portable across platforms. 1. string库中所有的字符索引从前往后是1,2,...;从后往前是-1,-2,... 2. string库中所有的function都不会直接操作字符串，而是返回一个结果 s = "[abc]" string.len(s) <==返回5 string.rep("abc", 2) <==返回"abcabc" string.lower("ABC") <==返回"abc" string.upper("abc") <==返回"ABC" string.sub(s, 2) <==返回"abc]" string.sub(s, -2) <==返回"c]" string.sub(s, 2, -2) <==返回"abc" string.format(fmt, ...)返回一个类似printf的格式化字符串 string.find(s, pattern, pos) 第1个参数：源字符串 第2个参数：待搜索之模式串 第3个参数：A hint, 从pos位置开始搜索 找到匹配返回：匹配串开始和结束的位置，否则返回nil 简单的模式串 s = "hello world" i, j = string.find(s, "hello") print(i, j) --> 1 5 print(string.sub(s, i, j)) --> hello print(string.find(s, "world")) --> 7 11 i, j = string.find(s, "l")
第1章 Java开发入门 一、填空题 1、Java EE、Java SE、Java ME 2、JRE 3、javac 4、bin 5、path、classpath 二、选择题 1、ABCD 2、C 3、D 4、B 5、B 三、简答题 1、面向对象、跨平台性、健壮性、安全性、可移植性、多线程性、动态性等。 2、JRE（Java Runtime Environment，Java运行时环境），它相当于操作系统部分，提供了Java程 序运行时所需要的基本条件和许多Java基础类，例如，IO类、GUI控件类、网络类等。JRE是提供给普通用户使用的，如果你只想运行别人开发好的Java程序，那么，你的计算机上必须且只需安装JRE。 JDK（Java Development Kit，Java开发工具包），它包含编译工具、解释工具、文档制作工具、打包工具多种与开发相关的工具，是提供给Java开发人员使用的。初学者学习和使用Java语言时，首先必须下载和安装JDK。JDK中已经包含了JRE部分，初学者安装JDK后不必再去下载和安装JRE了。 四、编程题 public class HelloWorld { public static void main(String[] args) { System.out.println("这是第一个Java程序！"); } } 第2章 Java编程基础 一、填空题 1、 class 2、 true和false 3、单行注释、多行注释、文档注释 4、基本数据类型、引用数据类型 5、 1、2、4、8 6、 & && | || 7、 0 8、 5 9、 34 10、56 二、判断题 1、错 2、对 3、错 4、对 5、错
java笔试题以及答案详解一 一、单项选择题 1．Java是从（）语言改进重新设计。 A．Ada B．C++ C．Pasacal D．BASIC 答案：B 2．下列语句哪一个正确（） A．Java程序经编译后会产生machine code B．Java程序经编译后会产生byte code C．Java程序经编译后会产生DLL D．以上都不正确 答案：B 3．下列说法正确的有（） A．class中的constructor不可省略 B．constructor必须与class同名，但方法不能与class同名 C．constructor在一个对象被new时执行 D．一个class只能定义一个constructor 答案：C 详解：见下面代码，很明显方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。
4．提供Java存取数据库能力的包是（） A．java.sql B．java.awt C．https://www.doczj.com/doc/7212658806.html,ng D．java.swing 答案：A 5．下列运算符合法的是（） A．&& B．<> C．if D．:= 答案：A 详解： 6．执行如下程序代码 a=0;c=0; do{ --c; a=a-1;
}while(a>0); 后，C的值是（） A．0 B．1 C．-1 D．死循环 答案：C 详解： 7．下列哪一种叙述是正确的（） A．abstract修饰符可修饰字段、方法和类 B．抽象方法的body部分必须用一对大括号{ }包住C．声明抽象方法，大括号可有可无 D．声明抽象方法不可写出大括号 答案：D 详解： 8．下列语句正确的是（） A．形式参数可被视为local variable B．形式参数可被字段修饰符修饰 C．形式参数为方法被调用时，真正被传递的参数 D．形式参数不可以是对象 答案：A 详解：
String和string的区别 从位置讲： 1.String是.NET Framework里面的String，小写的string是C#语言中的string 2.如果把using System;删掉，没有大写的String了，System是.NET Framework 类库中的一个函数名. 从性质讲： 1.string是关键字，String是类，string不能作为类、结构、枚举、字段、变量、 方法、属性的名称 2.用C#编写代码的情况下尽量使用小写的string，比较符合规范，如果在追求效率 的情况下可以使用大写的String，因为最终通过编译后，小写的string会变成大写的String，可以给编译减少负荷，从而运行效率提高。 3.string 类型表示Unicode 字符的字符串，string 是 .NET Framework 中的 String 的别名，对字符串相等性的测试更为直观 string详解： s tring s = string.Empty：一个指向空字符串的字符串变量, s不占用存储空间.s变量可以使用,比如s.Length string s = "";一个指向"\0"的空字符串, 占用一个字节存储空间,因为转义符\0代表字符串结束.s变量可以使用,比如s.Length string s = null; 一个指不向任何一个存储空间的变量,s不可以使用 单个字符分割： string s="abcdeabcdeabcde"; string[] sArray=s.Split('c'); foreach(string i in sArray) Console.WriteLine(i.ToString()); 输出下面的结果: ab deab deab de 多个字符分割:
C++中针对C语言中处理字符串的难题，在标准库中设计了string类，因此现在编程中涉及到字符串的处理，就可以直接使用string类了。 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 首先，为了在我们的程序中使用string类型，我们必须包含头文件。如下： #include
https://www.doczj.com/doc/7212658806.html, web前端培训教程：String类型的属性和内置方法 String 类型包含了三个属性和大量的可用内置方法。 String 也包含对象的通用方法，比如valueOf()、toLocaleString()和toString()方法，但这些方法都返回字符串的基本值。 var box = 'Mr.Lee'; alert(box.charAt(1)); //r alert(box.charCodeAt(1)); //114
https://www.doczj.com/doc/7212658806.html, alert(box[1]); //r，通过数组方式截取 PS：box[1]在IE 浏览器会显示undefined，所以使用时要慎重。 var box = 'Mr.Lee'; alert(box.concat(' is ', ' Teacher ', '!')); //Mr.Lee is Teacher ! alert(box.slice(3)); //Lee alert(box.slice(3,5)); //Le alert(box.substring(3)); //Lee alert(box.substring(3,5)); //Le alert(box.substr(3)); //Lee alert(box.substr(3,5)); //Lee var box = 'Mr.Lee'; alert(box.slice(-3)); //Lee，6+(-3)=3 位开始 alert(box.substring(-3)); //Mr.Lee 负数返回全部 alert(box.substr(-3)); //Lee，6+(-3)=3 位开始 var box = 'Mr.Lee'; alert(box.slice(3, -1)); //Le 6+(-1)=5, (3,5) alert(box.substring(3, -1)); //Mr. 第二参为负，直接转0，
在看C++编程思想中，每个练习基本都是使用ofstream,ifstream,fstream，以前粗略知道其用法和含义，在看了几位大牛的博文后，进行整理和总结： 这里主要是讨论fstream的内容： [java]view plaincopyprint? 1.#include
之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 首先，为了在我们的程序中使用string类型，我们必须包含头文件
Java注解(Annotation) (1) Annotation(注释)是及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注释是以‘@注释名’在代码中存在的，根据注释参数的个数，我们可以将注释分为：标记注释、单值注释、完整注释三类。它们都不会直接影响到程序的语义，只是作为注释（标识）存在，我们可以通过反射机制编程实现对这些元数据的访问。另外，你可以在编译时选择代码里的注释是否只存在于源代码级，或者它也能在class文件中出现。 元数据的作用 如果要对于元数据的作用进行分类，目前还没有明确的定义，不过我们可以根据它所起的作用，大致可分为三类： 编写文档：通过代码里标识的元数据生成文档。 代码分析：通过代码里标识的元数据对代码进行分析。 编译检查：通过代码里标识的元数据让编译器能实现基本的编译检查。 基本内置注释 @Override Java代码 1. package 2. /** 3. * 测试Override注解
4. * @author Administrator 5. * 6. */ 7. public class OverrideDemoTest { 8. 9. public String tostring(){ 11. return "测试注释"; 12. } 13. } package /** * 测试Override注解 * @author Administrator * */ public class OverrideDemoTest { package 2. /** 3. * 测试Deprecated注解 4. * @author Administrator 5. * 6. */ 7. public class DeprecatedDemoTest { 8. public static void main(String[] args) {
c++string函数的用法 之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用= 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 首先，为了在我们的程序中使用string类型，我们必须包含头文件
相等性的比较 1)对于原生数据类型，比较的是左右两边的值是否相同 2)对于引用类型的话，比较引用是否指向同一个对象，即引用的地址是否一致。 2.j https://www.doczj.com/doc/7212658806.html,ng.Object类 当打印引用是，实际上是打印引用对象的toString()的返回值。 每个类都继承了Object 所以每个类多有这个toString方法。每个类都可以覆写这个方法。 3.比较的内容，比较的值。比较的是引用 String str = new String(“a”); String str 1= new String(“a”); str!=str1;但是str.equals(str1);内容是相同的。 这时比较的是对象的地址值。两个是不同的。 String str =”a”; String str1 = “a”; 这时比较的是值，所以是相等的。 String str = new String(“a”); String str1 = “a”; 不同的数据类型是不同的。。。 Equals()方法，定义于Object中的，每个类中都有这个方法。调用eequals 的方法与传进来的对象是否一致。同一个对象。 String 把equals覆写了 源代码的文件在src.zip中。。。。。。。。字符串只要求是否内容一致。
覆写的这个方法的时候可以参照这种模式来书写。内容。 首先判断是否是同一个对象。 然后进行强制类型转换 然后进行比较相应的内容 对于STRING 对象的比较，请使用EQUALS()方法而不是所以用==。。。 比较EQUALS 和==的比较区别。。。当类中没有覆写这个方法时就可以默认这两个形式是相同的。 法的时候可String是常量，其对象一旦创建完毕就无法改变。 使用+ 拼接时候，会生成新的的String对象而不是在原有的字符串上追加，原来的字符串不变。 String池pool。 String s = “a”;(这种称为字面值赋值方式) 1) 查找String 中是否有这个”a”这个字符，如果没有，在String池中创建一个”a”对象，然后把这个”a”的地址反回来，这样s就会指向”a”字符串对象 2) 如果已经有了这个字符串就不再创建了，直接把”a”的对象地址返回给s 5.String s = new String(“a”); New 就是创建一个对象。 1） 如果字符串已经有，则就在堆中创建一个对象，不在String Pool中创建。返回这个对象的地址给这个引用 2) 如果没有，则先在Stirng Pool 中创建一个”a”对象，然后在堆中创建一个”a”对象然后把对象的地址返回，赋值给引用，使得引用指向了堆中指向的对象 Str.intern(); 如果String Pool中没有str字符串，就在池中创建这个。然后返回。 Strings are constant; their values cannot be changed after they are created. String buffers support mutable strings. Because String objects are immutable they can be shared.