Ttyjfyk

I want to write a very simple std::string like compile-time const char* string.

I need to work with strings in the compiletime, just like with strings, I implemented basic functions.

class cstring final 
const char* str_;
std::size_t size_;

public:
constexpr cstring(const char* str, std::size_t size, std::size_t prefix = 0, std::size_t suffix = 0) noexcept
 : str_str + prefix,
 size_size - prefix - suffix 

template <std::size_t N>
constexpr cstring(const char (&str)[N]) noexcept : cstringstr, N - 1, 0, 0 

constexpr cstring() noexcept : cstringnullptr, 0, 0, 0 

cstring(const std::string& str) noexcept : cstringstr.data(), str.size(), 0, 0 

constexpr cstring(const cstring&) = default;

cstring& operator=(const cstring&) = default;

constexpr std::size_t size() const noexcept return size_; 

constexpr std::size_t length() const noexcept return size_; 

constexpr std::size_t max_size() const noexcept 
 return (std::numeric_limits<std::size_t>::max)();


constexpr bool empty() const noexcept return size_ == 0; 

constexpr const char* begin() const noexcept return str_; 

constexpr const char* end() const noexcept return str_ + size_; 

constexpr const char* cbegin() const noexcept return begin(); 

constexpr const char* cend() const noexcept return end(); 

constexpr const char& operator[](std::size_t i) const return str_[i]; 

constexpr const char& at(std::size_t i) const 
 return (i < size_) ? str_[i]
 : (throw std::out_of_range"cstring::at", str_[0]);


constexpr const char& front() const return str_[0]; 

constexpr const char& back() const return str_[size_ - 1]; 

constexpr const char* data() const noexcept return str_; 

constexpr cstring remove_prefix(std::size_t n) const 
 return str_ + n, size_ - n;


constexpr cstring add_prefix(std::size_t n) const 
 return str_ - n, size_ + n;


constexpr cstring remove_suffix(std::size_t n) const 
 return str_, size_ - n;


constexpr cstring add_suffix(std::size_t n) const 
 return str_, size_ + n;


constexpr cstring substr(std::size_t pos, std::size_t n) const 
 return str_ + pos, n;


constexpr int compare(cstring other) const 
 return (size_ == other.size_) ? detail::StrCompare(str_, other.str_, size_)
 : ((size_ > other.size_) ? 1 : -1);


friend constexpr bool operator==(cstring lhs, cstring rhs) 
 return lhs.compare(rhs) == 0;


friend constexpr bool operator!=(cstring lhs, cstring rhs) 
 return !(lhs == rhs);


std::string append(cstring s) const 
 return std::stringstr_, size_.append(s.str_, s.size_);


friend std::string operator+(cstring lhs, cstring rhs) 
 return std::stringlhs.str_, lhs.size_ + std::stringrhs.str_, rhs.size_;


friend std::ostream& operator<<(std::ostream& os, cstring str) 
 os.write(str.str_, str.size_);
 return os;


operator std::string() const return std::stringstr_, size_; 
;

1. I would only ever mark polymorphic classes final. For them, there's a potential benefit to balance out the unnaturalness of not being able to inherit.




2. You should really indent the contents of the class by one step. Though that could possibly be an artifact of only partially adapting to SE's markup.




3. Consider verifying that prefix and suffix have sensible values, at least in debug-mode (assert()).




4. The first ctor has sensible defaults for its last two parameters. Why not take advantage of that?




5. Is there a reason you only accept std::string, instead of generally std::basic_string<char, std::char_traits<char>, AnyAllocator>?




6. You could use !_size instead of _size == 0. Well, de gustibus.




7. Your comparison is curious, but at least consistent.




8. I would suggest conforming to C++17 std::string_view as closely as possible so you can later remove your custom class, and to ease the burden for users.