Implement Your Own std::string (MyString)

The single most pervasive bug in custom string implementations is failing to account for the null terminator \0 in memory allocations:

// FATAL BUG: Buffer overflow!
char* buf = new char[size_]; // Needs new char[size_ + 1]!
std::memcpy(buf, src, size_);
buf[size_] = '\0'; // WRITES PAST THE ALLOCATED HEAP BLOCK!

To ensure c_str() operates in O(1) time without dynamic allocation, data_[size_] must always be \0. When allocating memory for a string of capacity C, you must allocate C + 1 bytes. Even for an empty string MyString(), allocating a 1-byte buffer containing "\0" prevents data_ from ever being nullptr, ensuring c_str() can safely return data_ unconditionally without branching.

When an interviewer asks you to write MyString(const char* s), what happens if a caller passes MyString(nullptr)?

If you blindly write size_ = std::strlen(s);, std::strlen(nullptr) triggers an immediate segmentation fault (Undefined Behavior)! A robust production implementation guards against nullptr by defaulting to an empty string:

MyString(const char* str) {
    if (!str) {
        data_ = new char[1]{'\0'};
        size_ = 0;
        capacity_ = 0;
    } else {
        size_ = std::strlen(str);
        capacity_ = size_;
        data_ = new char[capacity_ + 1];
        std::memcpy(data_, str, size_ + 1); // Copies payload + null byte!
    }
}

A naive copy assignment operator typically looks like:

// BUG: Vulnerable to self-assignment and throws midway!
MyString& operator=(const MyString& other) {
    delete[] data_; // Self-assignment kills other.data_!
    data_ = new char[other.size_ + 1]; // If new throws bad_alloc, *this is corrupt!
    std::memcpy(data_, other.data_, other.size_ + 1);
    return *this;
}

If s = s; is called, delete[] data_ destroys the very memory that is about to be copied. Furthermore, if new throws std::bad_alloc, the original string's data has already been destroyed, violating exception safety.

The industry standard solution is the Copy-and-Swap Idiom:

1. Construct a temporary copy MyString tmp(other); (if this throws, *this is completely untouched!).
2. Swap the internal pointers of tmp and *this in non-throwing O(1) operations.
3. When tmp leaves scope, its destructor safely frees the old buffer.

In C++, moving an object transfers ownership of its underlying heap resources in O(1) time without copying. However, according to the C++ Standard, a moved-from object must be left in a valid, destructible state.

If you simply write:

MyString(MyString&& other) noexcept
    : data_(other.data_), size_(other.size_), capacity_(other.capacity_) {
    other.data_ = nullptr; // DANGEROUS if other.c_str() is subsequently called!
}

If the moved-from string is later accessed via other.c_str(), printing it dereferences nullptr and crashes. The robust idiom delegates to MyString() (which allocates new char[1]{'\0'}) and then swaps with other:

MyString(MyString&& other) noexcept : MyString() {
    swap(other);
}

Now this gets other's live heap buffer, and other receives a valid empty "\0" string!

In real-world applications, over 70% of strings (keys, names, codes, UUID prefixes) are under 16 characters long. Dynamic heap allocations for every 4-byte or 8-byte string create heavy memory fragmentation and CPU cache misses.

Small String Optimization (SSO) replaces the pointer with a stack-allocated buffer when the string is short. By placing a char inlineBuf_[16] inside an anonymous union with char* heapBuf_, strings up to 15 characters (plus the \0 terminator) are stored directly inside the MyString stack frame with 0 heap allocations! When appending causes the string to exceed 15 characters, it automatically transitions to a dynamic heap buffer.