Оператор возврата Возвращает значение нулевого указателя, а не желаемое значение

Question

Я запускал это через debug, а в функции String Substring все работает до оператора return.

'returnString', в коде ниже, имеет правильное значение, когда на обратной линии. Однако, как только я иду к следующей строке (закрывающая скобка сразу после), оно меняется:

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

, который я восходит к деструктору, это значение строки имеет при удалении.

Теперь я бы подумал, что значение будет удалено только после его передачи, но похоже, что он сначала удаляется. Вы, ребята, знаете, как это исправить? Как я уже сказал выше, функция работает отлично (по крайней мере, похоже на нее), есть что-то не так, как она возвращает значение.

линия, которая вызывает на моей строке функции: String LocalString((Address.Substring(0, atIndex))); (Адрес объявляется строка под «частный» в соответствующем файле заголовок)

Substring немного мимо на полпути вниз, сразу после оператора индекса. Если мне кажется, что у меня отсутствует функция или файл, попросите ее. Спасибо за чтение и (я надеюсь) помощь.

string.h файл:

#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; 
}; 

где-то в 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; 
*/ 

Answer 1

Несмотря на комментарий // Assignment operator to perform deep copy класс не имеет определенного пользователем назначение оператор.

По умолчанию компьютер, оператор присваивания выполняет мелкую копию. Содержимый текст будет потерян, как только один экземпляр будет уничтожен.