String Class Constructors

[Myxamatosis]

Our assignment calls for us to create a user defined string class, without using anything from the directories string.h, string, or cstring.

however in the implementation file we're given, there are two different forms of the constructor.

 String(const string&); 

and

String(const char[ ] ); 

The variables are as follows.

unsigned Length;
unsigned Capacity;
char * Mem;
 

I have a general idea about the string& constructor, though I'm not sure how to apply the c-type data.

String::String(const string& RHS )
{
  Length = RHS.Length;
  Capacity = RHS.Capacity;
  Mem = RHS;
}
 

but I know that's not right, namely the Mem part.

the const char [] constructor is really where I have no clue, since I'm not sure how to check the length of the data being inserted into the array, namely, how to set Length.

Also, How does the program differentiate between the two constructors? what If I were to compare two different 'strings' and wanted to use the c-type array?

Help is greatly appreciated.

[Laharl]

A C-string is ended by a terminating null character, '\0'. The ASCII code for this special character is 0. The program (meaning the compiler) can tell the difference between the constructors because the parameters are different.

To compare two different strings, you first need to see if they are the same length. Then you can check if all the characters are the same.

[Myxamatosis]

but how exactly does the code for the inside of each constructor go? How close am I on understanding the first constructor?

I'm still unsure on how to construct the c-type.
something like

 x = [hello world];
A = new String(x);
 

but what exactly goes into the constructor to achieve this? I'm unsure on what to do or how to get it to work.

[Myxamatosis]

alright, update on my constructors...The first one (copy existing String) looks okay, but I'm still unsure on the C-style constructor.

String::String(const String& RHS)
{
    Length = RHS.Length;
    Capacity = RHS.Capacity;
    Mem = new char[Length+1];
 
    for (unsigned i = 0; i < Length ; i++ )
    {
        Mem[i] = RHS[i];
    }
 
    Mem[Length] = "\0";
}
 

Here's the other one I'm not sure on

String::String(const char[] str)
{
    Mem = [str];
    Length = str.Length();
    Capacity = str.Capacity();
}
 

How close is this to the proper way of constructing the objects? is there a way to test just these constructors to see if they work?

[oler1s]

If you want to see if the code you wrote works, why don't you try it out in a compiler? Sometimes, experimentation is a great way to learn. No one is born enlightened. Besides, it's pure silly if you start writing large blocks of code without checking with a compiler.

You may want to learn about initializer lists. They'll come in handy for the String& constructor. What about Length? If I gave you a String&, and asked you to tell me the length, how would it work? Finally, there's a critical difference between "\0" and '\0'. The type of quotes do have a meaning. The mistake you made should actually fail on compilation.

Your constructor that works with C strings is a pure mess, however. Fundamentally, you seem to lack proper understanding of what a C string is. A Cstring is an array of characters. With the one special property that it is terminated by the \0 character at the end of the other characters. A Cstring is not a first class citizen in C or C++. It does not have any special properties. It does not undergo special code. So you can't do something with a C string that wouldn't make any sense with a normal array. That means, you can do Length(), you can't do Capacity(), and [str] makes absolutely no sense.

Cstrings are tricky. But they are at heart, simple arrays. So you need to understand how arrays work, really really well. If you are having trouble converting logic into code, ask here. But don't guess at the code.

[Myxamatosis]

yeah, things start to clear up when you get a good night's sleep.

okay, so with the c-style string, I'm passing in an array. Since we're not allowed to use strlen, I'm going to have to loop down that array, counting each character, until I hit the \0.

int num = 0, lenCount = 0;
while ( str[num] != '\0' )
{
  lenCount += 1;
  num++;
}
 

then I'm going to have to create a new buffer to place this array in, yes?

Mem = new char[lenCount];
 

then fill it, much like the copy constructor does.

Now the logic that I'm still not quite getting is the capacity. Would I set it initially to the value of Length? when I do need to increase it, isn't it increased by a number of 16? and yes, I do know that capacity cannot be less than the length.

The reason I'm asking about capacity is because we need to create an append (+=) operator, though I don't know how exactly I'd increase the capacity in my code.

As for testing, if A was an string of array [Hello World], would cout << A give me hello world, or do I need to build the << overload before testing?

Thanks again for your help.

[Laharl]

I'm not quite sure what you mean about 'a string with array [Hello World]', but you probably need to overload it either way.

Capacity should be initially set to the value of length, I guess, as long as you update it every time you need to increase the size.

Also, you'll need to add one to lenCount, since the code as written doesn't include the null terminator. You also need to include space for said null terminator in the new array, so take that into consideration.

[Myxamatosis]

