StringHelpers in CPP
Aus LOMSO
| Du bist hier : | Wiki home -> Software -> Programmieren -> StringHelpers in CPP |
String Helper in C++
Oft fehlt in der Stringklasse in C++ genau die Methode, die man grad braucht.
Aus der Praxis heraus sind einige Methoden entstanden, die ich für nützlich halte.
Download: github: stringhelper
Autor
Richard Albrecht
Lizenz
LGPL
GNU Lesser General Public License
Tests
Im Folder test sind einige Unit-Tests mit Qt enthalten (Qt muss installiert sein).
Projektfiles
strings.pro für eine Qt Entwicklungs-Umgebung mit qmake ist dabei. Es ist kein sinnvolles Main dabei, weil es die Tests gibt.
test/teststrhlp.pro für eine Qt Entwicklungs-Umgebung mit qmake ist dabei. Qt wird verwendet. Die Tests können beliebig erweitert werden.
Compiler
gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3
Methoden
String nach Wert - Wert nach String (ersetzt 'itoa','atoi' usw.)
Quelle: C++ FAQ, How do I convert a value (a number, for example) to a std::string
-- Konvertiert einen Wert in einen String.
template<class T >
inline std::string toString( T val, size_t w = 6, std::string const& format = "%6.3lf" )
{
std::ostringstream o;
if ( !( o << val ) )
throw BadConversion( std::string( "toString(" ) + typeid( val ).name() + ")" );
return o.str();
}
-- Konvertiert einen double Wert in einen String
std::string toString( double val, size_t w = 6, std::string const& format = "%6.3lf" ) {
char num[256];
std::string f = format;
if( f.size() == 0 ){
f = "%6.3lf";
}
sprintf( num, f.c_str(), val );
return num; // automatische Konvertierung nach string
}
-- Konvertiert einen String in einen Wert
template<class T>
T string2type( std::string const& s ) {
T x;
std::istringstream insx( s );
//insx >> x;
if ( !( insx >> x ) )
throw BadConversion( std::string( "toString(" ) + typeid( s ).name() + ")" );
return x;
}
-- Konvertierung bool -> string, string -> bool
namespace{
const std::string s_true="true";
const std::string s_false="false";
}
std::string toString( bool b ) {
if( b )
return s_true;
return s_false;
}
bool string_to_bool( std::string const& s ) {
if( s == s_true){
return true;
}
if( s == s_false){
return false;
}
// was ist hier?
// nicht true, also false?, ist das gewollt?
return false;
}
to bin, hex
-- konvertiert einen Wert in einen Hex-String, ohne '0x' Prefix
std::string to_hex( size_t val, size_t w = 8 ){
std::ostringstream o;
o << std::setfill( '0' ) << std::setw( w ) << hex << val;
return o.str();
}
-- konvertiert einen Wert in einen Hex-String, mit '0x Prefix'
std::string to_hex_0x( size_t val, size_t w = 8 ){
string lower = to_hex(val,w);
to_upper_in_place(lower);
return "0x" + lower;
}
-- konvertiert einen Wert in einen Bin-String
std::string to_bin(size_t val, size_t l = 32){
size_t i;
char str[65];
for (i = l; i > 0; i--)
str[l-i] = '0' + ((val >> (i-1)) & 0x1);
str[l] = 0;
return string(str);
}
Upper - Lower
-- konvertiert einen String nach Kleinbuchstaben.
void to_lower_in_place( std::string& s ){
std::string::iterator start = s.begin();
while ( start != s.end() ) {
*start = ( char )::tolower( *start );
++start;
}
}
std::string to_lower( std::string const& s ){
string temp = s;
to_lower_in_place( temp );
return temp;
}
-- konvertiert einen String nach Grossbuchstaben.
void to_upper_in_place( std::string & s ){
std::string::iterator start = s.begin();
while ( start != s.end() ) {
*start = ( char )::toupper( *start );
++start;
}
}
std::string to_upper( std::string const& s ){
string temp = s;
to_upper_in_place( temp );
return temp;
}
String am Ende kappen
-- kappt einen String vor 'pattern'
std::string clip( std::string const& s, std::string const& pattern ){
if ( in.size() > 0 ) {
size_t i = index( in, pattern );
if ( i != std::string::npos ) {
return in.substr( 0, i ) ;
}
}
return in;
}
-- kappt einen String nach 'pattern'
std::string clip_after( std::string const& in , std::string const& pattern ) {
size_t i = index( in, pattern );
if ( i != std::string::npos ) {
return in.substr( 0, i + pattern.size() );
}
return in;
}
-- kappt einen string vor Position 'pos', Position beginnt mit '0'
std::string clip_at_pos( std::string const& s, size_t pos = 0){
if ( s.size() > 0 ) {
size_t i = pos;
if ( i != string::npos ) {
return s.substr( 0, i ) ;
}
}
return s;
}
-- kappt einen string vor Char 'ch'
std::string clip_at_char( std::string const& s, char ch ) {
if ( s.size() > 0 ) {
size_t i = index( s, ch );
if ( i != string::npos ) {
return s.substr( 0, i ) ;
}
}
return s;
}
-- kappt einen string nach Position 'pos', anderer Name für 'clip_at_pos'
std::string truncate( std::string const& s, size_t pos );
trim, rechts, links, beide Seiten, mit ' ' oder char
-- trim, beide Seiten
std::string trim( std::string const& str, char char2remove = ' ' ){
if( str.size() == 0 ) return "";
string::const_iterator bb = str.begin();
string::const_iterator ee = str.end ();
while ( bb < ee && *bb == ch ) {
++bb;
}
if( bb == ee ) return "";
ee = str.end() - 1;
while ( ee > bb && *ee == ch ) {
--ee;
}
int start = bb - str.begin();
int n = ee - bb + 1;
return str.substr( start, n );
}
-- trim von rechts
std::string trim_right( std::string const& str, char char2remove = ' ' ){
if ( str.size() == 0 ) return "";
string::const_iterator bb = str.begin();
string::const_iterator ee = str.end() - 1;
while ( ee > bb && *ee == ch ) {
--ee;
}
if( ee == str.end() - 1 ) return str;
if( ee == str.begin() ) return "";
int start = 0;
// ee is at first char from right, add one
++ee;
int n = ee - bb;
return str.substr( start, n );
}
-- trim von links
std::string trim_left( std::string const& str, char char2remove = ' ' ){
if( str.size() == 0 ) return "";
string::const_iterator bb = str.begin();
string::const_iterator ee = str.end ();
while ( bb < ee && *bb == ch ) {
++bb;
}
if( bb == ee ) return "";
if( bb == str.begin() ){
return str;
}
int start = bb - str.begin();
//int n = ee - bb + 1;
return str.substr( start );
}
Index
-- mit Char von links, return string::npos, wenn nicht gefunden
size_t index( std::string const& s, char ch, size_t start = 0 ) {
return s.find ( ch, pos );
}
-- mit Char von rechts, return string::npos, wenn nicht gefunden
size_t index_right( std::string const& s, char ch ) {
return s.rfind( ch );
}
-- mit Pattern, dto.
size_t index( std::string const& s, std::string const& pattern, size_t start = 0 ) {
return s.find ( pattern, pos );
}
size_t index_right( std::string const& s, const std::string& pattern ) ;
return s.rfind( pattern );
}
Ersetzen
std::string replace( std::string const& in, std::string const& pattern, std::string const& replace ){
return replace_first(ins,pattern,replace);
}
std::string replace_first( std::string const& in, std::string const& pattern, std::string const& replace ) {
string temp = in;
size_t pos = temp.find(pattern);
if(pos == std::string::npos)
return temp;
temp.replace(pos, pattern.length(), replace);
return temp;
}
std::string replace_all( std::string const& source, const std::string& pattern, const std::string & replace ) {
string temp = ins;
size_t pos = index( temp, pattern );
while ( pos != std::string::npos ) {
temp.replace(pos, pattern.length(), replace);
pos += replace.length();
pos = temp.find ( pattern, pos );
}
return temp;
}
Auffüllen rechts
std::string fillup( std::string const & in, char ch, size_t n ) {
string s = in;
if ( s.size() < n )
s += string( n - s.size(), ch ) ;
return s;
}
Suche Char, z.B. zur Bearbeitung von Pfadangaben
char last_char( string const& s ) {
if ( s.length()== 0 ) return 0;
return *(s.end() - 1);
}
char first_char( string const& s ) {
if ( s.length()== 0 ) return 0;
return s[0];
}
Löschen
std::string erase( std::string const& in, size_t pos, size_t len ){
string s = in;
erase_in_place( s, pos, len );
return s;
}
void erase_in_place( std::string & s, size_t pos, size_t len ){
s.erase( pos, len );
}
std::string remove_first( std::string const& in ) {
return erase( in, 0, 1 );
}
std::string remove_first( std::string const& in, std::string const& pattern ) {
size_t i = index( in, pattern );
if ( i != std::string::npos ) {
return erase( in, i, pattern.length() );
}
return in;
}
std::string remove_after( std::string const& in , std::string const& pattern ) {
string s = in;
remove_last_in_place( s );
return s;
}
std::string remove_last( std::string const& in ){
string s = in;
remove_last_in_place( s );
return s;
}
void remove_last_in_place( std::string &s ){
if ( s.size() > 0 ) {
int i = s.size() - 1;
s.erase( i, 1 );
}
}
void remove_last_in_place_if_ch( string &s, char ch ) {
if ( s.size() > 0 ) {
int i = s.size() - 1;
if ( s[i] == ch )
s.erase( i, 1 );
}
}
Einfügen
std::string insert_at( std::string const& in, char ch, size_t pos ){
string s = in;
if ( pos <= s.size() ) {
s.insert( pos, 1, ch );
}
return s;
}
std::string insert_at( std::string const& str, const std::string& insert, size_t pos ) {
string s = str;
if ( pos <= s.length() && insert.length() > 0 ) {
s.insert( pos, insert );
}
return s;
}
Zerlegen in Tokens
std::vector<std::string> tokenize( std::string const& str, const std::string& delimiters = " " ){
string::size_type pos_not_delimiter = str.find_first_not_of( delimiters, 0 );
string::size_type pos_delimiter = str.find_first_of( delimiters, pos_not_delimiter );
vector<string> tokens;
while ( string::npos != pos_delimiter || string::npos != pos_not_delimiter ) {
string::size_type length = pos_delimiter - pos_not_delimiter;
tokens.push_back( str.substr( pos_not_delimiter, length ) );
pos_not_delimiter = str.find_first_not_of( delimiters, pos_delimiter );
pos_delimiter = str.find_first_of( delimiters, pos_not_delimiter );
}
return tokens;
}
std::vector<std::string> split( std::string const& line, std::string const& delimiters = " " ){
vector<string> v = tokenize( l, delimiters);
return v;
}
