Mail Archives: djgpp/1997/12/08/08:22:45
michael wrote:
>
> dear all c/ c++ programmers
> i have been having problem trying to compile this program for the
> last three days.
> the program has been wriiten correctly, there are no syntax errors. But the
> every time i compile it, the compiler gives me a parse error for line after
> private in the class definition below in addition to a laundry list of more
> errors all refering to string type. . if anyone knows how I can fix this
> problem and why this occurs please send me a reply e-mail. I can't
> understand why this error occurs the program below is from a c++ book, the
> author claims that all the source programs in the book have been tested on a
> variety of platforms and compilers and that all are should work. once again
> i would appriaciate all the help I can get. If you know how to make this
> work or any revisions that are neccessary please reply to me.
> // pTest.cpp
> #include "plisting.h"
> int main() {
> phoneListing list[3];
>
> list[0] = phoneListing("Hall", "Rob", "555-1234");
> list[1] = phoneListing("Esterly", "Anna", "555-9999");
> list[2] = phoneListing("Ching", "June", "555-8888");
> cout << list[0].firstName() << endl;
> cout << list[1].lastName() << endl;
> cout << list[2].phoneNumber() << endl;
> for(int j = 0; j < 3; j++)
> list[j].display();
> return 0;
> }
> ----------------------------------------------------------------------------
> ---------------------------------------
> // Specification file: plisting.h
> // declaring class phonelisting
> #ifndef PLISTING_H
> #define PLISTING_H
> #include <OURSTR.H>
> class phoneListing {
> public:
>
> phoneListing::phoneListing();
> // POST: A phoneListing object is constructed without setting state
>
> phoneListing::phoneListing(string initLast, string initFirst,
> string initNumber);
> void phoneListing::display();
> string phoneListing::lastName();
> string phoneListing::firstName();
> string phoneListing::phoneNumber();
> private:
> string ln, fn pn; // the compiler keeps refering to this line, that
> the parse error
> // occurs before the semi colon...
> };
> #include "plisting.cpp"
> #endif
> ----------------------------------------------------------------------------
> ----------------------------------
> // implementation file: plisting.cpp
> // implements class phoneListing
> phoneListing::phoneListing()
> {
> // default constructor
> }
> phoneListing::phoneListing(string initLast, string initFirst,
> string initNumber)
> {
> ln = initLast;
> ln.toUpper();
> fn = initFirst;
> fn.toUpper();
> pn = initNumber;
> }
> string phoneListing::lastName()
> {
> return ln;
> }
> string phoneListing::firstName()
> {
> return fn;
> }
> string phoneListing::phoneNumber()
> {
> return pn;
> }
> void phoneListing::display()
> {
> cout.width(15);
> cout << firstName() << ' ' << lastName();
> cout.width(20-lastName().length());
> cout << ' ' << phoneNumber() <, endl;
> }
>
> ---------------------------------------------------------------------------------------------------------
>
> //--------------------------------------------------------------------
> // SPECIFICATION FILE: ourstr.h
> //
> // Declares: 1. class string
> // 2. The following overloaded operator functions
> // << output
> // >> input
> // < > >= <= (relational operators)
> // == != (equality operators)
> // + (ops must be string objects or 1 string literal
> //--------------------------------------------------------------------
> #ifndef OURSTR_H // Avoid duplicate compilation
> #define OURSTR_H
> #include <iostream.h> // for class istream and class ostream
> class string {
> public:
> // Default Constructor:
> string::string();
> // POST: String object is set to default null string as in string a;
> // Copy constructor:
> string::string(const string & strObj);
> // POST: Object is copied during argument/parameter associations
> // and during a function return. Objec
> t is also initialized as
> // string anotherStr(aStr);
> // Initializer constructor:
> string::string(const char * initText);
> // POST: Object is initialized using char* argument when constructed
> // as string aStr ("Hall");
> // Destructors, such as ~string, are invoked to deallocate memory
> // automatically when the string object is no longer necessary
> ~string();
> // Qualifying ~string with string:: causes problems on some compilers
> void string::toUpper();
> // POST: The string is converted to upper case.
> // Overload the assignment operator for string objects and char *
> string & string::operator = (const char * rightValue);
> // POST: The lvalue string object stores the string literal and
> // the dynamic length of the expression to the right of =
> // as in s1 = "A string literal"
> string & string::operator = (const string & rightValue);
> // POST: The lvalue string object stores the string literal and
> // the dynamic length of the expression to the right of =
> // as in s1 = s2;
> // Concatenation operator:
> string & string::operator += (const string & right);
> // POST: The right string object is appended to the
> // string object on the left.
> // Access individual characters as in strVar[3]
> char & string::operator [] (int index);
> // POST: A reference to one individual character is returned.
> // This may be applied to non-const objects.
> // Access individual characters as in strVar[3]
> const char & string::operator [] (int index) const;
> // POST: A reference to one individual character is returned.
> // This may be applied to const objects.
> // Accessor function:
> unsigned int string::length() const;
> // POST: The dynamic length of the string object is returned
> // Accessor function:
> char * string::chars() const;
> // POST: The characters (char *) of the string object are returned
> // Could use as arg to ifstream inFile(fileName.theChars());
> private:
> int len; // The length of any one object
> char * theChars; // A pointer to the characters of a string object
> }; // End the string class declaration
> //--------------------------------------------------------------------
> // Allow easy input and output of strings for standard I/O (cin/cout)
> // and simple file I/O with ifstream and ofstream objects only
> //--------------------------------------------------------------------
> ostream & operator << (ostream & os, const string & outputString);
> istream & operator >> (istream & is, string & inputString);
> //--------------------------------------------------------------------
> // Allow catenation and comparison of string objects
> //--------------------------------------------------------------------
> string operator + (const string & left, const string & right);
> string operator + (const string & left, const char * right);
> string operator + (const char * left, const string & right);
> //--------------------------------------------------------------------
> // The overloaded relational operator function prototypes
> //--------------------------------------------------------------------
> int operator < (const string & left, const string & right);
> int operator <= (const string & left, const string & right);
> int operator > (const string & left, const string & right);
> int operator >= (const string & left, const string & right);
> //--------------------------------------------------------------------
> // The overloaded equality operator function prototypes
> //--------------------------------------------------------------------
> int operator == (const string & left, const string & right);
> int operator != (const string & left, const string & right);
> #include "ourstr.cpp" // Add member function implementations
> #endif // OURSTR_H
>
> ----------------------------------------------------------------------------
> --------------------------------
>
> //----------------------------------------------------------------------
> // IMPLEMENTATION file ourstr.cpp
> //
> // Implements: class string
> // Note: This file is automatically included by ourstr.h
> //----------------------------------------------------------------------
> #include <string.h> // for strlen and strcpy
> #include <stdlib.h> // for exit
> #include <iostream.h> // for class istream and class ostream
> #include <ctype.h> // for toupper
> string::string()
> { // Initialize a string object as a null string in string a;
> len = 0;
> theChars = new char[1];
> theChars[0] = 0; // Store the null char into the
> // first byte pointed to by theChars
> }
> string::string(const char * initText)
> { // Initialize string objects as:
> // string strVar ("Initial string");
> // string strVar = "Initial string";
> len = strlen(initText); // Actual length without '\0'
> theChars = new char[len + 1]; // Allocate memory + 1 for '\0'
> if(! theChars)
> { // Terminate program if no more memory
> cout << "**Error** Memory exausted trying to create "
> << initText << endl
> << "...Program terminated..." << endl;
> exit(0);
> }
> strcpy(theChars, initText); // Let theChars point to initText
> }
> string::string(const string & source)
> { // This is the copy constructor which allows string b(a);
> len = source.len;
> theChars = new char[len + 1]; // Allocate memory.
> if(! theChars)
> { // Terminate program if no more memory
> cout << "**Error** Memory exausted trying to create "
> << source.theChars << endl
> << "...Program terminated..." << endl;
> exit(0);
> }
> strcpy(theChars, source.theChars); // Let theChars point to the chars
> // of the copied object.
> }
> unsigned int string::length() const
> {
> return len;
> }
> char * string::chars() const
> {
> return theChars;
> }
> string::~string()
> { // Deallocate memory to avoid exhausting the free store
> delete [] theChars;
> }
> // Upcase the enter string as a member function strVar.toUpper();
> void string::toUpper()
> {
> int lastChar = length();
> for(int j = 0; j <= lastChar-1; j++)
> theChars[j] = toupper(theChars[j]);
> }
> string & string::operator = (const string & rightValue)
> {
> // Skip copying in statements like this: aString = aString;
> if (this != &rightValue)
> {
> delete theChars; // Deallocate memory of old string object
> len = rightValue.len;
> theChars = new char[len + 1];
> strcpy(theChars, rightValue.theChars);
> }
> return *this;
> }
> string & string::operator = (const char * rightValue)
> {
> delete theChars; // Deallocate memeory for the lValue object
> len = strlen(rightValue);
> theChars = new char[len + 1];
> strcpy(theChars, rightValue);
> return *this;
> }
> string & string::operator += (const string & right)
> { // Concatenation
> int combinedLength = this->len + right.len;
> // Allocate enough memory for both operands.
> char * temp = new char[combinedLength + 1];
> if(! temp)
> { // Terminate program if no memory left
> cout << "**Error** Memory exausted trying to create "
> << right.theChars << endl;
> exit(0);
> }
> strcpy(temp, theChars); // 1. Create the
> strcat(temp, right.theChars); // new string
> delete theChars; // 2. Deallocate unneeded memory
> // 3. Point theChars to the same memory as temp
> theChars = temp; // 4. Create and return
> len = combinedLength; // this newly
> return *this; // created object
> }
> char & string::operator [] (int index)
> {
> // The user refers to the first character
> // in the string object with [1], not 0.
> if((index < 0) || (index >= len))
> {
> cout << "\n**Error** For string object `" << theChars
> << "', subscript [" << index << "] is out of range. " << endl;
> cout << "Subscript must be in the range of 1.." << (len-1) << endl;
> exit(0);
> }
> return theChars[index];
> }
> const char & string::operator [] (int index) const
> {
> if((index < 0) || (index > len))
> {
> cout << "\n**Error** For string object `" << theChars
> << "', index [" << index << "] is out of range. " << endl;
> cout << "Index must be in the range of 1.." << (len-1) << endl;
> exit(0);
> }
> return theChars[index];
> }
> ostream & operator << (ostream & os, const string & outputString)
> {
> os << outputString.chars(); // Insert characters to output stream.
> return os;
> }
> istream & operator >> (istream & is, string & inputString)
> {
> char temp[128]; // Allow a very large input string
> is >> temp; // Read chars up to first whitespace.
> inputString = string(temp); // Alter argument to right of >>
> return is;
> }
> string operator + (const string & left, const string & right)
> { // concatenation such as strVar + strVar
> string temp(left); // Create new object with left operand.
> temp += right; // Use the existing operation to create
> return temp; // one string from two string operands.
> }
> string operator + (const string & left, const char * right)
> { // Concatenate as strVar + "a string"; // constant on right
> string temp(left);
> temp += right;
> return temp;
> }
> string operator + (const char * left, const string & right)
> { // Concatenation such as "a string" + strVar; // constant on left
> string temp;
> temp = left;
> temp += right;
> return temp;
> }
> int operator < (const string & left, const string & right)
> {
> return (strcmp(left.chars(), right.chars()) < 0);
> }
> int operator <= (const string & left, const string & right)
> {
> return ! (strcmp(left.chars(), right.chars()) > 0);
> }
> int operator > (const string & left, const string & right)
> {
> return (strcmp(left.chars(), right.chars()) > 0);
> }
> int operator >= (const string & left, const string & right)
> {
> return ! (strcmp(left.chars(), right.chars()) < 0);
> }
> int operator == (const string & left, const string & right)
> {
> return (strcmp(left.chars(), right.chars()) == 0);
> }
> int operator != (const string & left, const string & right)
> {
> return (strcmp(left.chars(), right.chars()) != 0);
> }
>
> the above are all the files in the program. as noted above the parse error
> occurs in the include file plisting.h, in the line after private, where
> the private data
> members are declared. My hunch is that the compiler does not recognize the
> string
> type from the class string.
> thank you
> Mitchell Jordan
> Mjordan2 AT pipeline DOT com
I don't know much about C/C++. I starting to learn. This may sound
real silly but could it be that the '{' after the int(main) shouldn't be
on same line?
You have:
int main() {
Should'nt it be:
int main()
{ ...
...
}
I really don't know about any other errors. Perhaps other users could
suggest something.
Good Luck
Michael Iwaki iwaki AT gte DOT net
--
- Raw text -