C/C++ 字符串 总结

admin 2014年06月08日 C C# C++学习 627次阅读 查看评论

1 字符基础

1.1 单字节字符集(single-byte character set(SBCS))

顾名思义,在这种模式下,所有的字符都只用一个字节表示,常见的如,ASCII

1.2 多字节字符集(multi-byte character set(MBCS))

在Windows中MBCS包含两种字符类型,单字节字符和双字节字符.由于windows使用的多字节字符绝大部分是两个字节长,所以MBCS常被DBCS代替。

1.3 unicode

Unicode是一种所有的字符都使用两个字节编码的编码模式。Unicode字符有时也被称作宽字符,因为它比单子节字符宽(使用了更多的存储空间)。

常见的为utf-8,还有一个比较少用的是utf-16

1.3.1 utf-8 BOM头

浏览器中或某些文本编辑器中会给utf-8 文本 加上bom头。在程序读取的过程中需要去掉BOM头否则会出现乱码。

BOM 格式为: EF BB BF,10进制格式为:-17 -69 -65

Utf8去BOM头的方法:

1
2
3
4
5
6
7
8
9
10
11
12
string Utf8DeBOM(string s) {
    int c1 = s[0];
    int c2 = s[1];
    int c3 = s[2];
 
    if (c1 == -17 && c2 == -69 && c3 == -65)
    {
        s = s.substr(3, s.length());   
    }
 
    return s;
}

2 C/C++/VC++中的字符串

2.1 C中的字符串

C语言中, 没有字符串的数据类型,使用一个以NULL('\0')字符结尾的字符数组来保存字符串。

char* p = "Hello world";

char* p = (char*)malloc (100 * sizeof(char));

char p[100] = "hello world";

2.2 C++ 中的字符串

C++ 语言中有单独字符串类型,在string头文件中,还有对应的宽字符串wstring.

string iStr = "Hello world";

wstring wStr = "Hello world";

2.3 VC ++ 中的字符串

在学Window是开发过程中最头疼的莫过于一堆字符串宏。

类型 MBCS 中含义 Unicode 中含义

TCHAR char wchar_t

WCHAR wchar _twchar_t

LPSTR char* char*

LPCWSTR const wchar_t* const wchar_t*

LPCSTR const char* const char*

LPWSTR wchar_t* wchar_t*

LPTSTR TCHAR* TCHAR*

LPCTSTR const TCHAR* const TCHAR*

char 标准c的字符类型(1Byte)
wchar_t 保存UNICODE字符集的类型(2Byte)

TCHAR的定义如下:

1
2
3
4
5
#ifdef UNICODE
typedef wchar_t TCHAR;
#else
typedef char TCHAR;
#endif

再了解一个宏_T(),使用宏_T(),使代码有了unicode的意识。

1
2
3
4
#ifdef UNICODE
#define _T(x) L##x
#else
#define _T(x) x

3 标准C++ 字符串操作

3.1 构造方法

string(const char *s); //用c字符串s初始化

string(int n,char c); //用n个字符c初始化

此外,string类还支持默认构造函数和复制构造函数,如string s1;string s2="hello";都是正确的写法。当构造的string太长而无法表达时会抛出length_error异常

3.2 操作方法

3.2.1 字符操作

const char &operator[](int n)const; // 索引操作,取单个字符

const char &at(int n)const;// 同上

char &operator[](int n);//同上

char &at(int n);//同上

operator[]和at()均返回当前字符串中第n个字符的位置,但at函数提供范围检查,当越界时会抛出out_of_range异常,下标运算符[]不提供检查访问。


const char *data()const;//返回一个非null终止的c字符数组

const char *c_str()const;//返回一个以null终止的c字符串

int copy(char *s, int n, int pos = 0) const;//把当前串中以pos开始的n个字符拷贝到以s为起始位置的字符数组中,返回实际拷贝的数目

3.2.2 string的特性描述

int capacity()const; //返回当前容量(即string中不必增加内存即可存放的元素个数)

int max_size()const; //返回string对象中可存放的最大字符串的长度

int size()const; //返回当前字符串的大小

int length()const; //返回当前字符串的长度

bool empty()const; //当前字符串是否为空

void resize(int len,char c);//把字符串当前大小置为len,并用字符c填充不足的部分

 

3.2.3 string类的输入输出操作

string类重载运算符operator>>用于输入,同样重载运算符operator<<用于输出操作。

