String class Input

NOTE:

These are a little sketchy...I'll fill in details 'soon'.

Dynamic Array Input

first off, let's examine the nature of dynamic input. we have two main options at this point:
- we could read until the array is full and only grow if we needed to
- we could create a new dynamic array block by block and only transfer its contents when the input is done
which to choose? the first assumes that we have space at the end of our array to fill in and that we will grow by a pre-determined block size (recall our discussion of dynamic memory management and how to avoid odd-sized holes in the heap by using a specified block size for all allocations). well, this isn't our situation with the String class. in the String class, we decided to take up just enough memory to store the string and no more. so there is never any extra and we don't use blocking. we could change our minds, but we'll save that for a future lab/project.
now we are left with the second choice. we read a block of data from the stream and then allocate just enough heap space to hold the read block. this implies two things: we have a pre-allocated (non-dynamic) block of memory into which to read the characters, we have to count the number of actual characters in the block before attempting to allocate our dynamic copy of the data.

our basic approach will be to read a block from the stream and attach them in dynamic copies:

    read block
    while (read succeeded)
    {
        dynamic allocate enough space
        copy block to dynamic space
        read block
    }

but what happens on the second go-around? we'll have a dynamic area from the previous iteration and we'll need to concatenate the latest block to that. hmm...this will need more space.
again, we have two main choices:
- allocate a dynamic area long enough to hold both blocks, copy the first, concatenate the second, finally free the first block (which was dynamic)
- maintain a list of pointers to the dynamic blocks and total up the space at the end for a final allocation. this requires either a dynamically growing array or list. it also requires us to either remember or use strlen to determine the length of each dynamic block.

the second is fairly complicated, but not as bad as it might seem. the first, however, is quite easy to accomplish. for right now, we'll work with the first idea:

    read block
    while (read succeeded)
    {
        if (no previous block)
        {
            dynamic allocate enough space
            copy block to dynamic space
        }
        else
        {
            dynamic allocate enough space for both new and prior blocks
            copy prior block to dynamic space
            concatenate new block to dynamic space
            deallocate prior block (which was dynamic)
        }
        read block
    }

once reading fails, we just need to destroy our old selves and point ourselves to the last block.

Line Terminated Input

here we need to take account of a couple of quirks of the istream getline function. one is that it will set failbit on the stream when MAX-1 characters are read. the second is that it remembers the number of characters read and will return them when you call the associated gcount method of the stream.
finally, we note that the istream getline method returns a reference to the stream being read from -- making it easy to check for failures on the stream.

filling this info into our outline from above:

    while (!strm.getline(block,MAX))
    {
        strm.clear();
        if (no previous block)
        {
            dyn = new char [strm.gcount()+1];
            strcpy(dyn,block);
        }
        else
        {
            dyn = new char [strm.gcount()+strlen(block)+1];
            strcpy(dyn,old_dyn);
            strcat(dyn,block);
            delete [] old_dyn;
        }
    }

but we realize that this leaves much error checking to chance and is still a bit cryptic. finally we realize that the loop itself here only handles when our block is filled -- MAX-1 characters are read. when fewer characters are read, we haven't allocated it at all!

clarifying and fixing the incomplete read:

    old_dyn = nullptr;
// loop to get full blocks
    while (!strm.getline(block,MAX))
    {
        strm.clear();
        if (old_dyn == nullptr)
        {
            dyn = new char [strm.gcount()+1];
            strcpy(dyn,block);
        }
        else
        {
            dyn = new char [strm.gcount()+strlen(block)+1];
            strcpy(dyn,old_dyn);
            strcat(dyn,block);
            delete [] old_dyn;
        }
        old_dyn = dyn;
    }
// process any final incomplete blocks
    if (old_dyn == nullptr)
    {
        dyn = new char [strm.gcount()+1];
        strcpy(dyn,block);
    }
    else
    {
        dyn = new char [strm.gcount()+strlen(block)+1];
        strcpy(dyn,old_dyn);
        strcat(dyn,block);
        delete [] old_dyn;
    }
    old_dyn = dyn;

now we can do the final storage:

    destroy();
    string = old_dyn;
    length = strlen(string);

but, this code still leaves a lot to be desired. it is clunky and a bit slow. it is also a bit repetative.

first let's get rid of the strlen calls -- we know those are a bad idea:

    old_dyn = nullptr;
    had = 0;
// loop to get full blocks
    while (!strm.getline(block,MAX))
    {
        strm.clear();
        if (old_dyn == nullptr)
        {
            dyn = new char [strm.gcount()+1];
            strcpy(dyn,block);
            had = strm.gcount();
        }
        else
        {
            dyn = new char [strm.gcount()+had+1];
            strcpy(dyn,old_dyn);
            strcat(dyn,block);
            delete [] old_dyn;
            had += strm.gcount();
        }
        old_dyn = dyn;
    }
// process any final incomplete blocks
    if (old_dyn == nullptr)
    {
        dyn = new char [strm.gcount()+1];
        strcpy(dyn,block);
        had = strm.gcount();
    }
    else
    {
        dyn = new char [strm.gcount()+had+1];
        strcpy(dyn,old_dyn);
        strcat(dyn,block);
        delete [] old_dyn;
        had += strm.gcount();
    }
    old_dyn = dyn;
    destroy();
    string = old_dyn;
    length = had;

that wasn't too bad. now to remove the huge if that is used twice. a new function:

new_and_cat(&old, block, &had, just_read)
{
    if (old == nullptr)
    {
        dyn = new char [just_read+1];
        strcpy(dyn,block);
        had = just_read;
    }
    else
    {
        dyn = new char [just_read+had+1];
        strcpy(dyn,old);
        strcat(dyn,block);
        delete [] old;
        had += just_read;
    }
    return dyn;
}

and using it:

    old_dyn = nullptr;
    had = 0;
// loop to get full blocks
    while (!strm.getline(block,MAX))
    {
        strm.clear();
        old_dyn = new_and_cat(old_dyn, block, had, strm.gcount());
    }
// process any final incomplete blocks
    old_dyn = new_and_cat(old_dyn, block, had, strm.gcount());
    destroy();
    string = old_dyn;
    length = had;

much nicer. although we should put a little error checking in the new_and_cat function (all those allocations!):

new_and_cat(&old, block, &had, just_read)
{
    if (old == nullptr)
    {
        dyn = new char [just_read+1];
        if (dyn != nullptr)
        {
            strcpy(dyn,block);
            had = just_read;
        }
    }
    else
    {
        dyn = new char [just_read+had+1];
        if (dyn != nullptr)
        {
            strcpy(dyn,old);
            strcat(dyn,block);
            delete [] old;
            had += just_read;
        }
    }
    return dyn;
}

after reading through this for a while, we realize that the outer if is simply protecting the strcat part. the rest is duplicated. also, since 'had' is originally 0 we could += in both halves. and if 'had' is originally 0, it won't affect the allocation size from the second half. making these changes, we see that the two halves are almost identical:

new_and_cat(&old, block, &had, just_read)
{
    if (old == nullptr)
    {
        dyn = new char [had+just_read+1];
        if (dyn != nullptr)
        {
            // don't strcpy(dyn,old); since old is nullptr
            // don't delete [] old; since old is nullptr
            dyn[0] = '\0';
            strcat(dyn,block);
            had += just_read;
        }
    }
    else
    {
        dyn = new char [had+just_read+1];
        if (dyn != nullptr)
        {
            strcpy(dyn,old);
            delete [] old;
            strcat(dyn,block);
            had += just_read;
        }
    }
    return dyn;
}

so, we use a little trickery to remove the outer if:

new_and_cat(&old, block, &had, just_read)
{
    dyn = new char [had+just_read+1];
    if (dyn != nullptr)
    {
        if (old != nullptr)
        {
            strcpy(dyn,old);
            delete [] old;
            old = nullptr;
        }
        else
        {
            dyn[0] = '\0';
        }
        strcat(dyn,block);
        had += just_read;
    }
    return dyn;
}

now we fill in types and headers and other good stuff:

char * new_and_cat(char * &old, const char block[], long &had, long just_read)
{
    char * dyn = new char [had+just_read+1];
    if (dyn != nullptr)
    {
        if (old != nullptr)
        {
            strcpy(dyn,old);
            delete [] old;
            old = nullptr;
        }
        else
        {
            dyn[0] = '\0';
        }
        strcat(dyn,block);
        had += just_read;
    }
    return dyn;
}

long String::getline(istream &strm)
{
    const long MAX = 400;
    long had;
    char * old_dyn;
    char block[MAX];

    old_dyn = nullptr;
    had = 0;

// loop to get full blocks
    while (!strm.getline(block,MAX))
    {
        strm.clear();
        old_dyn = new_and_cat(old_dyn, block, had, strm.gcount());
    }

// process any final incomplete block
    old_dyn = new_and_cat(old_dyn, block, had, strm.gcount());

    destroy();
    string = old_dyn;
    length = had;

    return length;
}

Space Terminated Input

space terminated input is very similar except we will be using >> instead of getline. unfortunately, gcount only works for 'unformatted' input (what the standard calls getline). so, we'll have to do our own string length checking.

a first stab at it would be:

istream & operator >>(istream & strm, String & me)
{
    const long MAX = 400;
    long had;
    char * old_dyn;
    char block[MAX];

    old_dyn = nullptr;
    had = 0;

// loop to get full blocks
    strm >> setw(MAX) >> block;
    while (strlen(block) == (MAX-1))
    {
        old_dyn = new_and_cat(old_dyn, block, had, strlen(block));
        strm >> setw(MAX) >> block;
    }

// process any final incomplete block
    old_dyn = new_and_cat(old_dyn, block, had, strlen(block));

    me.destroy();
    me.string = old_dyn;
    me.length = had;

    return strm;
}

not bad, but a little heavy on the use of strlen. we call it at least twice for each loop -- on the same string! let's try to remove the extra calls:

istream & operator >>(istream & strm, String & me)
{
    const long MAX = 400;
    long had, read;
    char * old_dyn;
    char block[MAX];

    old_dyn = nullptr;
    had = 0;

// loop to get full blocks
    strm >> setw(MAX) >> block;
    while ((read = strlen(block)) == (MAX-1))
    {
        old_dyn = new_and_cat(old_dyn, block, had, read);
        strm >> setw(MAX) >> block;
    }

// process any final incomplete block
    old_dyn = new_and_cat(old_dyn, block, had, read);

    me.destroy();
    me.string = old_dyn;
    me.length = had;

    return strm;
}

much better! some find it difficult to read (no pun intended), but most 'good' programmers consider it elegant to embed assignments like that.