C++与Pascal字符串差异及内存分配机制，C++字符类型分配使用咨询

Hey there! Let’s tackle your questions about string differences between C++ and Pascal, plus the nuances of char arrays, char*, and const char* in C++. I’ll focus heavily on memory allocation since that’s what you asked about—let’s dive in!

First up, Pascal strings—they’ve got a pretty straightforward approach compared to C++’s two main string types. Let’s split this into traditional static Pascal strings and the dynamic ones you’d see in Delphi or modern Pascal compilers:

Pascal Strings #

• Traditional Static Strings: These are fixed-size blocks of memory with a 1-byte length prefix at the very start. For example, declaring var s: string[10]; allocates 11 consecutive bytes total: 1 byte to store the actual number of characters used, plus 10 bytes for the characters themselves. Depending on scope, this lives either on the stack (if it’s a local variable) or the global data segment (if it’s a global variable). No null terminator is needed here—you just check the length byte to know how much of the buffer is in use.
• Dynamic Strings (e.g., Delphi’s AnsiString): These are reference-counted, heap-allocated structures. The variable you declare holds a pointer to a control block (stored on the heap) that tracks the string’s length, reference count, and the actual character data. When you assign one dynamic string to another, it doesn’t copy the entire character buffer—it just copies the pointer and increments the reference count. Only when you modify the string does it perform a copy-on-write to create a unique buffer for the modified version.

C++ Strings #

C++ has two distinct string systems, each with its own memory rules:

• C-style Strings (Null-terminated): These are just sequences of characters ending with a null byte (\0). There’s no explicit length stored anywhere—you have to calculate the length by scanning the bytes until you hit the null terminator (using functions like strlen()). Where the memory lives depends on how you declare the string (we’ll cover that in detail later).
• std::string: This is the modern, safe string class in C++. Under the hood, it’s a dynamic structure that stores the string’s length, capacity, and a pointer to the character data. Most implementations use heap allocation for larger strings, but small strings often use Small Buffer Optimization (SSO)—storing the characters directly inside the std::string object instead of the heap to avoid overhead. It handles resizing and memory cleanup automatically, so you don’t have to manage it manually.

Core Memory Allocation Differences #

Let’s boil down the key contrasts:

• Length Tracking: Pascal strings (both static and dynamic) store the length explicitly. C-style strings rely on a null terminator, while std::string uses explicit length tracking like Pascal but with modern memory management.
• Memory Location: Traditional Pascal static strings live on the stack or global segment; dynamic Pascal strings are heap-allocated with reference counting. C-style strings can be stack, global, or heap-allocated depending on declaration. std::string uses heap (or SSO) with automatic cleanup.
• Copy Behavior: Dynamic Pascal strings use reference counting + copy-on-write. Pre-C11, std::string also used this, but post-C11, most implementations use value semantics with deep copies (SSO still applies for small strings). C-style strings require manual copying with functions like strcpy().

Now let’s unpack the three C++ types you asked about—each has unique memory rules and use cases:

char Array #

• Memory Allocation:
  • Local arrays (e.g., char buf[10];) live on the stack, with 10 uninitialized bytes by default.
  • Global/static arrays (e.g., static char global_buf[10];) live in the global data segment and are automatically initialized to zero.
  • If you initialize it with a string literal (e.g., char greeting[] = "Hello";), it gets allocated on the stack/global (depending on scope) with exactly enough bytes for the string plus the null terminator—so 6 bytes here ('H','e','l','l','o','\0').
• Usage:
  • You can modify individual characters (e.g., greeting[0] = 'h'; is totally allowed).
  • The size is fixed at compile time—you can’t resize it without manually reallocating (which is messy with arrays).
  • It decays to a char* in most contexts (like when passed to a function), but you can still get its fixed size with sizeof(greeting).

char* (Non-const Pointer to char) #

• Memory Allocation:
  • The pointer itself is allocated on the stack (if local) or global segment (if global). What it points to varies:
    • If pointing to a string literal (e.g., char* ptr = "Hello";), it’s pointing to a read-only string literal pool (global data segment). Note: This is technically undefined behavior in C++ because string literals are const—compilers might let you do it, but modifying the literal will crash your program.
    • If pointing to a heap-allocated buffer (e.g., char* heap_buf = new char[10];), it points to memory on the heap. You must manually call delete[] heap_buf later to avoid memory leaks.
    • If pointing to a char array (e.g., char buf[10]; char* ptr = buf;), it points to the stack/global memory of the array.
• Usage:
  • You can modify the data it points to only if the underlying memory is writable (like a heap buffer or char array—never a string literal).
  • It doesn’t track size—you need to either rely on the null terminator or pass a separate length variable.
  • You can reassign it to point to different memory locations (e.g., ptr = another_buf; works fine).

const char* (Pointer to const char) #

• Memory Allocation:
  • Like char*, the pointer itself lives on the stack/global. What it points to is usually:
    • A string literal (e.g., const char* msg = "Hello";), which resides in the read-only string literal pool—this is the safe, correct way to reference string literals in C++.
    • A const char array (e.g., const char buf[] = "Hi"; const char* ptr = buf;), which is stack/global allocated and read-only.
    • A heap-allocated const buffer (less common, e.g., const char* heap_ptr = new const char[10];), but you can’t modify this data.
• Usage:
  • You can’t modify the data it points to—any attempt (like msg[0] = 'h';) will throw a compile error (or cause undefined behavior if you cast away const, which you should never do).
  • It’s the preferred type for passing read-only string data to functions, as it enforces immutability and prevents accidental modifications.
  • You can reassign it to point to other const char data (e.g., msg = "World"; is allowed).

Quick Cheat Sheet #

内容的提问来源于stack exchange，提问作者Jack McCall