SRString

[SR_team]

Пиздатый апгрейд std::string. Теперь строки юзабельны и const char* не нужен!




Код:






#ifndef SRSTRING_H
#define SRSTRING_H

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

enum eRegExp{
eRe_notMatched,
eRe_matched,
eRe_searched
};

template
class SRStringBase : public std::basic_string
{
public:
SRStringBase() : std::basic_string() {}
SRStringBase(TChar c) { this->push_back(c); }
SRStringBase(const TChar * str) : std::basic_string(str) {}
SRStringBase(TChar * str) : std::basic_string(str) {}
SRStringBase(std::basic_string str) : std::basic_string(str) {}
SRStringBase(const SRStringBase &str) : std::basic_string(str.c_str()) {}

template
static SRStringBase sprintf(const SRStringBase &format, Args ... args)
{
size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;
std::unique_ptr buf( new char[ size ] );
snprintf( buf.get(), size, format.c_str(), args ... );
return SRStringBase( buf.get() );
}

template
void format(const SRStringBase &format, Args ... args)
{
this->clear();
size_t size = snprintf( nullptr, 0, format.c_str(), args ... ) + 1;
std::unique_ptr buf( new char[ size ] );
snprintf( buf.get(), size, format.c_str(), args ... );
this->append(SRStringBase( buf.get() ));
}
template
void args(Args ... args)
{
size_t size = snprintf( nullptr, 0, this->c_str(), args ... ) + 1;
std::unique_ptr buf( new char[ size ] );
snprintf( buf.get(), size, this->c_str(), args ... );
this->clear();
this->append(SRStringBase( buf.get() ));
}

const SRStringBase toUpper()
{
std::transform(this->begin(), this->end(), this->begin(), ::toupper);
return SRStringBase(*this);
}
const SRStringBase toLower()
{
std::transform(this->begin(), this->end(), this->begin(), ::tolower);
return SRStringBase(*this);
}

int toInt(int base = 10)
{
int ret;
try {
ret = std::stoi(std::basic_string(*this), 0, base);
} catch (std::exception &) {
ret = std::stoll(std::basic_string(*this), 0, base);
}
return ret;
}
unsigned int toUInt(int base = 10)
{
unsigned int ret;
try {
ret = std::stoi(std::basic_string(*this), 0, base);
} catch (std::exception &) {
ret = std::stoull(std::basic_string(*this), 0, base);
}
return ret;
}
long toLong(int base = 10)
{
long ret;
try {
ret = std::stol(std::basic_string(*this), 0, base);
} catch (std::exception &) {
ret = std::stoll(std::basic_string(*this), 0, base);
}
return ret;
}
long long toLongLong(int base = 10)
{
return std::stoll(std::basic_string(*this), 0, base);
}
unsigned long toULong(int base = 10)
{
unsigned long ret;
try {
ret = std::stoul(std::basic_string(*this), 0, base);
} catch (std::exception &) {
ret = std::stoull(std::basic_string(*this), 0, base);
}
return ret;
}
unsigned long long toULongLong(int base = 10)
{
return std::stoull(std::basic_string(*this), 0, base);
}
float toFloat()
{
float ret;
try {
ret = std::stof(std::basic_string(*this));
} catch (std::exception &) {
ret = std::stod(std::basic_string(*this));
}
return ret;
}
double toDouble()
{
double ret;
try {
ret = std::stod(std::basic_string(*this));
} catch (std::exception &) {
ret = std::stold(std::basic_string(*this));
}
return ret;
}
long double toLongDouble()
{
return std::stold(std::basic_string(*this));
}

const std::deque> split(TChar delimeter)
{
std::basic_stringstream ss(*this);
std::basic_string item;
std::deque> splittedStrings;
while (std::getline(ss, item, delimeter))
{
splittedStrings.push_back(item);
}
return splittedStrings;
}

void push_front(TChar __c)
{
this->insert(0, std::basic_string(SRStringBase(__c)));
}
void pop_front() noexcept
{
this->erase(0, 1);
}

const SRStringBase replace(size_t start, size_t len, SRStringBase new_str)
{
this->std::basic_string::replace(start, len, std::basic_string(new_str));
return SRStringBase(*this);
}
const SRStringBase replace(SRStringBase old_str, SRStringBase new_str)
{
size_t find_pos = 0;
while (true){
size_t pos = this->find(std::basic_string(old_str), find_pos);
if (pos == this->npos)
break;
replace(pos, old_str.length(), new_str);
find_pos = pos + new_str.length();
}
return SRStringBase(*this);
}
const SRStringBase replace(TChar old_str, SRStringBase new_str)
{
size_t find_pos = 0;
while (true){
size_t pos = this->find(std::basic_string(SRStringBase(old_str)), find_pos);
if (pos == this->npos)
break;
replace(pos, 1, new_str);
find_pos = pos + 1;
}
return SRStringBase(*this);
}
const SRStringBase replace(SRStringBase old_str, TChar new_str)
{
size_t find_pos = 0;
while (true){
size_t pos = this->find(std::basic_string(old_str), find_pos);
if (pos == this->npos)
break;
replace(pos, old_str.length(), new_str);
find_pos = pos + new_str.length();
}
return SRStringBase(*this);
}
const SRStringBase replace(TChar old_str, TChar new_str)
{
size_t find_pos = 0;
while (true){
size_t pos = this->find(std::basic_string(SRStringBase(old_str)), find_pos);
if (pos == this->npos)
break;
replace(pos, 1, new_str);
find_pos = pos + 1;
}
return SRStringBase(*this);
}

const SRStringBase removeFirst(size_t len = 1)
{
std::basic_string::erase(0, len);
return SRStringBase(*this);
}
const SRStringBase removeLast(size_t len = 1)
{
std::basic_string::erase(this->length() - len, len);
return SRStringBase(*this);
}

const SRStringBase remove(size_t start, size_t len)
{
std::basic_string::erase(start, len);
return SRStringBase(*this);
}
const SRStringBase remove(TChar chr)
{
replace(chr, "");
return SRStringBase(*this);
}
const SRStringBase remove(SRStringBase str)
{
replace(str, "");
return SRStringBase(*this);
}

const SRStringBase removeOne(TChar chr)
{
size_t pos = this->find(std::basic_string(SRStringBase(chr)));
if (pos != this->npos){
this->std::basic_string::replace(pos, 1, std::basic_string(""));
}
return SRStringBase(*this);
}
const SRStringBase removeOne(SRStringBase str)
{
size_t pos = this->find(std::basic_string(str));
if (pos != this->npos){
this->std::basic_string::replace(pos, str.length(), std::basic_string(""));
}
return SRStringBase(*this);
}

bool isEmpty()
{
return (this->length() == 0);
}

bool indexOf(const SRStringBase &str)
{
return (this->find(std::basic_string(str)) != this->npos);
}

eRegExp indexIn(const std::regex &re)
{
if (std::regex_match(this->c_str(), cmatch, re))
return eRegExp::eRe_matched;
else if (std::regex_search(this->c_str(), cmatch, re))
return eRegExp::eRe_searched;
return eRegExp::eRe_notMatched;
}
eRegExp indexIn(const SRStringBase &re, std::regex::flag_type flag = std::regex::ECMAScript)
{
std::regex _re(re, flag);
return indexIn(_re);
}
const SRStringBase cap(int id)
{
if (id >= cmatch.size())
return "";
return cmatch[id].str();
}
size_t sizeCap()
{
return cmatch.size();
}
const std::cmatch lastCmatch()
{
return cmatch;
}

const SRStringBase toUnicode()
{
std::wstring_convert> converter;
if (typeid (TChar) == typeid (wchar_t))
return SRStringBase(*this);
return converter.from_bytes(*this);
}
const SRStringBase toAnsi()
{
std::wstring_convert> converter;
if (typeid (TChar) == typeid (char))
return SRStringBase(*this);
return converter.to_bytes(*this);
}

void fromUnicode(const SRStringBase &str)
{
std::wstring_convert> converter;
this->clear();
if (typeid (TChar) == typeid (wchar_t))
this->append((TChar*)str.c_str());
else this->append((TChar*)converter.to_bytes(str).c_str());
}
void fromAnsi(const SRStringBase &str)
{
std::wstring_convert> converter;
this->clear();
if (typeid (TChar) == typeid (char))
this->append((TChar*)str.c_str());
else this->append((TChar*)converter.from_bytes(str).c_str());
}

static SRStringBase Ansi2Unicode(const char* str)
{
std::wstring_convert> converter;
return converter.from_bytes(str);
}
static SRStringBase Unicode2Ansi(const wchar_t* str)
{
std::wstring_convert> converter;
return converter.to_bytes(str);
}

private:
std::cmatch cmatch;
};

