C++工程师必备的字符串操作技巧

在C++开发中，字符串操作是经常用到的操作之一。字符串操作的灵活应用，能够提高代码的效率，减少重复工作，以及让代码更加易于维护和升级。因此，作为C++工程师，熟练掌握字符串操作技巧，是十分必要的。本文将从多个方面对C++工程师需要掌握的字符串操作技巧进行详细的阐述。

一、字符串基本操作

字符串基本操作是C++工程师的基本功之一，掌握了这些操作，才能更好地实现具体的业务需求。常见的字符串基本操作函数有下面这些：

1. strlen函数

strlen函数用于求字符串的长度，其定义如下：

“`c++
size_t strlen(const char* str);
“`

str为一个指向C字符串的指针，函数的返回值是字符串的长度。

示例代码：

“`c++
#include
#include
using namespace std;

int main(){
const char* str = “Hello World!”;
cout<<"The length of the string is:"<<strlen(str)<<endl;
return 0;
}
“`

2. strcpy函数

strcpy函数用于将一个字符串复制到另一个字符串中，其定义如下：

“`c++
char* strcpy(char* dest, const char* src);
“`

dest为目标字符串的指针，src为源字符串的指针，函数的返回值为目标字符串的指针。

示例代码：

“`c++
#include
#include
using namespace std;

int main(){
char str1[20], str2[20];
strcpy(str1, “Hello World!”);
strcpy(str2, str1);
cout<<"str1:"<<str1<<endl;
cout<<"str2:"<<str2<<endl;
return 0;
}
“`

3. strcat函数

strcat函数用于将一个字符串连接到另一个字符串的末尾，其定义如下：

“`c++
char* strcat(char* dest, const char* src);
“`

dest为目标字符串的指针，src为源字符串的指针，函数的返回值为目标字符串的指针。

示例代码：

“`c++
#include
#include
using namespace std;

int main(){
char str1[20] = “Hello “, str2[20] = “World!”;
strcat(str1, str2);
cout<<str1<<endl;
return 0;
}
“`

二、字符串查找和替换

字符串查找和替换是字符串操作中的另一重要方面，能够帮助C++工程师更好地处理字符串中的信息，完成代码的具体业务需求。常用的字符串查找和替换函数有如下几个：

1. strstr函数

strstr函数用于查找一个字符串中是否包含另一个子字符串，其定义如下：

“`c++
char* strstr(const char* str1, const char* str2);
“`

str1为源字符串的指针，str2为待查找的子字符串的指针，函数的返回值为子字符串在源字符串中的指针，如果未找到，返回NULL。

示例代码：

“`c++
#include
#include
using namespace std;

int main(){
const char* str1 = “Hello World!”;
const char* str2 = “World”;
if(strstr(str1, str2)){
cout<<"Find! The position of str2 in str1:"<<strstr(str1, str2) – str1<<endl;
}
else{
cout<<"Not find!"<<endl;
}
return 0;
}
“`

2. str_replace函数

str_replace函数用于将一个字符串中的指定子字符串替换为另一个字符串，其定义如下：

“`c++
void str_replace(string& str, const string& old_value, const string& new_value);
“`

str为源字符串，old_value为需要替换的子字符串，new_value为替换后的子字符串。

示例代码：

“`c++
#include
#include
using namespace std;

void str_replace(string& str, const string& old_value, const string& new_value){
for(string::size_type pos = 0; pos != string::npos; pos += new_value.length()){
pos = str.find(old_value, pos);
if(pos != string::npos){
str.replace(pos, old_value.length(), new_value);
}
else{
break;
}
}
}

int main(){
string str = “Hello World!”;
string old_value = “World”;
string new_value = “Bob”;
str_replace(str, old_value, new_value);
cout<<str<<endl;
return 0;
}
“`

三、字符串分割和合并

字符串分割和合并是实现具体业务算法的重要基础，有时候需要对字符串进行分割或者合并处理，才能完成需要的算法操作。下面是常用的字符串分割和合并函数：

1. strtok函数

strtok函数用于将一个字符串根据指定的分隔符进行分割，其定义如下：

“`c++
char* strtok(char* str, const char* delim);
“`

str为待分割的字符串，delim为分隔符，函数返回分割后的字符串。需要注意的是，调用strtok函数时，需要先调用一次，后续的调用都传入NULL作为第一个参数。

示例代码：

“`c++
#include
#include
using namespace std;

int main(){
char str[] = “apple,banana,orange”;
char* p = strtok(str, “,”);
while(p){
cout<<p<<endl;
p = strtok(NULL, ",");
}
return 0;
}
“`

2. join函数

