Thread: Why is my C program printing like this? Do I not understand how strings work?

  1. #1
    Registered User
    Join Date
    Sep 2017
    Posts
    1

    Why is my C program printing like this? Do I not understand how strings work?

    Here's a snippet of the code:

    Code:
    FILE *fp;
        fp = fopen(argv[2], "r"); // the input file
        while (!(feof(fp))) {
            char c;
            int i = 0;
            char string[101]; // max string length is 100. last spot reserved for '\0'
            string[100] = '\0';
            while ((c = fgetc(fp)) != ' ' && i < 100) {
                string[i] = c;
                i++;
            }
            printf("%s\n",string);
        }
        fclose(fp);
    This is just an example of a bigger problem that I'm having, but I feel like if I understand why this is happening.

    The contents of the "argv[2]" file are as follows:

    Code:
    this is an input file
    The output I am getting overall by this is:

    this
    isis
    anis
    input
    file
    �������������������������������������������������� �������������������������������������������� �

    ...as opposed to what I"m looking for:

    this
    is
    an
    input
    file

    I'm confused as to why the string doesn't seem to be a new string (i.e., why the second time around the string is "is" followed by the remaining two characters of the last string which also happen to be "is" making "isis" all together). Why doesn't the same thing happen to the last two? Why isn't "file" printed as "filet"? Very confusing.

    Overall I'm just trying to get my desired output. Any suggestions as to why I'm not? Why is the string being overridden as opposed to the program making a new string for each iteration?

  2. #2
    and the hat of int overfl Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    39,659
    Well you're not putting the \0 in the right place.

    After the loop exits, you need
    string[i] = '\0';
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.

  3. #3
    Banned
    Join Date
    Aug 2017
    Posts
    861
    No reason to go the full 100 if the file does not.

    Code:
    #include <stdio.h>
    
    int main (int argc, char **argv)
    {
    
    FILE *fp;
        fp = fopen(argv[1], "r"); // the input file
        while (!(feof(fp))) {
            char c;
            int i = 0;
            char string[101]; // max string length is 100. last spot reserved for '\0'
            string[100] = '\0';
            while ((c = fgetc(fp)) != EOF ) {    //' ' && i < 100) {
                string[i] = c;
                i++;
    
            }
            printf("%s %d\n",string, i);
        }
        fclose(fp);
    
    return 0;
    }
    results; added int count to printf
    Code:
    userx@~/bin <> ./a.out input_file
    this
    isis
    anis
    input
    file
     26
    oops, I copied your what it is not suppose to be for my test file.
    there, is that better?
    Code:
    userx@~/bin <> ./a.out input_file
    this
    is
    an
    input
    file
     22
    Last edited by userxbw; 09-21-2017 at 01:55 PM.

  4. #4
    Banned
    Join Date
    Aug 2017
    Posts
    861
    well I don't know everything, but I did notice you're using two loops,

    Code:
    #include <stdio.h>
    int main (int argc, char **argv)
    {
        char c;
        int i = 0;
        char string[100]; // max string length is 100. last spot reserved for '\0'
       //string[100] = '\0';
    FILE *fp;
    
    fp = fopen(argv[1], "r"); // the input file
    
        while (!(feof(fp))) {
    
            c = fgetc(fp) ;
            string[i] = c;
             i++;
            }
           string[i] = '\0';
         printf("%s %d\n",string, i);
       fclose(fp);
    
    return 0;
    }
    replace that other while loop with this
    Code:
        while ((c = fgetc(fp)) != EOF ) {
             string[i] = c;
             i++;
            }
          string[i] = '\0';
        fclose(fp);
     printf("%s %d\n",string, i);
    takes out that left over crap char thingy at the end of the print out if you do it that first way.
    try both ways to see what I am taking about.


    your inner loop was / is over riding your outer loop btw. fyi.
    Last edited by userxbw; 09-21-2017 at 02:32 PM. Reason: added more

  5. #5
    Registered User
    Join Date
    Sep 2014
    Posts
    364
    Quote Originally Posted by userxbw View Post
    Code:
    …
        char c;
    …
        while ((c = fgetc(fp)) != EOF ) {
    …
    Your comparition will allways be true, because 'c' can't represent EOF.
    Look at fgetc - C++ Reference
    The function 'fgetc' returns a 'int'.
    This means you should declare 'c' as 'int'.
    Other have classes, we are class

  6. #6
    and the hat of int overfl Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    39,659
    > No reason to go the full 100 if the file does not.
    Can you say "buffer overrun" ?

    Today's well-formed file might not be a problem, but tomorrows malicious hacker would have a field day.
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.

  7. #7
    Banned
    Join Date
    Aug 2017
    Posts
    861
    Quote Originally Posted by Salem View Post
    > No reason to go the full 100 if the file does not.
    Can you say "buffer overrun" ?

    Today's well-formed file might not be a problem, but tomorrows malicious hacker would have a field day.
    buffer over run would require over 100 not under 100. checking for EOF and knowing what or aprox what size the files are one is working with helps too. create a buffer larger than needed then just use EOF end of file or size of buffer in tandem with EOF, not separate of eof.

    he was using two loops where the first checked for eof and the inner went to buffer limit, over riding the EOF check, the file was under the buffer limit so that is why he was getting that crap printed out of it too, because it was going beyond eof, not the buffer. capeesh?
    Last edited by userxbw; 09-22-2017 at 07:26 AM.

  8. #8
    Banned
    Join Date
    Aug 2017
    Posts
    861
    Quote Originally Posted by WoodSTokk View Post
    Your comparition will allways be true, because 'c' can't represent EOF.
    Look at fgetc - C++ Reference
    The function 'fgetc' returns a 'int'.
    This means you should declare 'c' as 'int'.
    Ok, if true, then the concept is still true, even though the method may not be.

    one still needs to check for EOF to prevent over run of file, and buffer size to prevent blowing it up. how that is to be done depends on the lang used to make it happen.

    edit: now looking at that reference you gave me after I posted, I see that it is doing the same thing where you said it can't
    Code:
    Example
    
     
    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 /* fgetc example: money counter */ #include <stdio.h> int main () { FILE * pFile; int c; int n = 0; pFile=fopen ("myfile.txt","r"); if (pFile==NULL) perror ("Error opening file"); else { do { c = fgetc (pFile); if (c == '$') n++; } while (c != EOF); fclose (pFile); printf ("The file contains %d dollar sign characters ($).\n",n); } return 0; }
    it is just written differently but doing the same thing. this just shortens that code to one line
    Code:
    while ((c = fgetc(fp)) != EOF )
    returns an int? are you taking about the 'c' returning an int or the function fgetc?
    what value is that int? that is what you use for a return value to check for error or not -

    0 (zero) represents what?
    anything other than 0 (zero) represent what?

    read it again, return values in int are used for what and what?
    Code:
     Return Value
    
     On success, the character read is returned (promoted to an int value).
    The return type is int to accommodate for the special value EOF, which indicates failure:
    now lets look at your logic, because your whole logic board is off. You have some bad data or missing data corrupting your thought process.
    The function 'fgetc' returns a 'int'.
    This means you should declare 'c' as 'int'.
    you are reading in Char, not int. so that would fail. (even though char is actually int ) it still uses a char data type to let the compiler know you're reading letters and not numbers. so lets look closer shall we?

    you said, it will always be true because 'c' cannot return a false, or true.
    if that were true then why does it stop running? that should tell you that you're thinking in error. it has to be using something other than the var 'c' to tell the while loop when it reaches the EOF. That is where the function comes in, not the var. as shown to you already.
    Last edited by userxbw; 09-22-2017 at 08:09 AM.

  9. #9
    Banned
    Join Date
    Aug 2017
    Posts
    861
    To OP:
    If the position indicator was at the end-of-file, the function returns EOF and sets the eof indicator (feof) of stream.
    If some other reading error happens, the function also returns EOF, but sets its error indicator (ferror) instead.
    this is why one checks for EOF then uses 'feof' and 'ferror' for checks to see what really happened if it closes the file or stops ahead of time.

  10. #10
    Registered User
    Join Date
    Sep 2014
    Posts
    364
    Quote Originally Posted by userxbw View Post
    are you taking about the 'c' returning an int or the function fgetc?

    'c' is a variable and return nothing. It can only represent a value according to the type.
    The function 'fgetc' return a value of type int. This means, the variable you assign the returned value should be possible to accommodate this value.
    'fgetc' return a int, so the variable you assign the returned value should also be of type int (or greater).


    Quote Originally Posted by userxbw View Post
    what value is that int? that is what you use for a return value to check for error or not

    It doesn't matter. The type char is one byte. On computers today it will be 8 bit and can represent the values from 0 to 255. Every character that you read from a file can have a value in this range. How can the function 'fgetc' tell you that you have reached the end of file (EOF)?
    This is why the function returns a int. A integer can represent all values of type char (0-255) and many more values. One value outside of char-range is EOF. It can be -1 or 256 or anything else outside of 0-255 but inside the range of int. It doesn't matter what value it is exactly. The value is defined as macro with the name 'EOF'.
    So you can check the returned value of 'fgetc' against 'EOF' to see if you reading over the file end or not.


    Quote Originally Posted by userxbw View Post
    you are reading in Char, not int. so that would fail.

    No. The function 'fgetc' read a char, promoted it to a int and return this int.
    Nothing will fail.
    Return Value
    On success, the character read is returned (promoted to an int value).
    The return type is int to accommodate for the special value EOF, which indicates failure:
    If the position indicator was at the end-of-file, the function returns EOF and sets the eof indicator (feof) of stream.
    If some other reading error happens, the function also returns EOF, but sets its error indicator (ferror) instead.

    Quote Originally Posted by userxbw View Post
    (even though char is actually int ) it still uses a char data type to let the compiler know you're reading letters and not numbers.

    Wrong! The compiler see that you use the function 'fgetc' and this function returns a int.
    It doesn't matter what the function is doing inside and how it is does.
    If you assign the returned value to a variable of type char, it can be that you lose information, but this is your problem, not the problem of the compiler.


    Quote Originally Posted by userxbw View Post
    you said, it will always be true because 'c' cannot return a false, or true.

    No. As I mentioned before, 'c' is a variable and can hold a value.
    This value can be interpreted as true (not zero) or false (zero).
    But thats not the point. I pertain to the lines:
    Code:
    …
        char c;
    …
        while ((c = fgetc(fp)) != EOF ) {
    …
    In this lines, 'c' is declared as a char. If the function 'fgetc' attempt to read a char from the file, but there is no more characters to read, the function returns a value that is outside the range that a char can interpret. But 'c' is a char and therefore all bits that are over the representation of a char will be cuted off (information lost). The result in 'c' is a possible character, but this character was never readed.


    Quote Originally Posted by userxbw View Post
    if that were true then why does it stop running? that should tell you that you're thinking in error. it has to be using something other than the var 'c' to tell the while loop when it reaches the EOF. That is where the function comes in, not the var. as shown to you already.

    I don't know if you talking about this line
    Code:
    while (!(feof(fp)))
    or this line
    Code:
    while ((c = fgetc(fp)) != EOF )
    Thats two completely different things.
    In first case, the function 'feof' checks the end-of-file indicator of that stream and has nothing to do with the last readed character.
    In second case, the returned value of the function 'fgetc' will be assigned to the variable 'c' and thereafter the value of 'c' will be checked against the macro 'EOF'.
    It can be, that the truncated value stored in 'c' represent also 'EOF', but it can also be that 'EOF' was not meant.
    Other have classes, we are class

  11. #11
    Registered User
    Join Date
    Sep 2014
    Posts
    364
    Quote Originally Posted by userxbw View Post
    are you taking about the 'c' returning an int or the function fgetc?

    'c' is a variable and return nothing. It can only represent a value according to the type.
    The function 'fgetc' return a value of type int. This means, the variable you assign the returned value should be possible to accommodate this value.
    'fgetc' return a int, so the variable you assign the returned value should also be of type int (or greater).


    Quote Originally Posted by userxbw View Post
    what value is that int? that is what you use for a return value to check for error or not

    It doesn't matter. The type char is one byte. On computers today it will be 8 bit and can represent the values from 0 to 255. Every character that you read from a file can have a value in this range. How can the function 'fgetc' tell you that you have reached the end of file (EOF)?
    This is why the function returns a int. A integer can represent all values of type char (0-255) and many more values. One value outside of char-range is EOF. It can be -1 or 256 or anything else outside of 0-255 but inside the range of int. It doesn't matter what value it is exactly. The value is defined as macro with the name 'EOF'.
    So you can check the returned value of 'fgetc' against 'EOF' to see if you reading over the file end or not.


    Quote Originally Posted by userxbw View Post
    you are reading in Char, not int. so that would fail.

    No. The function 'fgetc' read a char, promoted it to a int and return this int.
    Nothing will fail.
    Return Value
    On success, the character read is returned (promoted to an int value).
    The return type is int to accommodate for the special value EOF, which indicates failure:
    If the position indicator was at the end-of-file, the function returns EOF and sets the eof indicator (feof) of stream.
    If some other reading error happens, the function also returns EOF, but sets its error indicator (ferror) instead.

    Quote Originally Posted by userxbw View Post
    (even though char is actually int ) it still uses a char data type to let the compiler know you're reading letters and not numbers.

    Wrong! The compiler see that you use the function 'fgetc' and this function returns a int.
    It doesn't matter what the function is doing inside and how it is does.
    If you assign the returned value to a variable of type char, it can be that you lose information, but this is your problem, not the problem of the compiler.


    Quote Originally Posted by userxbw View Post
    you said, it will always be true because 'c' cannot return a false, or true.

    No. As I mentioned before, 'c' is a variable and can hold a value.
    This value can be interpreted as true (not zero) or false (zero).
    But thats not the point. I pertain to the lines:
    Code:
    …
        char c;
    …
        while ((c = fgetc(fp)) != EOF ) {
    …
    In this lines, 'c' is declared as a char. If the function 'fgetc' attempt to read a char from the file, but there is no more characters to read, the function returns a value that is outside the range that a char can interpret. But 'c' is a char and therefore all bits that are over the representation of a char will be cuted off (information lost). The result in 'c' is a possible character, but this character was never readed.


    Quote Originally Posted by userxbw View Post
    if that were true then why does it stop running? that should tell you that you're thinking in error. it has to be using something other than the var 'c' to tell the while loop when it reaches the EOF. That is where the function comes in, not the var. as shown to you already.

    I don't know if you talking about this line
    Code:
    while (!(feof(fp)))
    or this line
    Code:
    while ((c = fgetc(fp)) != EOF )
    Thats two completely different things.
    In first case, the function 'feof' checks the end-of-file indicator of that stream and has nothing to do with the last readed character.
    In second case, the returned value of the function 'fgetc' will be assigned to the variable 'c' and thereafter the value of 'c' will be checked against the macro 'EOF'.
    It can be, that the truncated value stored in 'c' represent also 'EOF', but it can also be that 'EOF' was not meant.
    Other have classes, we are class

  12. #12
    Banned
    Join Date
    Aug 2017
    Posts
    861
    Quote Originally Posted by WoodSTokk View Post
    I don't know if you talking about this line
    Code:
    while (!(feof(fp)))
    or this line
    Code:
    while ((c = fgetc(fp)) != EOF )
    Thats two completely different things.
    In first case, the function 'feof' checks the end-of-file indicator of that stream and has nothing to do with the last read character.
    In second case, the returned value of the function 'fgetc' will be assigned to the variable 'c' and thereafter the value of 'c' will be checked against the macro 'EOF'.
    It can be, that the truncated value stored in 'c' represent also 'EOF', but it can also be that 'EOF' was not meant.

    exactly, that is what I am saying, they two completely different things.,
    that is one cause of the problem, because you check for EOF first, and that returns the marker feof or ferror so you can check that next if you want to know the why it stopped.

    this is wrong:
    Code:
    #include <stdio.h>
    int main (int argc, char **argv)
    {
        char c;
        int i = 0;
        char string[100]; // max string length is 100. last spot reserved for '\0'
       //string[100] = '\0';
    FILE *fp;
     
    fp = fopen(argv[1], "r"); // the input file
     
        while (!(feof(fp))) {
     
            c = fgetc(fp) ;
            string[i] = c;
             i++;
            }
           string[i] = '\0';
         printf("%s %d\n",string, i);
       fclose(fp);
     
    return 0;
    }
    you are always going to get one 'bad' ch printed out because it runs one more after ending at 'eof'. because feof is the return value not the check.

    even their example of how to run it and check for EOF is not like yours, because when it reaches EOF it returns,

    feof or ferror then you check for that next,

    LIKE this:
    it is used to see why it stopped reading the file.
    Code:
    include <stdio.h>
    
    
    int main (int argc, char **argv)
    {
        char c;
        int i = 0;
        char string[100]; // max string length is 100. last spot reserved for '\0'
    
        FILE *fp;
        fp = fopen(argv[1], "r"); // the input file
    
      while ((c = fgetc(fp)) != EOF ) {
        string[i] = c;
        i++;
         }
        string[i] = '\0';
    
        if (feof(fp) )
          printf("\n feof returned  \n Normal eof of stream\n");
    
         else if (ferror(fp))
          printf(" \ntferror returned \n errored before eof \n");
    
           fclose(fp);
    
          printf("\n%s %d\n",string, i);
    
    return 0;
    }
    results
    Code:
    userx@~/bin <> ./a.out input_file
    
     feof returned  
     Normal eof of stream
    
    this
    is
    an
    input
    file
    
    this is an input file string.
     53
    using this way
    Code:
       while (!(feof(fp)))
    
    is telling it to keep trying to read it while it is not a normal EOF

    ----
    as far as the c having to be a int or char you are correct it works both ways, I checked it.
    Last edited by userxbw; 09-23-2017 at 08:28 AM.

  13. #13
    Registered User
    Join Date
    Sep 2014
    Posts
    364
    Quote Originally Posted by userxbw View Post
    you are always going to get one 'bad' ch printed out because it runs one more after ending at 'eof'. because feof is the return value not the check.

    The difference is:
    'fgetc' return 'EOF' if there was no character left to read.
    'feof' return a value that will be interpreted as 'true' if the eof-flag of the stream is set.
    But the eof-flag will first set, if there was no character to read at the last input operation.


    Example:
    You have a file with the content 'abc'.
    Code:
    // 'feof'-variant
    
    while (!(feof(fp))) {
        c = fgetc(fp);
        string[i] = c;
        i++;
    }
    1: !feof returns 'true' -> fgetc returns 'a' (eof-flag 'clear')
    2: !feof returns 'true' -> fgetc returns 'b' (eof-flag 'clear')
    3: !feof returns 'true' -> fgetc returns 'c' (eof-flag 'clear')
    4: !feof returns 'true' -> fgetc returns 'EOF' (eof-flag 'set')
    5: !feof returns 'false' -> stop
    while-loop end, because '!feof' returns 'false'.


    This means, if the eof-flag is not set, read a character and append it to the char-array string.
    If the loop has read the last character and added to string, the eof-flag will not be set (because 'fgetc' has successfully read a char).
    So the loops continue. Now, the 'fgetc' returns 'EOF' (now the eof-flag will be set) but you append the 'EOF' to string.
    Thats the matter of the 'bad' ch.
    Code:
    // 'fgetc'-variant
    
    while ((c = fgetc(fp)) != EOF) {
        string[i] = c;
        i++;
    }
    1: fgetc returns 'a' (eof-flag 'clear') -> execute loop-body
    2: fgetc returns 'b' (eof-flag 'clear') -> execute loop-body
    3: fgetc returns 'c' (eof-flag 'clear') -> execute loop-body
    4: fgetc returns 'EOF' (eof-flag 'set') -> stop
    while-loop end, because 'c' is set to 'EOF'.


    Here is also a ' FAQ > Why it's bad to use feof() to control a loop - Cprogramming.com


    'c' can be of type char or should it be of type int ?
    As I mentioned in a previous post, 'fgetc' returns a integer, so 'c' should be declared as int.


    Why?
    A char is allways 1 byte and today this means 8 bit.
    The values go from 0 [00000000] to 255 [11111111].
    A int is at minimum 16 bit. So it can represent all characters and many more values.
    One special value is EOF and is mostly defined to the value -1 [11111111 11111111].
    If you assign the returned value of 'fgetc' to a char, the high significant bits get losed.
    So the symbol 'EOF' [11111111 11111111] (-1) will become [11111111] (255). For char, this is a valid symbol.
    But for a int there is a difference between -1 [11111111 11111111] and 255 [00000000 11111111].
    Thats the reason, why 'c' (in our code) should be declared as int.


    Here is a example where 'c' is declared as char.
    Code:
    #include <stdio.h>
    
    int main(int argc, char *argv[]) {
    
        FILE *fp;
        char c;
        int i = 0;
        char string[101] = {'\0'};
    
        if (argc < 2) {
            fprintf(stderr, "no argument! exit.\n");
            return 1;
        }
    
        fp = fopen(argv[1], "r");
        while ((c = fgetc(fp)) != EOF) {
            string[i++] = c;
        }
        printf("'%s'\n", string);
        fclose(fp);
        return 0;
    }
    I have also a textfile (foo.txt) with 7 characters as content:
    Code:
    $ hexdump -C foo.txt 
    00000000  61 62 63 ff 64 65 66                              |abc.def|
    Now, look what will happen:
    Code:
    $ ./foo foo.txt 
    'abc'
    Now we change line 6 from 'char c;' to 'int c;':
    Code:
    $ ./foo foo.txt 
    'abc�def'
    As you can see, the character 0xff will be evaluate as 'EOF' and not as regular character.
    So please stop suggesting to assign the returned value of 'fgetc' to a variable of type char!
    Last edited by WoodSTokk; 09-23-2017 at 05:49 PM.
    Other have classes, we are class

  14. #14
    and the hat of int overfl Salem's Avatar
    Join Date
    Aug 2001
    Location
    The edge of the known universe
    Posts
    39,659
    Excellent summary by WoodSTokk.
    If you dance barefoot on the broken glass of undefined behaviour, you've got to expect the occasional cut.
    If at first you don't succeed, try writing your phone number on the exam paper.

  15. #15
    Banned
    Join Date
    Aug 2017
    Posts
    861
    Quote Originally Posted by WoodSTokk View Post
    As you can see, the character 0xff will be evaluate as 'EOF' and not as regular character.
    So please stop suggesting to assign the returned value of 'fgetc' to a variable of type char!
    so you tell me and others this first, fgetc - C++ Reference which give this example:
    Code:
    /* fgetc example: money counter */
    #include <stdio.h>
    int main ()
    {
      FILE * pFile;
      int c;
      int n = 0;
      pFile=fopen ("myfile.txt","r");
      if (pFile==NULL) perror ("Error opening file");
      else
      {
        do {
          c = fgetc (pFile);
          if (c == '$') n++;
        } while (c != EOF);
        fclose (pFile);
        printf ("The file contains %d dollar sign characters ($).\n",n);
      }
      return 0;
    }
    now you tell me that example is wrong by now stating I and others should not use that which equates to the same as this,
    Code:
    while ( c = fgetc(pfile) != EOF ) {
    if (c == '$')
    printf (" got it ($)\n");
    }
    which you used to show this is how to do it, now you're saying it is not. Why are you now contradicting yourself, for one?

    while you showed the difference between using a char or an int, so there is a difference therefore making what you are stating plausible, because now it all depends no how one is using it, therefore it seems both ways are correct as long as the two are not mixed together. ( off the top of my head evaluation, mind you).

    where many others too will contradict what you just stated to me,
    file - issue fgetc() c using while loop - Stack Overflow


    Code:
    char buffer[500];
    FILE *fp;while (!feof(fp))....
    reference:
    http://people.cs.uchicago.edu/~dmfra...ials/fgets.txt

    again these two examples show what I am now suggesting as a truth. it has to be, because both deferent ways are being used to read a file,
    and are considered by the others to be a right way of doing it.
    Code:
    You can check it with ferror(3), right after the while:
    
      while (EOF != (ch = fgetc(fp)))
       // do something
    
    if (ferror(fp) != 0)
    c - fgetc(): Is it enough to just check EOF? - Stack Overflow

    another example of someone not me, showing !feof(pf) NOT being
    used as a correct means of doing this as well. Then doing what I did
    after it is completed by checking why it ended,so it is not just me
    .
    Just so you know it looks like you're going to have to inform
    the entire programming community of your findings.

    Maybe you should see if you can book an opening on TED and at least get paid for
    it while your informing the entire programming community that them that are not doing it
    your way are wrong. then tell them to stop it and see what happens.
    Last edited by userxbw; 09-24-2017 at 02:26 PM.

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. Help printing strings
    By Frendin in forum C Programming
    Replies: 6
    Last Post: 12-09-2012, 07:39 PM
  2. simple printing calculator in C doesn't work
    By Pierre Hardy in forum C Programming
    Replies: 6
    Last Post: 02-10-2012, 02:03 PM
  3. I dont understand why this wouldn't work
    By We'reGeeks in forum C Programming
    Replies: 28
    Last Post: 03-02-2011, 03:26 AM
  4. don't understand why this code doesn't work properly
    By artistunknown in forum C Programming
    Replies: 10
    Last Post: 01-23-2010, 08:48 PM
  5. Don't understand why this doesn't work. . .
    By k2712 in forum C Programming
    Replies: 7
    Last Post: 10-07-2007, 04:08 PM

Tags for this Thread