Optimize a small-string C++ class

You are implementing a high-performance C/C++ string type that uses a small-string optimization: short strings are stored inline in a fixed buffer, and long strings are stored on the heap.

Given the (simplified) class layout below:

const size_t BUFF_SIZE = 128;

class MyString {
private:
 char buf[BUFF_SIZE]; // inline storage for “small” strings
 size_t length; // number of bytes (not including '\0')
 char* ptr; // heap storage for “large” strings

public:
 MyString(const char* s, size_t len) {
 length = len;
 if (len < BUFF_SIZE) {
 strncpy(buf, s, len);
 buf[len] = '\0';
 } else {
 ptr = (char*)malloc(len + 1);
 if (ptr == nullptr) throw "not enough memory";
 memcpy(ptr, s, len);
 ptr[len] = '\0';
 }
 }
};

Answer the following:

1. strncpy(buf, s, len) copies characters one-by-one conceptually. How would you speed up copying for the small-string case?
2. Is using memcpy(buf, s, len) equivalent to strncpy(buf, s, len)? If not, what are the behavioral differences and safety pitfalls?
3. In a cmp/string-compare function, why can comparing short strings (< 256 bytes) be significantly faster than comparing long strings, even if you “ignore the length difference” conceptually?
4. If BUFF_SIZE == 1, what is the likely sizeof(MyString) on a 32-bit machine vs a 64-bit machine? Explain the role of alignment/padding.
5. If BUFF_SIZE == 8 but typical strings are ~10–15 characters, how could you redesign the layout to reduce object size and improve cache locality? (Hint: avoid paying for both inline storage and a pointer when only one is needed.)