Thread: While loop not looping

The display line isnt looping and I cant figure out why...

Code:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <io.h>
#include <fcntl.h>


int main()
{
    // String Storage
    char mystring[100];
    size_t mystring_reply;


    // Format into words
    int character_scanner = 0;
    int begin_word = 0;


    FILE *outfile;        //  DHH declare a pointer to a file control block.
    FILE *infile;


    int file_size = 0;
    char *buffer;


    // Create, open and write to a file**********************
    outfile = fopen("Hello_World.txt", "w+");


    if (!outfile)
    {
        printf("File failed to open");
    }


    fprintf(outfile, "%s", "Hello World. This would happen to be the\n"
                            "string being tested for whitespace!\n");
    fseek(outfile, 0, SEEK_SET);
    // ***************************************************************************
#if 0
    ( DHH long string, multiple adjacent strings are concatenated by the compiler
    into one long string.  This works as long as there are no % characters in it
    because it occupies the position of the format string in the fprintf function call)
    A safer implementation would be:


    fprintf(outfile, "%s", "Hello World. This would happen to be the string "
            "being tested for whitespace!\n");


                -or-


    fprintf(outfile, "%s\n", "Hello World. This would happen to be the string "
            "being tested for whitespace!\n");
#endif    
    /*
     *     DHH  This version of fgets makes it unnecessary to search for every use of mystring
     *    to make sure you don't declare it with multiple lengths.  I practice, the
     *    only constants I allow in my code are 1 and 0.  Anything else is declared
     *    as a #define or a variable.  It prevents a lot of unnecessary debuging later.
     */


    while (fgets(mystring, sizeof mystring, outfile))
    {


#if 0
        OK, we got a line of input for parsing.
       initialize the character scanner to start of line.
#endif


    character_scanner = 0;


    // loop processing the line.**********************
    while (mystring[character_scanner] != NULL)    //  DHH
        {
        begin_word = character_scanner;    


        if (!isspace(mystring[character_scanner]))
        {
        while (!isspace(mystring[++character_scanner]));
        
        mystring[character_scanner++] = '\0';
        }
        else
        {
        begin_word = ++character_scanner;
        }
        }
    }
    fclose(outfile);
    // ****************************************************


    // Loop the display line ******************************
    character_scanner = 0;
    do
    {
        printf("%c", mystring[character_scanner]);
        character_scanner++;
    } while (mystring[character_scanner] != NULL);


    // ****************************************************
}

since its a 'do' loop, it will always print at least one character. but if the character is not printable, you might not see anything. i'm guessing you get one or more unprintable characters then it hits '0' in mystring[character_scanner]

change your printf("%c" to printf("%02x" to get the hex output to see what the first character is or use a debugger

Although this is quite embarrassing, I thought id let you know I found the problem. The compilers auto-stop feature was placed before the end of the loop. took me two days to figure that out. there's one for the newbie book...

whats a compiler auto-stop feature?

Originally Posted by stahta01

That is NOT what I learned; and, I do not believe it is true that the standard says that.
Note: It is true for all the C Compilers I have used; but, I never ever read that the standard says it must be true.

Tim S.

There have been compilers for machines where NULL != 0, if I remember correctly most, if not all, of those where before C was standardized.

I have been in several discussions about this issue before, I have tried reading the standard and I am still not sure what is right and wrong regarding this. I have even spoken to a few self professed "language lawyers" regarding this and then didn't agree with each other, so I really hope that somebody in this thread can shed some light on this issue! :-)

I don't have a proper copy of the C standard to hand but from The C89 Draft.

An integral constant expression with the value 0, or such an expression cast to type void * , is called a null pointer constant. If a null pointer constant is assigned to or compared for equality to a pointer, the constant is converted to a pointer of that type. Such a pointer, called a null pointer, is guaranteed to compare unequal to a pointer to any object or function.

later on:

A.6.3 Implementation-defined behavior

Each implementation shall document its behavior in each of the areas listed in this section. The following are implementation-defined:
...
* The null pointer constant to which the macro NULL expands (4.1.5).

As I understand it NULL is just a preprocessor define to 0 -- so after preprocessing, these two assignments are exactly the same:

Code:

char *p1 = 0;  
char *p2 = NULL;  // preprocessed to char *p2 = 0;

I think the confusion comes from the fact that the machine representation of the null pointer isn't guaranteed to have value 0, though it does on all the architectures I know of.

Code:

char *p = 0;   // NULL pointer
int a = (int)p; // a might not be 0

The C faq names a couple of architectures with non-0 null pointer representations (Question 5.17) but NULL is still 0, as oogabooga concisely explained.