when capacity is increased, would I create a new spot in memory that's of longer length? or can the original one be updated?

so if I had a String that contained 'hello' and one that contained 'world', could I update 'hello's capacity to something like 16 and then add 'world'?

logically I just don't see how updating the capacity variable creates more memory in that array.

[oler1s]

okay, so with the c-style string, I'm passing in an array. Since we're not allowed to use strlen, I'm going to have to loop down that array, counting each character, until I hit the \0.

Precisely. Although in your code, your use of both num and lenCount is redundant.

then I'm going to have to create a new buffer to place this array in, yes?...then fill it, much like the copy constructor does.

Correct. But be careful about the size of the array. Use examples to determine if you have off by one errors and what not. If I have the array H E L L O \0 , what does lenCount give me? Don't assume. Walk through the loop as many times as it takes, and write down the values of num vs. lenCount. What do you get? And how big does your new array have to be? (By asking this question, I think you have an off by one error).

Now the logic that I'm still not quite getting is the capacity. Would I set it initially to the value of Length?

Depends on how you define Length.

when I do need to increase it, isn't it increased by a number of 16?

By what logic?

The reason I'm asking about capacity is because we need to create an append (+=) operator, though I don't know how exactly I'd increase the capacity in my code.

Sit and think about it for a while. String concatenation and appending is a real problem in programming. Come up with some ideas, and think about how efficient they are. And yes, depending on how it's implemented, string appending can be really, really inefficient.

As for testing, if A was an string of array [Hello World], would cout << A give me hello world, or do I need to build the << overload before testing?

As in, if you were to try to pass your string class to the << operator, would it automatically print out the contents? No way. You have to deal with the overload yourself. There's a few traps in doing this, so for testing purposes, you may want to put a quick hack of a debug function in your code. Once you get everything else working, we can help you tackle the ostream overload.

[Myxamatosis]

alright, here's what i've been thinking on for the += operator.

   void String::operator+=(const String& rhs)
   {
      unsigned short rhsLen = rhs.Length;
      unsigned short totalLen = Length + rhsLen;
      String  temp(totalLen);
      for (unsigned short i = 0; i<Length; i++)
         temp[i] = Mem[i];
      for (unsigned short j = 0; j<rhs.Length; j++, i++)
         temp[i] = rhs[i-Length];
      temp[totalLen]='\0';
      *this = temp;
   }
 

Though this way doesn't deal with the capacity of the memory, since a new String is created.

As for what 'capacity' is defined as in our program, this was what it says.
" The length of a data object of type "String" is the number of characters
that it contains; the capacity is the number of bytes of memory which have
been allocated to hold those characters. The capacity is always a multiple
of 16 bytes, and is always greater than or equal to the length."

I don't know if that helps, or if it changes the design of my operator.

[Myxamatosis]

so instead of creating a new String object every time the += operator is called, wouldn't this work better and more efficient?

String& String::operator+= (const String& rhs)
{
  unsigned totalLen = rhs.Length + Length;
  if (totalLen < Capacity)
    {
      //fill the Mem[] with the rhs String
    }
  else
  {
    Capacity = totalLen; //or Capacity = Capacity*2, just something that
    //fill the Mem[] with the rhs String once Capacity has been increased
  }
  return *this;
}
 

also, I'm still not sure on how to print these variables to test the constructor/operator without already having the << overloaded. is there some sort of code availiable?

[Laharl]

You can print the integers with no trouble, though the C-string will require a loop to print each character. Printing the class as a whole, though, (aka passing a string object to <<), will require the overload function to be written.

Your append code is a good start, I think.

[Myxamatosis]

I'm getting some errors on testing the constructors. I've built a small main program to print out these Strings, though I have some errors that don't make sense to me

proj07.main.cpp:9: error: new types may not be defined in a return type
proj07.main.cpp:9: error: extraneous `int' ignored
proj07.main.cpp:9: error: `main' must return `int'

proj07.string.cpp:14: error: new types may not be defined in a return type
proj07.string.cpp:14: error: return type specification for destructor invalid
In file included from proj07.main.cpp:6:

Explanations are fine, and if you need the code to see, let me know

[Laharl]

Destructors, like constructors, return nothing. Not void, nothing. Main has to return an int, conventionally zero for a successful run. That's about all I can give you without seeing code.

[Myxamatosis]

If i have the implementation file and source file separate, how do i pass around the private variables? I know that private variables are limited to the class itself, but isn't the source code file implementing part of the class?

[Laharl]

If you declare the private variables in the .h, and then #include the .h in your .cpp, you can use the private variables without issues in your function implementations.