typedef SRStringBase SRString;
typedef std::deque SRStringList;
typedef SRStringBase SRWstring;
typedef std::deque SRWstringList;

#endif // SRSTRING_H







Класс имеет кучу *****тых методов, которых крайне не хватает в чистом std::string, начнем со статичных методов:


sprintf(format, args) - аналог C'шной функции, но глотает строку и сплевывает тоже строку, при этом не требует предварительного создания буффера.

Ansi2Unicode(string) - создание UNICODE строки из ANSI строки.

Unicode2Ansi(string) - создание ANSI строки из UNICODE строки.
Обычные методы класса:


format(format, args) - форматирование строки.

args(args) - вставка аргументов в строку.

toUpper() - перевести всю строку в верхний регистр.

toLower() - перевести всю строку в нижний регистр.

toInt(base) - перевести строку в число, base - система счисления.

toUInt(base) - перевести строку в без-знаковое число, base - система счисления.

toLong(base) - аналог toInt().

toULong(base) - аналог toUInt().

toLongLong(base) - перевести строку в длинное число, base - система счисления.

toULongLong(base) - перевести строку в длинное без-знаковое число, base - система счисления.

toFloat() - перевести строку в число с плавающей запятой.

toDouble() - перевести строку в число с плавающей запятой двойной точности.

