郭老二

郭老二

关注
发信
关注(28)粉丝(399)

【C++】POCO学习总结（十五）：字符串操作

【C++】郭老二博文之：C++目录

1、简介

POCO提供一些函数来处理 std::string 和 std::wstring；
比如：

  • 去除空格
  • 大小写转换
  • 不区分大小写比较
  • 字符转换和子字符串替换
  • 连接

许多函数有两种变体:

  • 返回一个新字符串而不修改原字符串的函数;
  • 直接修改原始字符串的函数（函数名后面附加了inPlace）；
  • 所有函数都在Poco命名空间中。

2、去除空格

2.1 说明

  • std::[w]string trimLeft(const std::[w]string& str)：返回str副本，副本中的空格将被删除
  • std::[w]string& trimLeftInPlace(std::[w]string& str)：从str中删除的空格并返回对它的
  • std::[w]string trimRight(const std::[w]string& str)：返回str的副本，副本中的空格将被删除
  • std::[w]string trimRightInPlace(std::[w]string& str)：从str中删除空格并返回对它的
  • Std::[w]string trim(const Std::[w]string& str)：返回str的副本，副本中删除空格
  • std::[w]string trimInPlace(std::[w]string& str)：从str中删除空格，并返回对它的

2.2 用法

#include <Poco/String.h>
using Poco::trim;
using Poco::trimLeft;
using Poco::trimRight;
using Poco::trimRightInPlace;
int main(int argc, char** argv)
{
	std::string hello(" Hello, world! ");
	std::string s1(trimLeft(hello)); // "Hello, world! "
	trimRightInPlace(s1); // "Hello, world!"
	std::string s2(trim(hello)); // "Hello, world!"
	return 0;
}

3、大小写转换

3.1 说明

  • std::[w]string toUpper(const std::[w]string& str)：返回一个str的副本，其中所有字符都转换为
  • std::[w]string toLower(const std::[w]string& str)：返回一个str的副本，其中所有字符都转换为。
  • std::[w]string& toUpperInPlace(std::[w]string& str) ：将str中所有字符都转换为，并返回对它的
  • std::[w]string& toLowerInPlace(std::[w]string& str)：将str中所有字符都转换为，并返回对它的
  • int icompare(const std::[w]string& str1, const std::[w]string& str2)：不区分大小写的比较
    :这些函数不适用于UTF-8字符串。

3.2 用法

#include "Poco/String.h"
using Poco::toUpper;
using Poco::toLower;
using Poco::toLowerInPlace;
using Poco::icompare;
int main(int argc, char** argv)
{
	std::string hello("Hello, world!");
	std::string s1(toUpper(hello)); // "HELLO, WORLD!"
	toLowerInPlace(s1); // "hello, world!"
	int rc = icompare(hello, s1); // 0
	rc = icompare(hello, "Hello, Universe!"); // 1
	return 0;
}

4、替换、拼接

4.1 说明

1）替换字符

  • std::::[w]string translate(const std::[w]string& str, const std::[w]string& from, const std::[w]string& to)
    返回str的副本，其中from中的所有字符替换为to中相应的(按位置)字符。如果to中没有对应的字符，则删除该字符。
  • std::[w]string& translateInPlace(std::[w]string& str, const std::[w]string& from, const std::[w]string& to)
    返回修改后的str，其中from中的所有字符替换为to中相应的(按位置)字符。如果to中没有对应的字符，则删除该字符。

2）子字符串替换

  • std::[w]string replace(const std::[w]string& str, const std::[w]string& from, const std::[w]string& to)
    返回str的副本，其中出现from中给出的子字符串的所有都替换为to中给出的字符串。
  • std::[w]string& replaceInPlace(std::[w]string& str, const std::[w]string& from, const std::[w]string& to)
    返回修改后str，其中出现from中给出的子字符串的所有都替换为to中给出的字符串。

3）拼接

  • std::[w]string cat(const std::[w]string& s1, const std::[w]string& s2 [, const std::[w]string& s3 [,…]])
    最多连接六个字符串并返回结果
  • template <class S, class It>
    S cat(const S& delimiter, const It& begin, const It& end)
    连接[It, end]范围内的所有字符串，中间添加delimiter分隔符

4.2 用法

#include "Poco/String.h"
#include <vector>

using Poco::translateInPlace;
using Poco::replace;
using Poco::cat;

