String ADT HELP! Pointer problems

[ilikenwf]

I am done and this compiles and everything (except for one of the provided files, which seems to have errors itself...I exclude that from the build until I need it, but will post it too). The only code I made is the implementation. Other than that, the others are provided to me. I need this before tomorrow, if you can help me. This is probably a stupid typo or something but I am at my wit's end.

I am having problems with a pointer somewhere. I am using VC++, and I get problems like

 "Unhandled exception at 0x1022fb10 in lab3.exe: 0xC0000005: Access violation reading location 0x00000000." 
 
+        this    0x0012fef0 {bufferSize=1 buffer=0x00000000 <Bad Ptr> }    const String * const
        bufferSize    1    int
+        buffer    0x00000000 <Bad Ptr>    char *
 
 
+        buffer    0x00000000 <Bad Ptr>    char *
 

whenever I input anything at run time, yet the output is all correct. It says the problem is something to do with ostream...

[ilikenwf]

implementation:

//--------------------------------------------------------------------
//
//                                              STRADT.CPP
//
//  Implementation of the String ADT
//
//--------------------------------------------------------------------
 
 
#include <iostream>
#include "stradt.h"
#include <cstring>
 
//constructor used if a numeral amount of characters is passed in
//inputs: numChars, the number of characters for the string
//outputs: none
String::String ( int numChars )            // Create an empty string
{    
 
    bufferSize = numChars + 1; //declare a variable for the size, add 1 for delimiter
    if ( numChars <= 1 ) //if numChars is 1 or smaller it won't work, due to delimiter 
        {
         buffer = 0; //set as zero so that an obvious error is apparent
        }
    else //otherwise, create the string with the specified number of characters, initialized to 0
        {
         buffer = new char[numChars]; 
         buffer[0] = 0;
        }
}
 
//constructor used if a sequence of characters is entered
//inputs: charSeq points to the character sequence entered
//outputs: none
String::String ( const char *charSeq )      // Initialize using char*
{
 
   bufferSize = strlen(charSeq) +1;          // find length of charSeq
 
   buffer = new char[bufferSize + 1]; // allocate memory for charSeq + the delimiter
 
   strcpy(buffer, charSeq);             // copy the charSeq into the buffer
 
}
 
//destructor, to clear the buffer data
//inputs:none
//outputs:none
String::~String ()
{
    delete [] buffer; //clear the buffer 
}
 
//length - finds the length of the buffer
//inputs: none
//outputs: length of the buffer
int String::length () const
{
    return strlen(buffer); //return the buffer's length
} 
 
// [] operator overload - subscript, returns contents of buffer slot n
//inputs:n, an int representing the desired slot
//outputs:contents of a slot
char String::operator [] ( int n ) const
{
    if (n <= strlen(buffer)) //if the number is less than or equal to the length of the buffer
    { 
        return  buffer[n] ; //go ahead and return what is in the slot
    }
    else 
        return 0; //otherwise, return 0 so that user will see the error
}
//assignment operator overload - copies the contents of rightString into the buffer
//inputs: &rightString, whatever its contents may be
//outputs:none
void String::operator = ( const String &rightString )   // Assignment
{
            if (buffer == rightString.buffer) //if they are the same
            {
                                NULL; //don't do anything
            }
 
            else //otherwise...
            {
                bufferSize = rightString.bufferSize; //make sure that the size of buffer is the same as rightString
 
                delete [] buffer; //delete the contents of buffer
                buffer  = new char [bufferSize]; //reassign buffer with a string of bufferSize
 
                strcpy(buffer, rightString.buffer); //finally, copy rightString's buffer into buffer
            }
 
 
}
 
//clear function - clears the buffer, and sets its size to zero
//inputs: none
//outputs: none
void String::clear()
{
    buffer[0] = 0; //set buffer entries to zero
    bufferSize = 0; //reuce buffer slots to zero
}
 
//showstructure- used to display contents of the buffer
//inputs:none
//outputs: none
void String::showStructure () const
{
    std::cout << buffer << std::endl; //output the buffers, using the standard namespace
}
 
//copy constructor - copies the contents of valueString into buffer
//inputs:valueString
//outputs:none
String::String ( const String &valueString )
{
    bufferSize = valueString.bufferSize; //make sure the bufferSize is the same as valueString's
 
    buffer = new char[bufferSize]; //reassign buffer with a string of bufferSize slots
 
    strcpy(buffer, valueString.buffer); //copy contents of valueString's buffer into buffer
 
}    
 
// == operator overload - (friend function), compares leftString and rightString buffers to see if they are equal
//inputs: leftString and rightString
//outputs 1 or 0, depending on true or false
int operator == ( const String &leftString, const String &rightString )
{
    if ((strcmp(leftString.buffer, rightString.buffer)) == 0) //if they are the same
        return 1; //return true
    else
        return 0;//otherwise return false
}
 