toLongDouble() - перевести строку в длинное число с плавающей запятой двойной точности.

split(delimeter) - разбить строку на несколько строк, delimeter - символ разделения.

push_front(char) - добавить символ в начало строки.

pop_front() - удалить первый символ строки.

replace(old, new) - заменить подстроки old на подстроки new.

removeFirst( n ) - удалить первые n символов.

removeLast( n ) - удалить последние n символов.

remove(pos, n) - удалить n символов после позиции pos.

remove(string) - удалить из строки каждое вхождение подстроки string.

removeOne(string) - удалить первое вхождение подстроки string.

isEmpty() - проверка пустая ли строка.

indexOf(string) - проверка есть ли подстрока string в строке.

indexIn(re) - проверка матчится ли строка регуляркой.

cap(id) - получить подстроку под номером id из ранее заюзаной регулярки.

sizeCap() - получить число подстрок из ранее заюзаной регулярки.

lastCmatch() - получить std::cmatch из ранее заюзаной регулярки.

toUnicode() - создать UNICODE строку из текущей строки.

toAnsi() - создать ANSI строку из текущей строки.

fromUnicode(string) - создать текущую строку из UNICODE строки.

fromAnsi(string) - создать текущую строку из ANSI строки.
Остальные методы наследуются от std::string (https://www.blast.hk/redirect/aHR0cDovL3d3dy5jcGx1c3BsdXMuY29tL3JlZmVyZW5jZS9zdH Jpbmcvc3RyaW5nLw).

[Vovich]

Я вот что спросить хотел, std:: и using namespace std, какова разница, это как то влияет на быстродействие?

Потому что по сути удобнее вариант 2, как бы не приходится каждый раз юзать, но думаю в чем то есть загвоздка...

[NarutoUA]

У basic_string не виртуальный деструктор, у тебя повсюду будут memory leaks (так что прийдется делать его членом класса и пилить обёртку над его методами)

[SR_team]

У basic_string не виртуальный деструктор, у тебя повсюду будут memory leaks (так что прийдется делать его членом класса и пилить обёртку над его методами)


я ж не создаю динамически ничего. все должно быть норм

[SR_team]

std:: и using namespace std,


никакой. можно ещё делать using std::string, тогда везде можно будет писать string без std::

[_BashkaMen_]

C++:






int
toInt
(
int
base
=
10
)
{
int
ret
;
try
{
ret
=
std
::
stoi
(
std
::
basic_string

(
*
this
)
,
0
,
base
)
;
}
catch
(
std
::
exception
&
)
{
ret
=
std
::
stoll
(
std
::
basic_string

(
*
this
)
,
0
,
base
)
;
}
return
ret
;
}




Учите шарп, ребята

C++:






string a
=
"10"
;
int
b
=
int
.
Parse
(
a
)
;

[LUCHARE]

C++:






int
toInt
(
int
base
=
10
)
{
int
ret
;
try
{
ret
=
std
::
stoi
(
std
::
basic_string

(
*
this
)
,
0
,
base
)
;
}
catch
(
std
::
exception
&
)
{
ret
=
std
::
stoll
(
std
::
basic_string

(
*
this
)
,
0
,
base
)
;
}
return
ret
;
}




Учите шарп, ребята

C++:






string a
=
"10"
;
int
b
=
int
.
Parse
(
a
)
;





просто гениально сравнивать языки разных уровней