int main(int argc, char** argv)
{
	std::string s1("Eiffel Tower");
	translateInPlace(s1, "Eelo", "3310"); // "3iff31 T0w3r"

	std::string s2("aabbcc");
	std::string r(replace(s2, "aa", "AA")); // "AAbbcc"
	r = replace(s2, "bb", "xxx"); // "aaxxxcc"
	r = replace(s2, "bbcc", ""); // "aa"
	
	std::vector<std::string> colors;
	colors.push_back("red");
	colors.push_back("green");
	colors.push_back("blue");
	std::string s3;
	s3 = cat(std::string(", "), colors.begin(), colors.end()); //"red, green, blue"
	return 0;
}

5、Poco::NumberFormatter 数字格式化为字符串

Poco::NumberFormatter提供静态方法将数字格式化为字符串，其内部为使用std::sprintf()来实现

  • std::string format(int value)：格式化为一个十进制整数类型字符串
  • std::string format(int value, int width):格式化为一个十进制整数类型字符串，指定最小宽度width，不足时，右补
  • std::string format0(int value, int width)：格式化为一个十进制整数类型字符串，指定最小宽度width，不足时，右补充
  • std::string formatHex(int value)：格式化为一个十六进制的整数类型字符串
  • std::string formatHex(int value, int width)：式化为一个十六进制整数类型字符串，指定最小宽度width，不足时，右补充
  • std::string format(const void* ptr)：将指针ptr格式化为8位(32位系统)或16位(64系统)的字符串，十六进制形式
  • std::string format(double value)：格式化为十进制浮点表示法格式化浮点字符串，精度为八位小数
  • std::string format(double value, int precision)：格式化为十进制浮点数表示浮点字符串，带有精确的小数位数
  • std::string format(double value, int width, int precision)：格式化为十进制浮点数形式的浮点字符串，在指定宽度的字段中右对齐，带有精确的小数位数
#include "Poco/NumberFormatter.h"
using Poco::NumberFormatter;
int main(int argc, char** argv)
{
std::string s;
s = NumberFormatter::format(123); // "123"
s = NumberFormatter::format(123, 5); // " 123"
s = NumberFormatter::format(-123, 5); // " -123"
s = NumberFormatter::format(12345, 3); // "12345"
s = NumberFormatter::format0(123, 5); // "00123"
s = NumberFormatter::formatHex(123); // "7B"
s = NumberFormatter::formatHex(123, 4); // "007B"
s = NumberFormatter::format(1.5); // "1.5"
s = NumberFormatter::format(1.5, 2); // "1.50"
s = NumberFormatter::format(1.5, 5, 2); // " 1.50"
s = NumberFormatter::format(&s); // "00235F7D"
return 0;
}

6、Poco::NumberParser 从字符串中提取数字

Poco::NumberParser类的静态成员函数可用于从字符串中解析数字。

  • Int parse(const std::string& str)：从str中解析十进制形式的整数值，如果字符串不包含有效的数字，则抛出异常：SyntaxException。
  • bool tryParse(const std::string& str, int& value)：从str中解析十进制的整数值，并将其存储在value中。如果数字有效则返回true。否则返回false;在这种情况下Value是未定义的。
  • unsigned parseUnsigned(const std::string& str)：解析无符号的
  • bool tryParseUnsigned(const std::string& str, unsigned& value)
  • unsigned parseHex(const std::string& str)：解析十六进制
  • bool tryParseHex(const std::string& str, unsigned& value)
  • Int64 parse64(const std::string& str)：解析Int64
  • bool tryParse64(const std::string& str Int64& value)
  • UInt64 parseUnsigned64(const std::string& str)：解析无符号的UInt64
  • bool tryParseUnsigned64(const std::string& str UInt64& value)
  • UInt64 parseHex64(const std::string& str)：解析64位的十六进制
  • bool tryParseHex64(const std::string& str UInt64& value)
  • double parseFloat(const std::string& str)：解析浮点型
  • bool tryParseFloat(const std::string& str, double& value)

7、Poco::StringTokenizer 拆分字符串

