C++ StringBuilder 简易实现，多个对象共享同一内存

#pragma once

#include <string.h>
#include <stdlib.h>
#include <string>

class StringBuilder
{
public:
const static int kDefaultSize = 64;
public:
StringBuilder()
{
init();
}

StringBuilder(const char* str)
{
init();
append(str, strlen(str));
}

~StringBuilder()
{
}

StringBuilder(const StringBuilder& ps)
{
_size = ps._size;
_capacity = ps._capacity;
_data = ps._data;
}

StringBuilder& operator = (const StringBuilder& ps)
{
_size = ps._size;
_capacity = ps._capacity;
_data = ps._data;
return *this;
}

inline void init()
{
_size = 0;
_capacity = new int(kDefaultSize);
_data = new char*(new char[*_capacity]);
(*_data)[_size] = '\0';
}

inline void clear()
{
if (_capacity)
{
delete _capacity;
_capacity = NULL;
}
if (_data)
{
char* p = *_data;
delete[] p;
p = NULL;
delete _data;
_data = NULL;
}
_size = 0;
}

inline StringBuilder& append(const char* str, int len)
{
if (len >= *_capacity - _size)
{
int cap = *_capacity;
cap <<= 1;
while (len >= cap - _size)
cap <<= 1;
extend(cap);
}
strncpy((*_data) + _size, str, len);
_size += len;
return *this;
}

inline StringBuilder& append(char ch)
{
if (1 >= *_capacity - _size)
{
int cap = *_capacity;
cap <<= 1;
while (1 >= cap - _size)
cap <<= 1;
extend(cap);
}
(*_data)[_size++] = ch;
return *this;
}

inline StringBuilder& append(const char* str)
{
int len = strlen(str);
return append(str, len);
}

inline StringBuilder& append(const std::string& str)
{
return append(str.c_str(), str.length());
}

inline StringBuilder& append(int num)
{
return append(std::to_string(num));
}

inline void extend(int cap)
{
*_capacity = cap;
char* p = *_data;
char* newp = new char[*_capacity];
strncpy(newp, p, _size + 1);
delete[] p;
*_data = newp;
}

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

inline int size() const
{
return _size;
}

inline int capacity() const
{
return _capacity ? *_capacity : 0;
}

private:
int     _size;
int*    _capacity;
char**  _data;
};