// < operator overload - (friend function), sees if leftString's buffer is greater than rightString's
//inputs: leftString and rightString
//outputs 1 or 0, depending on true or false
int operator <  ( const String &leftString, const String &rightString )
    {
        if ((strcmp(leftString.buffer, rightString.buffer)) < 0) //if leftString is larger
            return 1;//return true
        else
        return 0;//otherwise return false
    }
 
// > operator overload - (friend function), sees if leftString's buffer is less than rightString's
//inputs: leftString and rightString
//outputs 1 or 0, depending on true or false
int operator >  ( const String &leftString, const String &rightString )
    {
        if ((strcmp(leftString.buffer, rightString.buffer)) > 0)//if leftstring is less than rightString
            return 1;//return true
        else
        return 0;//otherwise return false
    }

[ilikenwf]

header:

//--------------------------------------------------------------------
//
//  Laboratory 3                                            stradt.h
//
//  Class declaration for the array implementation of the String ADT
//
//--------------------------------------------------------------------
 
class String
{
  public:
 
    // Constructors
    String ( int numChars = 0 );            // Create an empty string
    String ( const char *charSeq );         // Initialize using char*
 
    // Destructor
    ~String ();
 
    // String operations
    int length () const;                             // # characters
    char operator [] ( int n ) const;                // Subscript
    void operator = ( const String &rightString );   // Assignment
    void clear ();                                   // Clear string
 
    // Output the string structure -- used in testing/debugging
    void showStructure () const;
 
    // In-lab operation
    String ( const String &valueString );          // Copy constructor
 
  private:
 
    // Data members
    int bufferSize;   // Size of the string buffer
    char *buffer;     // String buffer containing a null-terminated
                      // sequence of characters
 
  // Friends
/*
    // String input/output operations (In-lab Exercise 1)
    friend istream & operator >> ( istream &input,
                                   String &inputString );
    friend ostream & operator << ( ostream &output,
                                   const String &outputString );
*/
    // Relational operations (In-lab Exercise 3)
    friend int operator == ( const String &leftString,
                             const String &rightString );
    friend int operator <  ( const String &leftString,
                             const String &rightString );
    friend int operator >  ( const String &leftString,
                             const String &rightString );
 
};

test program:

//--------------------------------------------------------------------
//
//  Laboratory 3                                           test3.cpp
//
//  Test program for the operations in the String ADT
//
//--------------------------------------------------------------------
 
#include <iostream>
#include "stradt.h"
 
using namespace std;
 
//--------------------------------------------------------------------
//
//  Function prototype
 
void dummy ( String copyString );   // copyString is passed by value
 
