Return Statement Returning a Null Pointer Value an

问题:

I ran this through debug, and in the String Substring function, everything works up until the return statement.

'returnString', in the code below, has the correct value when at the return line. However, as soon as I go to next line (the closing bracket directly after), it changes to:

{Text=0x003ed0e0 "îþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþîþ... }String

which I traced back to the destructor, is the value the String has when deleted.

Now, I would have thought that the value would be deleted only after it's passed, but it seems like it's getting deleted first. You guys know how to fix this? Like I said above, the function works perfectly (at least, it looks like it), there's just something wrong with how it's returning the value.

The line that calls on my string function: String LocalString((Address.Substring(0, atIndex))); (Address is declared a String under 'private' in the respective header file)

Substring is a little past halfway down, right after the index operator. If it seems like I'm missing a function or a file, ask for it. Thanks for reading and (I'm hoping) the help.

The String.h file:

#pragma once

#include <iostream>
#include <sstream>
using namespace std;

// C++ String class that encapsulates an ASCII C-string
class String
{
public:
    // Default constructor
    String()
    {
        Text = NULL;
    }

    // MUST HAVE: Copy-constructor that performs deep copy
    String(const String& source)
    {
        Text = NULL;
        // Call the assignment operator to perform deep copy
        *this = source;     
    }

    // Init-constructor to initialize this String with a C-string
    String(const char* text)
    {
        Text = NULL;
        // Call the assignment operator to perform deep copy

        *this = text;

    }   

    // Destructor
    ~String()
    {
        delete[] Text;
    }

    // Returns the count of characters in a C-string text; NULL-terminator is not counted
    static int GetLength(const char* text)
    {
        int x = 0;
        while(text[x] != '\0')
            x++;

        return x;
    }

    // Assignment operator to perform deep copy
    String& operator = (const char* text)
    {
        // Ddispose of old Text
        delete[] Text;

        // +1 accounts for NULL-terminator
        int trueLength = GetLength(text) + 1;

        // Dynamically allocate characters on heap
        Text = new char[trueLength];

        // Copy all characters from source to Text; +1 accounts for NULL-terminator
        for ( int i = 0; i < trueLength; i++ )
            Text[i] = text[i];

        return *this;
    }

    // if length is not specified, then the substring spans from startPosition until the end of this String
    // throws an exception when startPosition is out of bounds
    String Substring(int startPosition, int length=0) const
    {
        char * str = this->GetText();
        int strLength = length;
        int x = 0;

        char* substring = new char[strLength];

        while(x < strLength && str[x+startPosition]!='\0')
        {
            substring[x] = str[x + startPosition];
            x++;
        }
        substring[x]='\0';

        String returnString = substring;


        return returnString;    
    }

    // Returns the count of characters in the String; NULL-terminator is not counted
    int GetLength() const
    {
        return GetLength(Text);
    }
private:
    // The encapsulated C-string
    char* Text;
};

somewhere in main.cpp...

String LocalString((Address.Substring(0, atIndex)));
String DomainString((Address.Substring(atIndex + 1)));
// or, in simpler syntax:
/*
 * String hell0 = String andGoodbye;
 * String smile = String andWave;
 */

回答1:

Despite the comment // Assignment operator to perform deep copy the class doesn't have a user defined assignment operator.

The default, computer generated, assignment operator performs a shallow copy. The contained text will be lost as soon as one copy is destroyed.