[Dev-C++] Reversing a string word by word - advice on my code please

[Daniel G. <sp...@ho...>]

Hi all,
I'd appreciate some code review on the logic of this function I wrote.
I'm using C# (does Dev support C# ?) (with the csc.exe compiler) to reverse 
a string and after a bit of struggling (though an idiotic mistake on my part 
- it is really embarassing) I managed it, and would like you to have a look 
at the code and tell me if there is a better way of doing it.

The logic is in question here, so don't worry about not knowing C#. 
StringManip is my class which has one 'string' member we are interested in, 
mCompanyName, which is being reversed.

/* ReverseSentenceByWord() is a function that reverses individual words in a 
string. It does this
           by looking for spaces and reverses all the letters before that 
space.
        */
        public void ReverseSentenceByWord(ref StringManip SentenceObj)
        {
            string Sentence = SentenceObj.mCompanyName;

            // This number increases each time the iterator moves forward, 
counting the length of the word.
            int CharsInWord = 0;
            // StartOfWord is a marker for where the start of the word 
begins. For example the first word will
            // always start at 0 (first element), but the next word may 
start 7 characters in (6).
            // This is required to reverse only one word at a time.
            int StartOfWord = 0;
            int EndOfWord = 0;
            int Iterator = 0;

            // What is the total length of the sentence?
            int TotalChars = Sentence.Length;

            // While we are not at the end of the string continue to run the 
code inside
            while(Iterator != TotalChars)
            {
                // If this is the second time around then the start of the 
word variable needs to change
                // (otherwise we'd be counting from the first letter every 
time).
                StartOfWord = Iterator;
                // Same for the number of characters in the word.
                CharsInWord = 0;

                // Count how many characters there are from the current 
iterator position to the next space.
                // But be sure to guard against indexing the end of the 
array.

                while(Sentence[Iterator] != ' ')
                {
                    if (Iterator == TotalChars-1)
                    {
                        // We are on the last letter so to catch it we must 
increase CharsInWord.
                        CharsInWord += 1;
                        break;
                    }
                    // Look at the next character
                    Iterator += 1;
                    CharsInWord += 1;
                }


                // In the case of a double space the character before will 
be ' ' so guard against this first of all
                // by saying "if the previous char is a space then loop 
again".
                if ( !((Iterator-1) == ' ') )
                {
                    // Space found, so mark the end of the word as the 
iterator's position minus one (we are sitting on a space
                    // at the moment). We still have the starting position 
stored from the previous loop (or 0 if this is the first time).
                    EndOfWord = Iterator - 1;

                    // Perform a quick check to ensure that the CharsInWord 
variable is correct.
                    if (CharsInWord == (EndOfWord - StartOfWord))
                    {
                        Console.WriteLine("\n\nNumbers do not match\nThe 
number of characters reported in the word does not match the actual 
amount.\n");
                    }

                    // Store the characters from the start of the word to 
the end of the word (using CharsInWord counter).
                    string Temp = Sentence.Substring(StartOfWord, 
CharsInWord);

                    // We must make a copy of Temp because we will use it in 
replacing Temp's letters.
                    string TempCopy = Temp;

                    /* Reverse and output to screen.
                       We do this by replacing the first and last elements, 
then the second and second
                       to last elements, then the third and third to last 
elements, etc.
                    */


                    // Make a copy of CharsInWord because we will be using 
this copy to count down to the middle.
                    int CharsInTemp = CharsInWord;

                    // This variable exists outside the for loop and is 
added to one character at a time.
                    // Chars cannot be converted to string types easily but 
this method works.
                    string ReversedString = "";

                    // Extract the letters from TempCopy one at a time into 
ReversedString.
                    for(int Loop=0; Loop<Temp.Length; Loop++)
                    {
                        // Make sure CharsInTemp becomes element 7 from the 
off.
                        if (CharsInTemp != 0)
                        {
                            CharsInTemp--;
                        }

                        /* Create many chars and concatenate them together 
in the reverse order */
                        char CurrentChar = Temp[CharsInTemp];
                        ReversedString += CurrentChar;
                        Console.WriteLine("{0}", ReversedString);

                    }
                }

                // Move the iterator forward one.
                Iterator += 1;

                // Force some space between word reversal in the window.
                Console.WriteLine("\n\n");
            }

_________________________________________________________________
Use MSN Messenger to send music and pics to your friends 
http://www.msn.co.uk/messenger