#include "Poco/StringTokenizer.h"
#include "Poco/String.h" // for cat
using Poco::StringTokenizer;
using Poco::cat;
int main(int argc, char** argv)
{
	StringTokenizer t1("red, green, blue", ",");// "red", " green", " blue" (note the whitespace)
	StringTokenizer t2("red,green,,blue", ",");// "red", "green", "", "blue"
	StringTokenizer t3("red; green, blue", ",;",StringTokenizer::TOK_TRIM);// "red", "green", "blue"
	StringTokenizer t4("red; green,, blue", ",;",StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);// "red", "green", "blue"
	std::string s(cat(std::string("; "), t4.begin(), t4.end()));// "red; green; blue"
	return 0;
}

8、Poco::RegularExpression 正则表达式

在POCO中使用 Poco::RegularExpression 来实现正则表达式
头文件： #include “Poco/ regulareexpression .h”
Poco:: RegularExpression 在内部使用PCRE库(Perl兼容正则表达式)。

用正则表达式匹配(match)、提取（extract）、分割（split）、替换子字符串（subst）

#include "Poco/RegularExpression.h"
#include <vector>
using Poco::RegularExpression;
int main(int argc, char** argv)
{
	RegularExpression re1("[0-9]+");
	bool match = re1.match("123"); // true
	match = re1.match("abc"); // false
	match = re1.match("abc123", 3); // true
	RegularExpression::Match pos;
	re1.match("123", 0, pos); // pos.offset == 0, pos.length == 3
	re1.match("ab12de", 0, pos); // pos.offset == 2, pos.length == 2
	re1.match("abcd", 0, pos); // pos.offset == std::string::npos
	RegularExpression re2("([0-9]+) ([0-9]+)");
	RegularExpression::MatchVec posVec;
	re2.match("123 456", 0, posVec);
	// posVec[0].offset == 0, posVec[0].length == 7
	// posVec[1].offset == 0, posVec[1].length == 3
	// posVec[2].offset == 4, posVec[2].length == 3
	std::string s;
	int n = re1.extract("123", s); // n == 1, s == "123"
	n = re1.extract("ab12de", 0, s); // n == 1, s == "12"
	n = re1.extract("abcd", 0, s); // n == 0, s == ""
	std::vector<std::string> vec;
	re2.split("123 456", 0, vec);
	// vec[0] == "123"
	// vec[1] == "456"
	s = "123";
	re1.subst(s, "ABC"); // s == "ABC"
	s = "123 456";
	re2.subst(s, "$2 $1"); // s == "456 123"
	RegularExpression re3("ABC");
	RegularExpression re4("ABC", RegularExpression::RE_CASELESS);
	match = re3.match("abc", 0); // false
	match = re4.match("abc", 0); // true
	return 0;
}

9、Poco::TextConverter 字符编码转换

Poco::TextConverter 实现在不同字符编码之间转换字符串

#include "Poco/TextConverter.h"
#include "Poco/Latin1Encoding.h"
#include "Poco/UTF8Encoding.h"
#include <iostream>
using Poco::TextConverter;
using Poco::Latin1Encoding;
using Poco::UTF8Encoding;
int main(int argc, char** argv)
{
	std::string latin1String("This is Latin-1 encoded text.");
	std::string utf8String;
	Latin1Encoding latin1;
	UTF8Encoding utf8;
	TextConverter converter(latin1, utf8);
	converter.convert(latin1String, utf8String);
	std::cout << utf8String << std::endl;
	return 0;
}

10、流中字符转换

  • Poco::OutputStreamConverter：作为一个过滤器，在将所有写入它的字符传递到另一个流之前，将它们转换为另一种编码。
  • Poco::InputStreamConverter：作为过滤器，从另一个流读取字符并将其转换为另一种编码，然后将它们传递给阅读器。
#include "Poco/StreamConverter.h"
#include "Poco/Latin1Encoding.h"
#include "Poco/UTF8Encoding.h"
#include <iostream>
using Poco::OutputStreamConverter;
using Poco::Latin1Encoding;
using Poco::UTF8Encoding;
int main(int argc, char** argv)
{
	std::string latin1String("This is Latin-1 encoded text.");
	Latin1Encoding latin1;
	UTF8Encoding utf8;
	OutputStreamConverter converter(std::cout, latin1, utf8);
	converter << latin1String << std::endl; // console output will be UTF-8
	return 0;
}

11、字符编码

Poco::Unicode：提供了对Unicode字符属性(字符类别、字符类型、脚本)的基本支持
Poco::UTF8：处理UTF-8编码的字符串

12-14 07:51
Powered by LMLPHP ©2024 郭老二 0.001523