函数getline(istream &in,string &s);用于从输入流in中读取字符串到s中,以换行符'\n'分开。

3.2.4 string的赋值

string &operator=(const string &s);//把字符串s赋给当前字符串

string &assign(const char *s);//用c类型字符串s赋值

string &assign(const char *s,int n);//用c字符串s开始的n个字符赋值

string &assign(const string &s);//把字符串s赋给当前字符串

string &assign(int n,char c);//用n个字符c赋值给当前字符串

string &assign(const string &s,int start,int n);//把字符串s中从start开始的n个字符赋给当前字符串

string &assign(const_iterator first,const_itertor last);//把first和last迭代器之间的部分赋给字符串

3.2.5 string的连接

string &operator+=(const string &s);//把字符串s连接到当前字符串的结尾

string &append(const char *s); //把c类型字符串s连接到当前字符串结尾

string &append(const char *s,int n);//把c类型字符串s的前n个字符连接到当前字符串结尾

string &append(const string &s); //同operator+=()

string &append(const string &s,int pos,int n);//把字符串s中从pos开始的n个字符连接到当前字符串的结尾

string &append(int n,char c); //在当前字符串结尾添加n个字符c

string &append(const_iterator first,const_iterator last);//把迭代器first和last之间的部分连接到当前字符串的结尾

3.2.6 string的比较

bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等

运算符">","<",">=","<=","!="均被重载用于字符串的比较;

int compare(const string &s) const;//比较当前字符串和s的大小

int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小

int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小

int compare(const char *s) const;

int compare(int pos, int n,const char *s) const;

int compare(int pos, int n,const char *s, int pos2) const;

compare函数在>时返回1,<时返回-1,==时返回0

3.2.7 string的子串

string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串

3.2.8 string的交换

void swap(string &s2); //交换当前字符串与s2的值

3.2.9 string类的查找函数

int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//查找成功时返回所在位置,失败返回string::npos的值
int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;
//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置,成功返回所在位置,失败时返回string::npos的值
int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos
int find_first_not_of(char c, int pos = 0) const;
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos,int n) const;
int find_first_not_of(const string &s,int pos = 0) const;
//从当前串中查找第一个不在串s中的字符出现的位置,失败返回string::npos
int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const;
int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s,int pos = npos) const;
//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似,只不过是从后向前查找

3.2.10 string类的替换函数

string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符,然后在p0处插入串s
string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符,然后在p0处插入字符串s的前n个字符
string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符,然后在p0处插入串s
string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符,然后在p0处插入串s中从pos开始的n个字符
string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符,然后在p0处插入n个字符c
string &replace(iterator first0, iterator last0,const char *s);//把[first0,last0)之间的部分替换为字符串s
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0,last0)之间的部分替换为s的前n个字符
string &replace(iterator first0, iterator last0,const string &s);//把[first0,last0)之间的部分替换为串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0,last0)之间的部分替换为n个字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0,last0)之间的部分替换成[first,last)之间的字符串

3.2.11 string类的插入函数

string &insert(int p0, const char *s);
string &insert(int p0, const char *s, int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s, int pos, int n);
//前4个函数在p0位置插入字符串s中pos开始的前n个字符
string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
iterator insert(iterator it, char c);//在it处插入字符c,返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first,last)之间的字符
void insert(iterator it, int n, char c);//在it处插入n个字符c

3.2.12 string类的删除函数

iterator erase(iterator first, iterator last);//删除[first,last)之间的所有字符,返回删除后迭代器的位置
iterator erase(iterator it);//删除it指向的字符,返回删除后迭代器的位置
string &erase(int pos = 0, int n = npos);//删除pos开始的n个字符,返回修改后的字符串

3.2.13 string类的迭代器处理

string类提供了向前和向后遍历的迭代器iterator,迭代器提供了访问各个字符的语法,类似于指针操作,迭代器不检查范围。
用string::iterator或string::const_iterator声明迭代器变量,const_iterator不允许改变迭代的内容。常用迭代器函数有:
const_iterator begin()const;
iterator begin(); //返回string的起始位置
const_iterator end()const;
iterator end(); //返回string的最后一个字符后面的位置
const_iterator rbegin()const;
iterator rbegin(); //返回string的最后一个字符的位置
const_iterator rend()const;
iterator rend(); //返回string第一个字符位置的前面
rbegin和rend用于从后向前的迭代访问,通过设置迭代器string::reverse_iterator,string::const_reverse_iterator实现