//--------------------------------------------------------------------
 
 
void main()
{
    String a("a"),                // Predefined test strings
           alp("alp"),
           alpha("alpha"),
           epsilon("epsilon"),
           empty,
           assignStr(5),          // Destination for assignment
           inputStr(5);           // Input string
    int n;                        // Input subscript
    char ch,                      // Character specified by subscript
         selection;               // Input test selection
 
    // Get user test selection.
 
    cout << endl << "Tests:" << endl;
    cout << "  1  Tests the constructors" << endl;
    cout << "  2  Tests the length operation" << endl;
    cout << "  3  Tests the subscript operation" << endl;
    cout << "  4  Tests the assignment and clear operations" << endl;
    cout << "  5  Tests the copy constructor         (Inactive : "
         << "In-lab Exercise 2)" << endl;
    cout << "  6  Tests the relational operations    (Inactive : "
         << "In-lab Exercise 3)" << endl;
    cout << "Select the test to run : ";
    cin >> selection;
 
    // Execute the selected test.
 
    cout << endl;
    switch ( selection )
    {
      case '1' :
           // Test 1 : Tests the constructors.
           cout << "Structure of various strings: " << endl;
           cout << "string: alpha" << endl;
           alpha.showStructure();
           cout << "string: epsilon" << endl;
           epsilon.showStructure();
           cout << "string: a" << endl;
           a.showStructure();
           cout << "empty string" << endl;
           empty.showStructure();
           break;
 
      case '2' :
           // Test 2 : Tests the length operation.
           cout << "Lengths of various strings:"  << endl;
           cout << " alpha   : " << alpha.length() << endl;
           cout << " epsilon : " << epsilon.length() << endl;
           cout << " a       : " << a.length() << endl;
           cout << " empty   : " << empty.length() << endl;
           break;
 
      case '3' :
           // Test 3 : Tests the subscript operation.
           cout << "Enter a subscript : ";
           cin >> n;
           ch = alpha[n];
           cout << "  alpha[" << n << "] : ";
           if ( ch == '\0' )
              cout << "\\0" << endl;
           else
              cout << ch << endl;
           break;
 
      case '4' :
           // Test 4 : Tests the assignment and clear operations.
           cout << "Assignments:" << endl;
           cout << "assignStr = alpha" << endl;
           assignStr = alpha;
           assignStr.showStructure();
           cout << "assignStr = a" << endl;
           assignStr = a;
           assignStr.showStructure();
           cout << "assignStr = empty" << endl;
           assignStr = empty;
           assignStr.showStructure();
           cout << "assignStr = epsilon" << endl;
           assignStr = epsilon;
           assignStr.showStructure();
           cout << "assignStr = assignStr" << endl;
           assignStr = assignStr;
           assignStr.showStructure();
           cout << "assignStr = alpha" << endl;
           assignStr = alpha;
           assignStr.showStructure();
           cout << "Clear assignStr" << endl;
           assignStr.clear();
           assignStr.showStructure();
           cout << "Confirm that alpha has not been cleared" << endl;
           alpha.showStructure();
           break;
 
  case '5' :                                  // In-lab Exercise 2
        // Test 5 : Tests the copy constructor.
        cout << "Calls by value:" << endl;
        cout << "alpha before call" << endl;
        alpha.showStructure();
        dummy(alpha);
        cout << "alpha after call" << endl;
        alpha.showStructure();
        cout << "a before call" << endl;
        a.showStructure();
        dummy(a);
        cout << "a after call" << endl;
        a.showStructure();
        break;
 
   case '6' :                                  // In-lab Exercise 3
        // Test 6 : Tests the relational operations.
        cout << "  left     right     <   ==   > " << endl;
        cout << "--------------------------------" << endl;
        cout << " alpha    epsilon    " << (alpha<epsilon)
             << "    " << (alpha==epsilon) << "   "
             << (alpha>epsilon) << endl;
        cout << " epsilon   alpha     " << (epsilon<alpha)
             << "    " << (epsilon==alpha) << "   "
             << (epsilon>alpha) << endl;
        cout << " alpha     alpha     " << (alpha<alpha) << "    "
             << (alpha==alpha) << "   " << (alpha>alpha) << endl;
        cout << "  alp      alpha     " << (alp<alpha) << "    "
             << (alp==alpha) << "   " << (alp>alpha) << endl;
        cout << " alpha      alp      " << (alpha<alp) << "    "
             << (alpha==alp) << "   " << (alpha>alp) << endl;
        cout << "   a       alpha     " << (a<alpha) << "    "
             << (a==alpha) << "   " << (a>alpha) << endl;
        cout << " alpha       a       " << (alpha<a) << "    "
             << (alpha==a) << "   " << (alpha>a) << endl;
        cout << " empty     alpha     " << (empty<alpha) << "    "
             << (empty==alpha) << "   " << (empty>alpha) << endl;
        cout << " alpha     empty     " << (alpha<empty) << "    "
             << (alpha==empty) << "   " << (alpha>empty) << endl;
        cout << " empty     empty     " << (empty<empty) << "    "
             << (empty==empty) << "   " << (empty>empty) << endl;
        break;
 
      default :
           cout << "Inactive or invalid test" << endl;
    }
 
    cin.ignore();
    cin.ignore();
}
 
//--------------------------------------------------------------------
 
void dummy ( String copyString )
 
// Dummy routine that is passed a string using call by value. Outputs
// copyString and clears it.
 
{
    cout << "Copy of string" << endl;
    copyString.showStructure();
    cout << "Clear copy" << endl;
    copyString.clear();
    copyString.showStructure();
}

[ilikenwf]

the buggy Strio.cpp, which thows the following errors for no apparent reason (I didn't create this, it was part of the project files for testing...

first, the errors:

1>------ Build started: Project: lab3, Configuration: Debug Win32 ------
1>Compiling...
1>STRIO.CPP
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : error C2143: syntax error : missing ';' before '&'
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : error C2065: 'input' : undeclared identifier
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : error C2065: 'String' : undeclared identifier
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : error C2065: 'inputString' : undeclared identifier
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
1>c:\users\projects\112\lab3\lab32\lab3\strio.cpp(14) : fatal error C1903: unable to recover from previous error(s); stopping compilation
1>Build log was saved at "file://c:\Users\projects\112\LAB3\lab32\lab3\Debug\BuildLog.htm"
1>lab3 - 7 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
 

the cpp file:

//--------------------------------------------------------------------
//
//  Laboratory 3, In-lab Exercise 1                        strio.cpp
//
//  String input/output operations
//
//--------------------------------------------------------------------
 
#include <iostream>
#include <iomanip>
 
//--------------------------------------------------------------------
 
istream & operator >> ( istream &input, String &inputString )
 
// String input function. Extracts a string from istream input and
// returns it in inputString. Returns the state of the input stream.
 
{
    const int textBufferSize = 256;     // Large (but finite)
    char textBuffer [textBufferSize];   // text buffer
 
    // Read a string into textBuffer, setw is used to prevent buffer
    // overflow.
 
    input >> setw(textBufferSize) >> textBuffer;
 
    // Apply the String(char*) constructor to convert textBuffer to
    // a string. Assign the resulting string to inputString using the
    // assignment operator.
 
    inputString = textBuffer;
 
    // Return the state of the input stream.
 
    return input;
}
 
//--------------------------------------------------------------------
 
ostream & operator << ( ostream &output, const String &outputString )
 
// String output function. Inserts outputString in ostream output.
// Returns the state of the output stream.
 
{
   output << outputString.buffer;
   return output;
}