std::string replacement (char* wrapper)

[Ginto8]

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):

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

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:

Code: Select all

#define STRING_WITH_IOSTREAM
#include "String.h"

Edit5: mostly fixed errors and stuff, nothing major

[avansc]

those inlines are really redundant.

most compiler these days make short functions like this inline.

[Ginto8]

those inlines are really redundant.

most compiler these days make short functions like this inline.

my reply:

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.

and now, the laugh that I promised:

=P

[MarauderIIC]

Well... class member functions aren't automatically inlined, necessarily. Some are. Some aren't. Depends what the compiler thinks. "Inline" doesn't even mean that it'll compile inline. It just means that you're suggesting to the compiler that maybe it should perhaps consider compiling it inline. Which it usually maybe perhaps sometimes considers anyway.

[Ewan]

Well... class member functions aren't automatically inlined, necessarily. Some are. Some aren't. Depends what the compiler thinks. "Inline" doesn't even mean that it'll compile inline. It just means that you're suggesting to the compiler that maybe it should perhaps consider compiling it inline. Which it usually maybe perhaps sometimes considers anyway.

Programming is so precise