Re: Please,help as soon as you can.
From: puzzlecracker (ironsel2000_at_gmail.com)
Date: 02/10/05
- Next message: john townsley: "global objects"
- Previous message: Alan Bashy: "Please,help as soon as you can."
- In reply to: Alan Bashy: "Please,help as soon as you can."
- Next in thread: Karsten Baumgarten: "Re: Please,help as soon as you can."
- Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
Date: 9 Feb 2005 17:22:28 -0800
Alan Bashy wrote:
> Please, guys, In need help with this. It is due in the next week.
Please,
> help me to implement the functions in this programm especially the
first
> three constructor. I need them guys. Please, help me.
>
> This was inspired by Exercise 7 and Programming Problem 8 in Chapter
3 of
> our text.
>
> I have done Exercise 7 for you: Below you will find the ADT
specification
> for a string
> of characters. It represents slightly more that a minimal string
class.
>
>
//--------------------------------------------------------------------------
> -
> #ifndef MyStringH
> #define MyStringH
>
//--------------------------------------------------------------------------
> -
> typedef char CharType; // Allow for other character types
>
> class String
> {
> public:
> // Constructors and Destructor
> String( int capacity = 50 ); // Make empty String with given
capacity
> String( const String & str ); // Copy str
> String( const CharType * str, int capacity = 50 ); // Make str a
String
> ~String();
>
> // Queries
> unsigned Length() const { return count_; }
> bool IsEmpty() const { return (count_ == 0); }
> bool IsFull() const { return count_ == capacity_; }
> int IndexOf( const String & str );
> String SubString( unsigned start, unsigned count ) const; //
Copy out
> const CharType * c_str() const;
>
> // Modifiers
> CharType & operator[]( int index ) { return string_[index]; } //
Unsafe
>
> bool Delete( unsigned start, unsigned count );
>
> bool Insert( unsigned pos, const String & str );
>
> private:
> // You supply the private data members
> };
>
//--------------------------------------------------------------------------
> -
> #endif
>
> Note that this is nearly the header file (*.h) you would use to
declare the
> class. The private data for the class is missing, but there are a
few hints
> in the above code to show you what data is required.
>
> The Constructors and Destructor
>
> String( int capacity = 50 );
> This constructor creates an empty String with the given capacity. If
an
> argument is missing for the parameter capacity, it is given the
default
> value 50 by the compiler.
>
> String( const String & str );
> This constructor is the copy constructor. It creates an exact
duplicate of
> its argument str. This includes duplicating the array of characters
owned
> by the object str.
>
> String( const CharType * str, int capacity = 50 );
> This constructor receives a pointer to a null terminated array of
characters
> of type CharType, which is set to char in the header file, but could
also be
> other types. It also receives an optional argument specifying a
capacity.
> The constructor creates a String object of the given capacity and
sets its
> internal array of characters equal to the array str by copying the
> characters.
>
> The Query Functions
>
> The functions Length(), IsEmpty() and IsFull() return the number of
> characters in the String object, whether the String is empty, and
whether
> the string is full (length = capacity) respectively. Note these
functions
> are implemented in the class declarations and give you some hints
about
> other class details.
>
> int IndexOf( const String & str );
> This functions returns the zero-based index of its String argument
str
> within the String object *this that is used to call the function. If
str
> can not be found as a substring within *this, the value -1 is
returned. For
> example, String("ab").IndexOf( String("b") ) returns 1.
>
> String SubString( unsigned start, unsigned count ) const;
> This function returns a String object, the value of which is the
substring
> that begins at index position start and contains count characters.
The
> value given for start must lie within the String object, and if it
doesn't
> the string String("") is returned. The value of count must not
extend
> beyond the end of the String object, and if it does then count is
truncated
> to correspond to the end of the string. For example,
> String("ab").SubString( 0, 1 ) returns String("a"),
> String("ab").SubString( 0, 3 ) returns String("ab"),
> String("ab").SubString( 3, 1 ) returns String("").
>
> const CharType * c_str() const;
> This function returns a pointer to a dynamically allocated C++ array
of
> characters of type CharType. The array is a null terminated string
> containing a copy of the characters in its String object. For
example,
> String("ab").c_str() returns a pointer to "ab". It is the
responsibility of
> the calling code to delete [ ] the string so returned.
>
> The Modifier Functions
>
> CharType & operator[]( int index ) { return string_[index]; }
> The overloaded operator[] returns a reference to the character at
position
> index which allows individual characters to be read and changed.
For
> example,
> String("abc")[2] = 'a' becomes String("aba"),
> CharType ch = String("abc")[2] produces ch == 'a'.
> Note that this function is already implemented and provides some
hints about
> class details.
>
> bool Delete( unsigned start, unsigned count );
> Function Delete deletes count characters from the string object that
called
> the function, starting at index position start. Arguments start and
count
> obey the same rules as described for function SubString. Use
function
> SubString to preview the substring that would be deleted. Use
function
> IndexOf to find a substring to delete.
>
> bool Insert( unsigned pos, const String & str );
> Function Insert inserts its second argument at the position index in
the
> string that called the function. This function may be used to append
or
> prepend strings to a given string. For example,
> String("abd").Insert( 0, "xyz" ) produces String("xyzabd"),
> String("abd").Insert( 3, "xyz" ) produces String("abdxyz"),
> String("abd").Insert( 2, "c" ) produces String("abcd").
>
> What You Do
>
> Your job is to implement and test this ADT using an array allocated
with the
> new operator in the constructors and de-allocated with the delete []
> operator in the destructor. You will find that three data members
will be
> sufficient for the job. At a minimum, you must test each function
with
> enough different arguments to show it works.
>
> You are allowed to define additional helper functions, member
functions or
> otherwise. For example, the following function allows you to use the
<<
> operator to display a String.
>
> ostream & operator<<( ostream & os, const String & str )
> {
> os << str.c_str();
> return os;
> }
>
> With this function the following works:
>
> String s("My string");
> cout << s << '\n';
>
> Also, the following function compares two C-style "strings" up to n
> "characters" and returns a + value if s1 > s2, a - value if s1 < s2,
and
> zero if s1 == s2.
>
> int MemCmp( const CharType * s1, const CharType * s2, unsigned n )
> {
> // Assume bin op - is defined for type CharType
> for ( unsigned c = 0; c < n; ++c )
> {
> if ( (s1[c] - s2[c]) != 0 )
> return (s1[c] - s2[c]); // s1 > or < s2
> }
> return 0; // s1 == s2
> }
>
> When you need a null character of type CharType use this:
CharType('\0')
>
> How You Do This
> Important: do not attempt to implement this all at once. Start with
the
> constructors and destructor. Implement them one at a time and use
the
> functions Length(), IsEmpty() and IsFull() to output the length of an
> object, whether the object is empty, and whether the object is full.
When
> you get correct results for each constructor, you may proceed to the
next
> phase.
>
> Implement and test function c_str(). This will allow you to output a
string
> using operator <<.
>
> Use the implemented operator [] to display and then change and
display one
> or two strings created in the first phase. When all appears correct
you may
> proceed to the next phase.
>
> Implement and test IndexOf().
>
> Implement and test SubString().
>
> Implement and test Delete().
>
> Implement and test Insert().
>
>
> Your Grade
>
> Your grade will be based on 1) correctness of your code, 2) good
style
> (indentation, variable names, etc.), 3) adequate testing, and 4)
amount
> completed.
>
> It is always better to turn in something rather than nothing. Late
papers
> are not accepted. Incomplete but timely papers may be improved and
> re-submitted within a week.
>
> Failure to attempt 2 or more labs results in failure of the course.
we ARE NOT a homework group!!!!
I have seen certain website where you can submit your assignments, and
they don't charge a great deal. Good Luck!
- Next message: john townsley: "global objects"
- Previous message: Alan Bashy: "Please,help as soon as you can."
- In reply to: Alan Bashy: "Please,help as soon as you can."
- Next in thread: Karsten Baumgarten: "Re: Please,help as soon as you can."
- Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]
Relevant Pages
|
