std::string replacement (char* wrapper)
Posted: Mon Apr 06, 2009 1:51 pm
For those of you that don't know, the std::string is more bloated than falco's mom. 
So, to counteract its bloatedness, but keep some functionality, I created a class that wraps to char* functions (from cstring). As you may notice, the entire class is inlined, so it is very efficient. The following code can be copied and pasted into a file called String.h, though you could use a different name (just remember to change the #define's):
getStr() and setStr() are so that you can make modifications to the string that these functions do not provide for. You can customize this class to fit your needs. If you decide to post "OMG why did you put inline in front of all those functions? Class member functions are automatically inlined!", I will laugh because I already know that. I only put the "inline" there to make it obvious that it is inline.
Edit: changed getStr(), added setStr(), so you don't end up with any length problems
Edit2: removed m_length based on it being unnecessary, put getStr() back to normal, changed some minor stuff
Edit3: added namespace std, and the typedef String string
Edit4: added operator<<, operator>>, and getline(). To use these, simply do this in your source file:
Edit5: mostly fixed errors and stuff, nothing major
So, to counteract its bloatedness, but keep some functionality, I created a class that wraps to char* functions (from cstring). As you may notice, the entire class is inlined, so it is very efficient. The following code can be copied and pasted into a file called String.h, though you could use a different name (just remember to change the #define's):
Code: Select all
#ifndef STRING_H
#define STRING_H
#include <cstring>
#ifdef STRING_WITH_IOSTREAM
#include <iostream>
#endif
namespace std
{
class String
{
char* m_str;
public:
String();
String(const char* str);
String(String const& str);
String(char ch);
// assignment
String& operator=(String const& str);
String& operator=(const char* str);
String& operator=(char ch);
// combining 2 or more strings
String operator+(String const& str);
String operator+(const char* str);
String operator+(char ch);
// appending
void operator+=(String const& str);
void operator+=(const char* str);
void operator+=(char ch);
void append(String const& str);
void append(const char* str);
void append(char ch);
// comparison
bool operator==(String const& str) const;
bool operator==(const char* str) const;
bool operator==(char ch) const;
bool compare(String const& str) const;
bool compare(const char* str) const;
bool compare(char ch) const;
// checks if str is part of m_str
bool contains(String const& str) const;
bool contains(const char* str) const;
bool contains(char ch) const;
// get variables
const char* c_str() const;
unsigned length() const;
// for custom manipulation of the string
char* getStr() const;
char& operator[](int i) const;
char& at(int i) const;
};
inline String::String() { *this = ""; }
inline String::String(const char* str) { *this = str; }
inline String::String(String const& str) { *this = str; }
inline String::String(char ch) { *this = ch; }
inline String& String::operator=(String const& str) { strcpy(m_str, str.c_str()); return *this; }
inline String& String::operator=(const char* str) { strcpy(m_str, str); return *this; }
inline String& String::operator=(char ch) { m_str[0] = ch; m_str[1] = '\0'; }
inline String String::operator+(String const& str)
{
char* str2;
strcpy(str2, m_str);
return String(strcat(str2, str.c_str()));
}
inline String String::operator+(const char* str)
{
char* str2;
strcpy(str2, m_str);
return String(strcat(str2, str));
}
inline String String::operator+(char ch)
{
char* str2;
strcpy(str2, m_str);
unsigned i = strlen(str2);
str2[i] = ch;
str2[i+1] = '\0';
return String(str2);
}
inline void String::operator+=(String const& str) { *this = *this + str; }
inline void String::operator+=(const char* str) { *this = *this + str; }
inline void String::operator+=(char ch) { *this = *this + ch; }
inline void String::append(String const& str) { *this += str; }
inline void String::append(const char* str) { *this += str; }
inline void String::append(char ch) { *this += ch; }
inline bool String::operator==(String const& str) const { return (strcmp(str.m_str, m_str) == 0); }
inline bool String::operator==(const char* str) const { return (strcmp(str, m_str) == 0); }
inline bool String::operator==(char ch) const { return ((strlen(m_str) == 1) && (m_str[0] == ch)); }
inline bool String::compare(String const& str) const { return (strcmp(str.m_str, m_str) == 0); }
inline bool String::compare(const char* str) const { return (strcmp(str, m_str) == 0); }
inline bool String::compare(char ch) const { return (*this == ch); }
inline bool String::contains(String const& str) const { return (strstr(m_str, str.m_str) != NULL) }
inline bool String::contains(const char* str) const { return (strstr(m_str, str) != NULL) }
inline bool String::contains(char ch) const
{
char* str;
str[0] = ch;
str[1] = '\0';
return (strstr(m_str, str) != NULL);
}
inline const char* String::c_str() const { return m_str; }
inline unsigned String::length() const { return strlen(m_str); }
inline char* String::getStr() const { return m_str; }
inline char& String::operator[](int i) const { return m_str[i]; }
inline char& String::at(int i) const { return (*this)[i]; }
typedef String string;
#ifdef STRING_WITH_IOSTREAM
inline ostream& operator<<(ostream& stream, String& str) { stream << str.c_str(); }
inline istream& operator>>(istream& stream, String& str) { stream >> str.getStr(); }
inline void getline(istream& stream, String& str) { stream.getline(str.getStr()); }
#endif
}
#endif
Edit: changed getStr(), added setStr(), so you don't end up with any length problems
Edit2: removed m_length based on it being unnecessary, put getStr() back to normal, changed some minor stuff
Edit3: added namespace std, and the typedef String string
Edit4: added operator<<, operator>>, and getline(). To use these, simply do this in your source file:
Code: Select all
#define STRING_WITH_IOSTREAM
#include "String.h"