//Overload >> for input
istream & operator>>(istream & in, ComplexNumber & n)
{
    int afterStart = 0;    
    
    char realStream[30];
    char imagStream[30];

    char thisChar = 'X';

    //Hold the input stream    
    char input[64];
    
    //fill the input stream character array with the input    
    in.getline(input, 64);

    for (int i = 0; i < 64; i++)
    {
        thisChar = input[i];
        
        if ((thisChar == '+')||(thisChar == '-'))
        {            
            for (int before = 0; before < (i-1); before++)
            {
                realStream[before] = input[before];
            }
            for (int after = (i+2); after < 64; after++)
            {
                char imagChar = imagStream[afterStart];        

                if(imagChar == 'i')         <=============== This line is causing issues.
                {
                    break;
                }

                imagStream[afterStart] = input[after];

                afterStart++;
            }
        }
    }

    double newReal = atof(realStream);
    double newImag = atof(imagStream);

    if (thisChar == '-')
    {
        newImag = (-1)*(newImag);
    }
    
    cout << newReal << " newReal " << newImag << " newImag" << endl;     
    
    ComplexNumber newComplex(newReal,newImag);

    n = newComplex;
        
    return in;
}

            for (int after = (i+2); after < 64; after++)
            {
                char imagChar = imagStream[afterStart];        

                if(imagChar == 'i')         <=============== This line is causing issues.
                {
                    break;
                }

                imagStream[afterStart] = input[after]; //this initilizes imagStream[afterStart], but...

                afterStart++; //we increase afterStart, so imagStream[afterStart] is again uninitialized...
            }

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;

int getRealNumber(char *in, char *out);
int getImaginaryNumber(char *in, char *out);

int main() {
    char inBuffer[256];
    char realPart[256];
    char imaginaryPart[256];

    int realLen = 0;
    double real = 0;
    double imaginary = 0;



    cout << "Input a complex number ###.### +/- i###.###: ";
    cin.getline(inBuffer, 255); //remeber to leave room for 0x00 char at end of string
    if (realLen = getRealNumber(inBuffer, realPart)) {
        real = atof(realPart);
        if (getImaginaryNumber(inBuffer + realLen, imaginaryPart)) {
            imaginary = atof(imaginaryPart);
        }
    }


    cout << "complex number: " <<inBuffer << endl;
    cout << "Real: " << real << endl;
    cout << "Imaginary: " << imaginary << endl;



    return 0;
}

//returns the number of characters moved over to out.
int getRealNumber(char *in, char *out) {
    int retVal = 0;
    char *ptr = in;
    int hasDecimal = false;
    while (*ptr == 0x20 || *ptr == 0x09) { ptr++; } //ignore initial white space
    //do we even have a valid initilal char [+-0123456789.]
    if (isdigit(*ptr) || *ptr == '.' || *ptr=='-' || *ptr == '+') {
        //The will add a sign into our output if one was present
        if (*ptr=='+' || *ptr=='-') {
            *out = *ptr; //copy the sign to the output
            out++;
            retVal++; //we added a char to the output...
            ptr++; //advance past the sign;
            while (*ptr == 0x20 || *ptr == 0x09) { ptr++; } //ignore any white space
        }

        while (isdigit(*ptr) || *ptr == '.') {
            if (*ptr=='.') {
                if (!hasDecimal) {
                    *out = *ptr;
                    out++;
                    retVal++;
                    hasDecimal=true;
                } else {
                    //Error number as an extra decimal point in it??
                }
            }
            if (isdigit(*ptr)) {
                    *out = *ptr;
                    out++;
                    retVal++;
            }
            ptr++;
        }
    }
    *out=0x00; //zero terminate the string.
    return retVal;
}

//returns the number of characters moved over to out.
int getImaginaryNumber(char *in, char *out) {
    int retVal = 0;
    char *ptr = in;
    int hasDecimal = false;
    while (*ptr == 0x20 || *ptr == 0x09) { ptr++; } //ignore initial white space
    
    //do we even have a valid initilal char [+-0123456789.iI]
    if (isdigit(*ptr) || *ptr == '.' || *ptr=='-' || *ptr == '+' || *ptr=='i' || *ptr=='I') {
        //The will add a sign into our output if one was present
        if (*ptr=='+' || *ptr=='-') {
            *out = *ptr; //copy the sign to the output
            out++;
            retVal++; //we added a char to the output...
            ptr++; //advance past the sign;
            while (*ptr == 0x20 || *ptr == 0x09) { ptr++; } //ignore any white space
        }

        if (*ptr=='i' || *ptr == 'I') {
            ptr++;
            while (*ptr == 0x20 || *ptr == 0x09) { ptr++; } //ignore any white space
        }

        while (isdigit(*ptr) || *ptr == '.') {
            if (*ptr=='.') {
                if (!hasDecimal) {
                    *out = *ptr;
                    out++;
                    retVal++;
                    hasDecimal=true;
                } else {
                    //Error number as an extra decimal point in it??
                }
            }
            if (isdigit(*ptr)) {
                    *out = *ptr;
                    out++;
                    retVal++;
            }
            ptr++;
        }
    }
    *out=0x00; //zero terminate the string.
    return retVal;
}

const ComplexNumber & ComplexNumber::operator+= (const ComplexNumber & rhs) {
    this->real+=rhs.real;
    this->imag+=rhs.imag;
    return *this;
}

const ComplexNumber & operator+= (const ComplexNumber & rhs) {...