std::string的构造和相互转化十分不便，自己项目中使用的一个std::string的封装类，std::string的一切性质都可以使用，添加了多种string构造方法和其它数据类型的转化。 无 /***基于std::string的c++字符串工具类，方便的实现string的构造、追加和相互转换*/c
/**
*基于std::string的c++字符串工具类，方便的实现string的构造、追加和相互转换
*/
class BscString : public std::string
{
public:
/**
*基础构造
*/
BscString() {
}
/**
*基本变量构造函数如:bool,int,double等
*/
template < typename T >
BscString(T const &val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*指针变量构造函数如:char*
*/
template < typename T >
BscString(T* val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*变量转换为string并追加到末尾
*/
template < typename T >
BscString& append(T const &val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
return *this;
}
/**
*字符串转换为string并追加到末尾
*/
template < typename T >
BscString& append(T* val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
return *this;
}
/**
*字符串转换为变量如:bool,int,long,double
*/
template < typename T >
void toValue(T &val) {
stringstream ss(*this);
ss >> val;
}
/**
*赋值T到string
*/
template < typename T >
void operator = (T const &val) {
stringstream ss;
std::string::clear();
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*赋值T*到string
*/
template < typename T >
void operator = (T* val) {
stringstream ss;
std::string::clear();
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*等同于append(T const &val)
*/
template < typename T >
BscString& operator << (T const &val) {
return append(val);
}
/**
*等同于append(T* val)
*/
template < typename T >
BscString& operator << (T* val) {
return append(val);
}
/**
*等同于toValue(T &val)
*/
template < typename T >
void operator >> (T &val) {
stringstream ss(*this);
ss >> val;
}
/************regex**************/
bool regexMatch(const std::string ®){
const std::regex pattern(reg);
return std::regex_match(*this, pattern);
}
bool regexMatch(const char* reg){
const std::regex pattern(reg);
return std::regex_match(*this, pattern);
}
/**************string*****************/
bool contains(const std::string &prefix){
return find(prefix) != -1;
}
bool startsWith(const std::string &prefix){
return find(prefix) == 0;
}
bool endsWith(const std::string &prefix){
return find(prefix) == (size() - prefix.size());
}
std::vector<std::string> split(std::string separator)
{
std::vector<std::string> result;
string str(*this);
int cutAt;
while ((cutAt = str.find_first_of(separator)) != str.npos)
{
if (cutAt > 0)
{
result.push_back(str.substr(0, cutAt));
}
else{
result.push_back("");
}
str = str.substr(cutAt + 1);
}
if (str.length() > 0)
{
result.push_back(str);
}
else{
result.push_back("");
}
return result;
}
};
#ifndef CTP_BASIC_BSCSTRING_H_
#define CTP_BASIC_BSCSTRING_H_
#include <stdio.h>
#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <cstdlib>
#include <regex>
using namespace std;
/**
*基于std::string的c++字符串工具类，方便的实现string的构造、追加和相互转换
*/
class BscString : public std::string
{
public:
/**
*基础构造
*/
BscString() {
}
/**
*基本变量构造函数如:bool,int,double等
*/
template < typename T >
BscString(T const &val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*指针变量构造函数如:char*
*/
template < typename T >
BscString(T* val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*变量转换为string并追加到末尾
*/
template < typename T >
BscString& append(T const &val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
return *this;
}
/**
*字符串转换为string并追加到末尾
*/
template < typename T >
BscString& append(T* val) {
stringstream ss;
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
return *this;
}
/**
*字符串转换为变量如:bool,int,long,double
*/
template < typename T >
void toValue(T &val) {
stringstream ss(*this);
ss >> val;
}
/**
*赋值T到string
*/
template < typename T >
void operator = (T const &val) {
stringstream ss;
std::string::clear();
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*赋值T*到string
*/
template < typename T >
void operator = (T* val) {
stringstream ss;
std::string::clear();
ss << fixed << setprecision(4) << val;
std::string::append(ss.str());
}
/**
*等同于append(T const &val)
*/
template < typename T >
BscString& operator << (T const &val) {
return append(val);
}
/**
*等同于append(T* val)
*/
template < typename T >
BscString& operator << (T* val) {
return append(val);
}
/**
*等同于toValue(T &val)
*/
template < typename T >
void operator >> (T &val) {
stringstream ss(*this);
ss >> val;
}
/************regex**************/
bool regexMatch(const std::string ®){
const std::regex pattern(reg);
return std::regex_match(*this, pattern);
}
bool regexMatch(const char* reg){
const std::regex pattern(reg);
return std::regex_match(*this, pattern);
}
/**************string*****************/
bool contains(const std::string &prefix){
return find(prefix) != -1;
}
bool startsWith(const std::string &prefix){
return find(prefix) == 0;
}
bool endsWith(const std::string &prefix){
return find(prefix) == (size() - prefix.size());
}
std::vector<std::string> split(std::string separator)
{
std::vector<std::string> result;
string str(*this);
int cutAt;
while ((cutAt = str.find_first_of(separator)) != str.npos)
{
if (cutAt > 0)
{
result.push_back(str.substr(0, cutAt));
}
else{
result.push_back("");
}
str = str.substr(cutAt + 1);
}
if (str.length() > 0)
{
result.push_back(str);
}
else{
result.push_back("");
}
return result;
}
};
#endif //CTP_BASIC_BSCSTRING_H_
