My code outputs a string with a lot of garbage at the end of it...

[nicole10hart]

can anyone tell me why my code would output the string designated plus ten or more characters of non sense at the end of it? my code also has a header with #include statements and a main that calls the functions.
#include "String.h"

//Default constructor
String::String()
{
Text = NULL;
}

//Init constructor, allocates string size characters long
String::String(int size)
{
Text = new char[size];
}

// Initializes this String with a specified C-string
String::String (char* source)
{
Text = NULL;
*this = source;
}

// Perform deep copy!
String& String::operator = (char* source)
{
//0. Delete old Text
delete [] Text;
//1. Figure out source size
int lengthOfSource = GetLength(source);
//2. Allocate Text, Size +1 to account for a NULL terminator
Text = new char[lengthOfSource];
//3. Copy
for ( int i = 0; i < lengthOfSource; i++)
Text[i] = source[i];
return *this;
}

//Copy constructor, performs deep-copy
String::String(const String& source)
{
Text = NULL;
*this = source;
}

//Assignment operator, performs deep-copy
String& String::operator = (const String& source)
{
return (*this=source.GetText());
}

//Destructor disposes allocated string
String::~String()
{
delete[] Text;
}

// Index operator, returns a reference to a character
//throws an exception when index is out of bounds
char& String::operator [] (int index) const
{
if ( (index < 0) || (index >= GetLength(Text)) )
{
stringstream error;
error << "Exception occurred: String::operator[] index " << index << " is out of bounds (0.." << (GetLength(Text) - 1) << ")";

//throws exception
throw error.str();
}
return Text[index-1];
}
//Concatenation operator, returns a new string
String String::operator + (const String& appendix) const
{
String newText = String(Text);
String newString = GetLength(Text) + appendix.GetLength();
int j = 0;

for (int i = 0; i < GetLength(Text); i++)
{
newString[i] = Text[i];
j++;
}
for (int i = 0; i < appendix.GetLength(); i++)
newString[i+j]= appendix[i];

return newString;
}

//Comparison operators
bool String::operator == (const String& compareTo) const
{
for ( int i = 0; i < compareTo.GetLength(); i++ )
{
if (Text[i] != compareTo[i])
return true;
}
return false;
}
bool String::operator != (const String& compareTo) const
{
return !(*this == compareTo);
}

/*static*/int String::GetLength(char* text)
{
int i = 0;
while ( text[i] != NULL )
i++;
return i;
}

// Returns the length of this String
int String::GetLength() const
{
return GetLength(Text);
}

char* String::GetText() const
{
return Text;
}

//Returns an index of aChar in this String starting the search
// from the startposition; if the character is not found returns NOT_FOUND
int String::Find(char aChar, int startPosition /*= 0*/) const
{
for ( int i = startPosition; i < GetLength(Text); i++)
{
if (Text[i] == aChar)
return i+1;
}
return NOT_FOUND;
}

//Returns a substring of this String starting from startPosition and
//length characters long (if length = 0 then substring spans
// from startPosition until the end of this String)
String String::Substring(int startPosition, int length/* = 0*/) const
{
String newString;
int cnt = 0;
int size = length;
while (size>=0)
{
newString[cnt]=Text[startPosition];
cnt++;
size--;
startPosition++;
}
return newString;
}

// Stream output operator for printing String to console
std::ostream& operator << (std::ostream& out, const String& myString)
{
return out << myString.GetText();
}

[zeroliken]

Wrap your code around code tags it will make your code a lot easier to read

Now for the garbage value try to print the string at all parts of the program(before and after initializaations and assigning values to it ) to see where it gets its garbage values