3.2.14 字符串流处理

通过定义ostringstream和istringstream变量实现,头文件中
例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
string input("hello,this is a test");
     istringstream is(input);
     string s1,s2,s3,s4;
     is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"
     ostringstream os;
     os<<s1<<s2<<s3<"" pre="">

 

3.2.15   字符串分割函数

 

class="brush:java;">vectorsplit(string& str,const char* c)
{
    char * p;
    vector res;
    p = strtok(const_cast<char*>(str.c_str()),c);
    while(p!=NULL)
    {
        res.push_back(p);
        p = strtok(NULL,c);
    }
    return res;
}char*>

 

3.2.16 字符串替换函数

 

class="brush:java;">void Replace(std::string&srcstr,const std::string&oldstr,const std::string&newstr)
    {
        string::size_type pos=0;
        string::size_type a=oldstr.size();
        string::size_type b=newstr.size();
        while((pos=srcstr.find(oldstr,pos))!=string::npos)
        {
            srcstr.replace(pos,a,newstr);
            pos+=b;
        }
    }

 

3.2.17 字符串的Trim方法

 

 

class="brush:java;">std::string TrimLeft(const std::string& str) {
        std::string t = str;
        for (std::string::iterator i = t.begin(); i != t.end(); i++) {
            if (!isspace(*i)) {
                t.erase(t.begin(), i);
                break;
            }
        }
        return t;
    }
 
    std::string TrimRight(const std::string& str) {
        if (str.begin() == str.end()) {
            return str;
        }
        std::string t = str;
        for (std::string::iterator i = t.end() - 1; i != t.begin(); i--) {
            if (!isspace(*i)) {
                t.erase(i + 1, t.end());
                break;
            }
        }
        return t;
    }
 
    std::string Trim(const std::string& str) {
        std::string t = str;
 
        std::string::iterator i;
        for (i = t.begin(); i != t.end(); i++) {
            if (!isspace(*i)) {
                t.erase(t.begin(), i);
                break;
            }
        }
        if (i == t.end()) {
            return t;
        }
 
        for (i = t.end() - 1; i != t.begin(); i--) {
            if (!isspace(*i)) {
                t.erase(i + 1, t.end());
                break;
            }
        }
        return t;
    }

 

4 字符串转换

4.1   string, char* , const char*   相互转化

 

class="brush:java;">char * s = "hello world";
    const char * cs = "world";
    string str;
    str = s; // char* -> string
    s = const_cast<char*>(cs); // const char* -> char*
    cs = s;// char* -> const char*
    s = const_cast<char*>(str.c_str());// string -> const char* -> char*

 

4.1  整形和字符串相互转化

 

 

class="brush:java;">// unsigned int to string 。用以取代atoi
static inline string Int2Str(unsigned int value)
{
    string result;
    stringstream buffer;
    buffer << std::dec << value;  
    buffer >> result;
    return result;
}
 
// string to unsigned int
static inline unsigned int Str2Int(string value)
{
    unsigned int result;
    stringstream buffer;
    buffer << std::dec << value;
    buffer >> result; 
    return result;
}

 

4.1 16进制 数字和字符串相互转化

 

 

class="brush:java;">// unsigned int to hex string
static inline string Uint2StrHex(unsigned int value)
{
    string result;
    stringstream buffer;
    buffer << hex << value;  
    buffer >> result;
    return result;
}
 
// hex string to unsigned int
static inline unsigned int StrHex2Uint(string value)
{
    unsigned int result;
    stringstream buffer;
    buffer << hex << value;
    buffer >> result; 
    return result;
}

 

5 参考资料

http://www.cnblogs.com/fdyang/archive/2012/06/01/2858741.html

 

http://www.cnblogs.com/sexybear/p/Cpp_stringplus.html

 

http://www.cnblogs.com/Frandy/archive/2012/04/18/cpp_str_split.html

http://blog.csdn.net/beyondhaven/article/details/6679206

 

http://www.cnblogs.com/ider/archive/2011/07/22/cpp_cast_operator_part2.html

 


« 上一篇 下一篇 » admin原创文章,转载请注明出处! 标签:c语言C语言学习

相关日志:

«   2019年6月   »
12
3456789
10111213141516
17181920212223
24252627282930
控制面板
您好,欢迎到访网站!
  [查看权限]
网站分类
文章归档
网站收藏
友情链接
图标汇集