StringRef - read only std::string like class similar to boost::string_ref

Question

Idea behind the class is same as boost::string_ref or llvm::SrtingRef.

StringRef is immutable and not-owning.

I did not implemented substring() yet, because I will not need it.

Example usage:

std::string name = "xxxx";

void store(const StringRef &s);

void something(const StringRef &s){
   //... do something here, for example
   if (s == "hi"){
      std::string a = s + name;
      store(a);
   }
}

int main(){
   // function can be call like this:
   something("Hello");
   // or with std::string:
   std::string a = "Hello";
   something(a);
}

---

stringref.h

#ifndef MY_STRING_REF_H
#define MY_STRING_REF_H

#include <string>
#include <ostream>

class StringRef{
public:
    StringRef() = default;

    StringRef(const char *data, size_t const size);
    StringRef(const char *data);
    StringRef(const std::string &s);

    // ==================================

    const char *data() const{
        return _data;
    }

    size_t size() const{
        return _size;
    }

    // ==================================

    bool empty() const;

    char charAt(size_t index) const;

    std::string toString() const;

    // ==================================

    int compare(const char *data) const;
    int compare(const std::string &s) const;
    int compare(const StringRef &sr) const;

    // ==================================

    operator std::string() const;

    char operator [] (size_t index) const;

    bool operator ==(const char *data) const;
    bool operator ==(const std::string &data) const;
    bool operator ==(const StringRef &data) const;
    bool operator ==(char c) const;

    bool operator !=(const char *data) const;
    bool operator !=(const std::string &data) const;
    bool operator !=(const StringRef &data) const;
    bool operator !=(char c) const;

    // ==================================

    const char *c_str() const{
        return data();
    }

    size_t length() const{
        return size();
    }

private:
    size_t          _size   = 0;
    const char      *_data  = __zeroStr;

private:
    constexpr
    static const char   *__zeroStr = "";
};

std::ostream& operator << (std::ostream& os, const StringRef &sr);

// ==================================

inline bool StringRef::empty() const{
    return _size == 0;
}

inline char StringRef::charAt(size_t const index) const{
    return _data[index];
}

inline std::string StringRef::toString() const{
    return std::string(_data, _size);
}

// ==================================

inline int StringRef::compare(const std::string &s) const{
    return compare(s.data() );
}

inline int StringRef::compare(const StringRef &sr) const{
    return compare(sr.data() );
}

// ==================================

inline StringRef::operator std::string() const{
    return toString();
}

inline char StringRef::operator [] (size_t const index) const{
    return charAt(index);
}

// ==================================

inline bool StringRef::operator ==(const char *data) const{
    return compare(data) == 0;
}

inline bool StringRef::operator ==(const std::string &data) const{
    return compare(data) == 0;
}

inline bool StringRef::operator ==(const StringRef &data) const{
    return compare(data) == 0;
}

inline bool StringRef::operator ==(char const c) const{
    return _size == 1 && _data[0] == c;
}

// ==================================

inline bool StringRef::operator !=(const char *data) const{
    return ! (*this == data);
}

inline bool StringRef::operator !=(const std::string &data) const{
    return ! (*this == data);
}

inline bool StringRef::operator !=(const StringRef &data) const{
    return ! (*this == data);
}

inline bool StringRef::operator !=(char const c) const{
    return ! (*this == c);
}

#endif

---

stringref.cc

#include "stringref.h"

#include <cstring>

// ==================================

std::ostream& operator << (std::ostream& os, const StringRef &sr) {
    for(size_t i = 0; i < sr.size(); ++i)
        os << sr[i];
    return os;
}

// ==================================

StringRef::StringRef(const char *data, size_t const size) :
        _size(size),
        _data(size ? data : __zeroStr){}

StringRef::StringRef(const char *data) :
        StringRef(data, data ? strlen(data) : 0){}

StringRef::StringRef(const std::string &s) :
        _size(s.size()),
        _data(s.data()){}

int StringRef::compare(const char *data) const{
    // Lazy based on LLVM::StringRef
    // http://llvm.org/docs/doxygen/html/StringRef_8h_source.html

    auto data_size = strlen(data);

    // check prefix
    if ( int res = memcmp(_data, data, std::min(_size, data_size ) ) )
        return res < 0 ? -1 : +1;

    // prefixes match, so we only need to check the lengths.
    if (_size == data_size)
        return 0;

    return _size < data_size ? -1 : +1;
}

Answer 1

Clean up the Interface

Your StringRef has a lot of member functions. It seems to be taking a cue from std::string, which has even more. A lot of those functions aren't really necessary. charAt(), operator std::string(), toString(), compare(). Do you really need any of those? I arranged those in decreasing order of "definitely remove this." For sure, charAt() should not exist. If you want to keep the string conversion, I would call it explicit operator std::string().

Indexing

You have:

char operator [] (size_t index) const;

I would propose instead to have:

char const& operator [] (size_t index) const;

The reason being that &s[0] is a fairly commonly used idiom to get a pointer to the first element... which would fail to compile now. I don't think that's something we should prematurely disallow, so let's make it work. Obviously make it char const& (and not char&) since you want to keep it immutable.

__zeroStr

First of all, this is a reserved name (as is any name that contains a double underscore). Secondly, it does nothing for you. Just have:

class StringRef {
    size_t _size = 0;
    const char* _data = "";
};

Repetition

You have four operator!=s defined. All of them forward to the appropriate operator==, which is good. But we still have to rewrite everything. We could make this a non-member template:

template <typename T>
auto operator!=(StringRef const& lhs, T const& rhs)
-> decltype(lhs == rhs)
{
    return !(lhs == rhs);
}

Now we just have the one.

bool operator==(char) const;

Why?

compare and strlen()

Your "primary" compare starts with:

int StringRef::compare(const char *data) const {
    auto data_size = strlen(data);
    ...
}

But two of our cases for compare (std::string and StringRef) know their own sizes. Why would we drop this information? Instead, use the case that doesn't know to simply forward to one that does:

int compare(const char* data) const { return compare(data, strlen(data)); }
int compare(const std::string& data) const { return compare(data.c_str(), data.size()); }
int compare(const StringRef& data) const { return compare(data.c_str(), data.size()); }

Which brings me to the main compare. We have two null-terminated strings. Both are null-terminated. So what happens when the first one is shorter than the other? Well, if it's a strict prefix, we'll eventually get to the \0 and that char will compare smaller. That's all we need to know:

int compare(const char* data, size_t len) {
    return memcmp(_data, data, std::max(len, _size));
}

That's quite a bit shorter.

operator<<

You are outputting each character one at a time. That's fine, but you could instead use the write() function:

std::ostream& operator << (std::ostream& os, const StringRef &sr) {
    return os.write(sr.c_str(), sr.size());
}