join函数用于将多个字符串进行合并，其定义如下：

“`c++
template
string join(const vector& vec, const char* delim);
“`

vec为待合并的字符串向量，delim为分隔符，函数返回合并后的字符串。

示例代码：

“`c++
#include
#include
#include
using namespace std;

template
string join(const vector& vec, const char* delim){
string result(“”);
for(typename vector::const_iterator iter=vec.begin(); iter!=vec.end(); ++iter){
result += *iter;
result += delim;
}
result.erase(result.length() – strlen(delim), strlen(delim));
return result;
}

int main(){
vector vec;
vec.push_back(“apple”);
vec.push_back(“banana”);
vec.push_back(“orange”);
cout<<join(vec, ",")<<endl;
return 0;
}
“`

四、字符串格式化和编解码

字符串格式化和编解码是字符串操作中的高级内容，能够更加灵活地操控字符串，使得代码更加高效和易于维护。下面是常见的字符串格式化和编解码函数：

1. sprintf函数

sprintf函数用于将一组数据，按照指定的格式输出到字符串中，其定义如下：

“`c++
int sprintf(char* str, const char* format, …);
“`

str为接收数据的字符串，format为格式化字符串，函数的返回值是输出到str中的字符数。

示例代码：

“`c++
#include
#include
using namespace std;

int main(){
char str[50];
sprintf(str, “%d %s %f”, 10, “Bob”, 1.5);
cout<<str<<endl;
return 0;
}
“`

2. base64编解码

base64编解码是将二进制数据使用64个字符表示的编码方式，常用于在网络传输中传递二进制数据。下面是base64编解码的实现方法：

示例代码：

“`c++
#include
#include
using namespace std;

static const string base64_chars =
“ABCDEFGHIJKLMNOPQRSTUVWXYZ”
“abcdefghijklmnopqrstuvwxyz”
“0123456789+/”;

string base64_encode(const char* bytes_to_encode, unsigned int in_len){
string ret;
int i = 0, j = 0;
unsigned char char_array_3[3], char_array_4[4];

while(in_len–){
char_array_3[i++] = *(bytes_to_encode++);
if(i == 3){
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
char_array_4[1] = ((char_array_3[0] & 0x03) <> 4);
char_array_4[2] = ((char_array_3[1] & 0x0f) <> 6);
char_array_4[3] = char_array_3[2] & 0x3f;

for(i = 0; i < 4; i++){
ret += base64_chars[char_array_4[i]];
}
i = 0;
}
}

if(i){
for(j = i; j > 2;
char_array_4[1] = ((char_array_3[0] & 0x03) <> 4);
char_array_4[2] = ((char_array_3[1] & 0x0f) <> 6);
char_array_4[3] = char_array_3[2] & 0x3f;

for(j = 0; j < i + 1; j++){
ret += base64_chars[char_array_4[j]];
}

while(i++ < 3){
ret += '=';
}
}

return ret;
}

string base64_decode(const string& encoded_string){
int in_len = encoded_string.size(), i = 0, j = 0, in_ = 0;
unsigned char char_array_4[4], char_array_3[3];
string ret;

while(in_len– && (encoded_string[in_] != '=') && is_base64(encoded_string[in_])){
char_array_4[i++] = encoded_string[in_];
in_++;

if(i == 4){
for(i = 0; i < 4; i++){
char_array_4[i] = base64_chars.find(char_array_4[i]);
}

char_array_3[0] = (char_array_4[0] <> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) <> 2);
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

for(i = 0; i < 3; i++){
ret += char_array_3[i];
}
i = 0;
}
}

if(i){
for(j = i; j < 4; j++){
char_array_4[j] = 0;
}

for(j = 0; j < 4; j++){
char_array_4[j] = base64_chars.find(char_array_4[j]);
}

char_array_3[0] = (char_array_4[0] <> 4);
char_array_3[1] = ((char_array_4[1] & 0xf) <> 2);

for(j = 0; j < i – 1; j++){
ret += char_array_3[j];
}
}

return ret;
}

bool is_base64(unsigned char c){
return (isalnum(c) || (c == '+') || (c == '/'));
}

int main(){
string str = "Hello World!";
string encoded = base64_encode(str.c_str(), str.length());
cout<<encoded<<endl;
string decoded = base64_decode(encoded);
cout<<decoded<<endl;
return 0;
}
“`

总结

本文中，我们详细地介绍了C++工程师需要掌握的字符串操作技巧。从字符串基本操作、字符串查找和替换、字符串分割和合并、字符串格式化和编解码四个方面，分别阐述了常用的字符串操作函数及其使用方法，并提供了相应的代码示例。通读全