C++输出垃圾数据清除方法及自定义字符串插入类问题排查

Hey there! Let's tackle your two C++ issues one by one—first clearing garbage data from output, then building that string insertion class without using the standard string type.

1. Fixing Garbage Data in Output #

Garbage data in your output almost always stems from a few common mistakes with C-style strings. Here's why it happens and how to fix it:

Common Causes of Garbage Data #

• Uninitialized variables: If you declare a char array or pointer without setting its values, it'll hold whatever random data was in that memory location before.
• Missing null terminator ('\0'): C-style strings rely on this character to mark the end. Without it, functions like your StrLen will keep reading past the intended string into garbage memory.
• Memory out-of-bounds access: Writing beyond the allocated length of your array can overwrite adjacent memory, leading to unexpected garbage in your output.

Fixes to Implement #

• Always initialize variables: For char arrays, use {0} to set all bytes to 0 (including the null terminator). For dynamic pointers, allocate enough space and explicitly set the last byte to '\0'.
• Validate string lengths: Ensure any function handling your strings stops at the null terminator, and never write beyond the allocated memory size.
• Double-check memory allocation: When using new for char arrays, allocate required_length + 1 bytes to make room for the null terminator.

2. Implementing a Custom String Insertion Class #

Let's build a class that handles string insertion without using std::string—only iostream is allowed. We'll bake in fixes to avoid garbage data as we go.

Complete Implementation #

#include "stdafx.h"
#include <iostream>
using namespace std;

// Helper function: Calculate C-style string length (with null pointer guard)
int StrLen(const char* s) {
    int len = 0;
    if (s == nullptr) return 0;
    while (s[len] != '\0') {
        len++;
    }
    return len;
}

class CustomString {
private:
    char* data;
    int length; // Length of the string (excluding null terminator)

public:
    // Default constructor (empty string)
    CustomString() : data(nullptr), length(0) {}

    // Constructor from C-style string
    CustomString(const char* str) {
        length = StrLen(str);
        // Allocate space for string + null terminator
        data = new char[length + 1];
        // Copy every character, including the null terminator
        for (int i = 0; i <= length; i++) {
            data[i] = str[i];
        }
    }

    // Destructor to free allocated memory (prevents leaks/dangling pointers)
    ~CustomString() {
        delete[] data;
        data = nullptr;
    }

    // Insert another CustomString into this one at position 'pos'
    void Insert(const CustomString& insertStr, int pos) {
        // Clamp invalid positions to valid range
        if (pos < 0) pos = 0;
        if (pos > length) pos = length;

        int insertLen = insertStr.length;
        int newLength = length + insertLen;

        // Allocate new memory for the combined string (plus null terminator)
        char* newData = new char[newLength + 1];

        // Step 1: Copy original string up to insertion position
        for (int i = 0; i < pos; i++) {
            newData[i] = data[i];
        }

        // Step 2: Copy the string to insert
        for (int i = 0; i < insertLen; i++) {
            newData[pos + i] = insertStr.data[i];
        }

        // Step 3: Copy remaining characters from original string
        for (int i = pos; i < length; i++) {
            newData[pos + insertLen + (i - pos)] = data[i];
        }

        // Critical: Add null terminator to avoid garbage data
        newData[newLength] = '\0';

        // Clean up old data and update class state
        delete[] data;
        data = newData;
        length = newLength;
    }

    // Print the string safely
    void Print() const {
        if (data != nullptr) {
            cout << data << endl;
        } else {
            cout << "(Empty string)" << endl;
        }
    }
};

// Test the class
int main() {
    CustomString original("Hello World!");
    CustomString insert(" beautiful");

    cout << "Original string: ";
    original.Print();

    original.Insert(insert, 5); // Insert right after "Hello"
    cout << "After insertion: ";
    original.Print();

    return 0;
}

Key Garbage Data Prevention Features #

• Proper memory allocation: We always allocate length + 1 bytes to include the null terminator, so cout and other functions know exactly where the string ends.
• Explicit null terminator: After combining strings, we manually set newData[newLength] = '\0'—no more reading past the string into random memory.
• Null pointer guards: The StrLen function checks for null inputs to avoid crashes and incorrect length calculations.
• Clean destructor: We free allocated memory to prevent leaks and dangling pointers, which can cause unexpected garbage in subsequent operations.

内容的提问来源于stack exchange，提问作者Samer Yousef