#include <stdio.h>
#include <malloc.h>
#include <string.h>
 
#include <utility>
 
 
class string {
  char* _c_str;
  std::size_t _length;
  std::size_t _capacity;
 
public:
  string(const char* str, std::size_t capacity) 
    : _c_str(nullptr), _length(0), _capacity(0)
  {
    _length = strlen(str);
    _capacity = capacity;
    if (_length > _capacity) { // 指定された大きさのバッファでは足りない
      _capacity = _length;
    }
    _c_str = reinterpret_cast< char* >(malloc(sizeof(char) * _capacity + sizeof(char))); // 終端文字を考慮
    memset(_c_str, 0, sizeof(char) * _capacity + sizeof(char));
    strncpy(_c_str, str, _length);
  }
 
  // copy
  string(const string& rhs)
    : string(rhs.c_str(), rhs.length()) {
  }
  string& operator= (const string& rhs) {
    if (this->capacity() >= rhs.length()) {
      strncpy(this->_c_str, rhs.c_str(), rhs.length());
      this->_length = rhs.length();
      memset(this->end(), 0, (this->capacity() - this->length() + 1) * sizeof(char));
      return (*this);
    }
    // バッファには入りきらない場合
    string new_val(rhs);
    std::swap(this->_c_str, new_val._c_str);
    std::swap(this->_length, new_val._length);
    std::swap(this->_capacity, new_val._capacity);
    return (*this);
  }
 
  ~string() {
    if (_c_str) {
      free(_c_str);
      _c_str = nullptr;
      _length = _capacity = 0;
    }
  }
 
  const char* c_str() const noexcept { return _c_str; }
  std::size_t length() const noexcept { return _length; }
  std::size_t capacity() const noexcept { return _capacity;}
 
  // begin, end
  char* begin() { return _c_str; }
  char* end() { return begin() + length(); } // 終端文字を返す
  const char* begin() const { return _c_str; }
  const char* end() const { return begin() + length(); } // 終端文字を返す
  const char* cbegin() const { return begin(); }
  const char* cend() const { return end(); } // 終端文字を返す
 
};
 
// compare
bool operator== (const string& s1, const string& s2) {
  return !strcmp(s1.c_str(), s2.c_str());
}
 
int main() {
  string str1("abcdef", 6);
  string str2("abcdefg", 0);
  string str3("", 10);
 
  str2 = str1;
  str3 = str1;
 
  printf("string: %s\nlength: %d\ncapacity:%d\n",
    str2.c_str(), str2.length(), str2.capacity());
  printf("string: %s\nlength: %d\ncapacity:%d\n",
    str3.c_str(), str3.length(), str3.capacity());
 
  if (str1 == str2) {
    printf("str1 == str2\n");
  }
}

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