late night coding

As the title suggest i'm coding at late o'clock over here and My code just hangs. I'm sure its something simple but I'd like to get it before bed.
thanks.

Code:

---

/* my getWord.c
GetWord reads characters from stdin up until the first space. it stores it in its
argument a char * and appends a '\n' then returns the word */
#include <stdio.h>
#include <string.h>
#define STOP ' '
#define SIZE 100

char *GetWord(char *);
int main(void){
    char store[SIZE];
   
  char *word = GetWord(store);
    printf("The word is %s", word);
    getchar();
    return 0;
}

char *GetWord(char vault[]){
    int ch,ndx=0;
    while( (ch = getchar()) !=STOP || ch !=EOF){
        vault[ndx] = ch;
        ndx+=1;
    }
    vault[ndx] = '\0';
    while(getchar() !='\n');
    return vault;
}

---

You could always try this:

Code:

---

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <ctype.h>

int getword(char *word, int lim) {
        int c;
        char *w = word;

        while (isspace(c = getch()))
                ;
        if (c != EOF)
                *w++ = c;
        if (!isalpha(c)) {
                *w = '\0';
                return c;
        }
        for ( ; --lim > 0; w++)
                if (!isalnum(*w = getch())) {
                        ungetch(*w);
                        break;
                }
        *w = '\0';

        return word[0];
}

int main() {
        char word[128];

        printf("Enter your password: ");
        if (getword(word, 128) != EOF)
                printf(word);

        return 0;
}

---

Heh, kinda late for me tonight too. Just tossing some ideas around.


- Stack Overflow

fix

Code:

---

    while( (ch = getchar()) !=STOP && ch !=EOF){

---

Thanks for the replies guys.

Quote:

---

Originally Posted by jverkoey

fix

Code:

---

    while( (ch = getchar()) !=STOP && ch !=EOF){

---

---

I knew it was something simple :D it I was drinking i'd have an excuse. right now its just lack of sleep. Thanks again.

Something else you might want to add into your Getword() function is some limitation on the input, so that the user cannot go outside the bounds of your array. Perhaps pass the size of the 'vault' to the function, and make sure that the input stops at one less than size, in order to leave room for the '\0'

~/

Of course your right Kermit. I wasn't worried or thinking about buffer overflows and I should always be, espeacially when working with arrays you should have pass the size of the array as a parameter. Thanks.
Good think i'm not working on a kernal of anything ;)

I'm having some logic problems I think again. This code simply returns "". Its the same problem as the above. it fetches the first word from input. Sorry If i was supposed to start a new thread. wasnt' really sure.

Code:

---

char *GetWord(char *vault){
//get word using advance pointer notation
int ch;
while( (ch = getchar()) !=STOP && ch !=EOF){
    *(vault++) = ch;
}
*vault ='\0';//whatever indice vault is at
while ( (getchar()) !='\n');
return  vault; 
}

---

It returns nothing, because you're incrementing vault throughout the function, and at last check, you assign it a null:

Code:

---

*vault ='\0';//whatever indice vault is at

---

Then you return that location.

You'll need to add a pointer, and increment that instead of incrementing vault, and then return vault.

Quzah.

thanks for the reply. couple questions.
When i return vault am i not returning it to vault[0] really. since vault is a pointer to character? then when I call it in main it should start printing from vault[0].

also what is the diference between this code. I just found out my book has an answer to this problem. It works fine, but it looks identical to mine.

Code:

---

char * getword(char * str)
{
    //int i;
    int ch;

    while ((ch = getchar()) != EOF && !isspace(ch))
        *str++ = ch;
    *str = '\0';
    if (ch == EOF)
        return NULL;
    else
    {
        while (ch != '\n')
            ch = getchar();
        return str;
    }
}

---

and mine

Code:

---

char *GetWord(char *vault){
//get word using advance pointer notation
int ch;

while( (ch = getchar()) !=STOP && ch !=EOF){
    *(vault++) = ch;
}
*vault ='\0';//whatever indice vault is at
while ( (getchar()) !='\n');
return  vault; 
}

---

The only thing i can see is I don't provide a conditional for EOF.

Quote:

---

You'll need to add a pointer, and increment that instead of incrementing vault, and then return vault.

---

can you give me an example of what you mean please.

Code:

---

char *GetWord(char *vault){
    //get word using advance pointer notation
    int ch;
    while( (ch = getchar()) !=STOP && ch !=EOF){
        *(vault++) = ch;
    }
    *vault ='\0';//whatever indice vault is at
    while ( (getchar()) !='\n');
    return  vault; 
}

---

Should be:

Code:

---

char *GetWord(char *vault){
    //get word using advance pointer notation
    int ch;
    char *ptr = vault;
    while( (ch = getchar()) !=STOP && ch !=EOF){
        *(ptr++) = ch;
    }
    *ptr ='\0';//whatever indice vault is at
    while ( (getchar()) !='\n');
    return  vault; 
}

---

That way you retain your origional pointer, so you can return it. This returns the start of the string, so you can actually use it. Or perhaps:

Code:

---

char *GetWord(char *vault){
    //get word using advance pointer notation
    int ch, count = 0;
    char *ptr = vault;
    while( (ch = getchar()) !=STOP && ch !=EOF){
        vault[count++] = ch;
    }
    vault[count] ='\0';//whatever indice vault is at
    while ( (getchar()) !='\n');
    return  vault; 
}

---

Or you could do the same, but use a bit of pointer math:

Code:

---

char *GetWord(char *vault){
    //get word using advance pointer notation
    int ch, count=0;
    while( (ch = getchar()) !=STOP && ch !=EOF){
        *(vault + count++) = ch;
    }
    *(vault + count ) ='\0';//whatever indice vault is at
while ( (getchar()) !='\n');
return  vault; 
}

---

I think all of those should work, I'm on the phone, so this is what you get. ;)

Quzah.

>When i return vault am i not returning it to vault[0] really.
No. You're using vault to walk along the memory where you are storing the characters. When you return vault, it points to the end of the string. If you want to keep the beginning you must save it before starting your run:

Code:

---

#include <ctype.h>
#include <stdio.h>

char *getword ( char *buffer, FILE *in )
{
  char *p = buffer;
  int ch;

  /* Stop at whitespace or end-of-file */
  while ( ( ch = fgetc ( in ) ) != EOF && !isspace ( ch ) )
    *p++ = (char)ch;

  /* Finalize the string */
  *p = '\0';

  /* Return end-of-file only if the buffer is empty */
  if ( buffer[0] == '\0' )
    return NULL;
  else
    return buffer;
}

int main ( void )
{
  char buffer[BUFSIZ];

  printf ( "%s\n", getword ( buffer, stdin ) );

  return 0;
}

---

Alright Quzah. your first two fragmenets are equivalent to what i've already done while playing around with this function.

Code:

---

GetWord using array notation.

char *GetWord(char vault[]){
    int ch,ndx=0;
    while( (ch = getchar()) !=STOP && ch !='\n' && ch !=EOF){
        //*(vault++) = ch;
        vault[ndx] = ch;
        ndx+=1;
    }
    //(*vault) = '\0';
    vault[ndx] = '\0';
    while((getchar()) !='\n');
    return vault;
}

---

and the other

Code:

---

char *GetWord(char vault[]){
//get word using pointer notation
int ch,ndx=0;
while( (ch = getchar ()) != STOP && ch !='\n' && ch !=EOF){
    *(vault + ndx) = ch;
    ndx+=1;
}
*(vault + ndx) = '\0';
while((getchar() ) !='\n');
return vault;
}

---

Thanks. I think the lesson to be learned here is what both you an prelude are pointing to that i need to use another pointer and increment that instead of the char *vault. It seems to be the equivalent of a index counter if i'd done it with array notation.

Quote:

---

You'll need to add a pointer, and increment that instead of incrementing vault, and then return vault.

---

I actually understood this and how to implement it when you said it. I just didn't and still don't understand why - though I can see how it works - I would have need to do it. but you guys are right.

Quote:

---

No. You're using vault to walk along the memory where you are storing the characters. When you return vault, it points to the end of the string. If you want to keep the beginning you must save it before starting your run:

---

Once again ma'am you've taught me something new just when I thought I understood it all. I'll think on it and see why I confused it and thought it would work. I'm probably just not thinking I'm so use to throwing together python code an having it work.
If i think on it i'm sure i'll realise why it couldn't work.

Thank you guys both.
:)

>I just didn't and still don't understand why
Why is very simple. You have a pointer that points to the beginning of a block of memory. If you assign a value to that location and then increment the pointer, you no longer point to the beginning of the block:

Code:

---

#include <stdio.h>

int main ( void )
{
  char buffer[2] = {'a','b'};
  char *p = buffer;

  printf ( "Before increment: %p -- %c\n", p, *p );
  ++p;
  printf ( "After increment:  %p -- %c\n", p, *p );

  return 0;
}

---

After your loop, the pointer has been incremented N times and the current memory that it points to contains the null terminator for the string. Therefore you're pointing to the end of the string. The only way to get back to the beginning is to either save the address of the beginning of the string:

Code:

---

#include <ctype.h>
#include <stdio.h>

char *getword ( char *buffer )
{
  char *p = buffer;
  int ch;

  while ( ( ch = getchar() ) != EOF && !isspace ( ch ) )
    *p++ = (char)ch;

  *p = '\0';

  return buffer;
}

int main ( void )
{
  char buffer[BUFSIZ];

  printf ( "%s\n", getword ( buffer ) );

  return 0;
}

---

Or to save the number of increments performed so that you can decrement that many times and find yourself back where you started:

Code:

---

#include <ctype.h>
#include <stdio.h>

char *getword ( char *buffer )
{
  int i = 0;
  int ch;

  while ( ( ch = getchar() ) != EOF && !isspace ( ch ) ) {
    *buffer++ = (char)ch;
    ++i;
  }

  *buffer = '\0';

  return buffer - i;
}

int main ( void )
{
  char buffer[BUFSIZ];

  printf ( "%s\n", getword ( buffer ) );

  return 0;
}

---

I'm sure you've also heard this before, but your function is very dangerous in that it doesn't check boundary conditions. You need to pass the size of the buffer as well and use that as another limit for the loop:

Code:

---

#include <ctype.h>
#include <stdio.h>

char *getword ( char *buffer, size_t size )
{
  char *p = buffer;
  int ch;

  while ( ( ch = getchar() ) != EOF && !isspace ( ch ) && --size > 0 )
    *p++ = (char)ch;

  *p = '\0';

  return buffer;
}

int main ( void )
{
  char buffer[BUFSIZ];

  printf ( "%s\n", getword ( buffer, sizeof buffer ) );

  return 0;
}

---

Quote:

---

Why is very simple. You have a pointer that points to the beginning of a block of memory. If you assign a value to that location and then increment the pointer, you no longer point to the beginning of the block:

---

Okay. So you point to the next location right?( Or are you saying i'm changing the actual value at that location?) if i'm incrementing the addy that first character is at that first location right? So thats where my logic was:

Code:

---

*(vault++) = ch;

---

that vault would increment to the next address and store the next character there.

This was my origianal code and obvioulsy it didn't work, however this code seems to be indentical and it works.

Code:

---

char * getword(char * str)
{
    //int i;
    int ch;

    while ((ch = getchar()) != EOF && !isspace(ch))
        *str++ = ch;
    *str = '\0';
    if (ch == EOF)
        return NULL;
    else
    {
        while (ch != '\n')
            ch = getchar();
        return str;
    }
}

---

why though?

also when you call a object by reference and do something to the pointer to object, that is analagous to doing something to the object as well correct? so

Code:

---

char *getword ( char *buffer, FILE *in )
{
  char *p = buffer;
  int ch;

  /* Stop at whitespace or end-of-file */
  while ( ( ch = fgetc ( in ) ) != EOF && !isspace ( ch ) )
    *p++ = (char)ch;

---

when it assignes buffer to *p and then when you increment *p++ isn't that incrementing buffer as well? This is my confusion: why assign buffer another ptr if itself is being incremented. it just seems like a rounabout way. Which the code above seems to agree as well(not yours).

Quote:

---

After your loop, the pointer has been incremented N times and the current memory that it points to contains the null terminator for the string.

---

but all the characters before were saved to the line of contiguous memory before right? and the '\0' just terminates it at that certain point in memory

Quote:

---

Therefore you're pointing to the end of the string.

---

okay.

Quote:

---

The only way to get back to the beginning is to either save the address of the beginning of the string..

---

or just

Code:

---

return string

---

as in your example

Code:

---

char *getword ( char *buffer )
{
  char *p = buffer;
  int ch;

  while ( ( ch = getchar() ) != EOF && !isspace ( ch ) )
    *p++ = (char)ch;

  *p = '\0';

  return buffer;
}

---

when you return a pointer unless you specify the direct address, it always goes to the biginning of that block of memory right? thus printing the first character of the string?

I'm really sorry if i'm not seeing this, it just doesn't make sense to what i've studied about ptrs, incrementing them and what the code from my book says. Feel free to give up in frustraion.

:(

You're familiar with how to declare a pointer:

Code:

---

char *p;

---

But it looks like initializing a pointer at the definition is confusing you. This is no doubt because declarations are designed to resemble use. The declaration above does not dereference anything, the asterisk is only saying that p is a pointer to char. When you initialize p in the same statement:

Code:

---

char buffer[10] = "testing";
char *p = buffer;

---

There is still no dereferencing going on. The asterisk is only used for the declaration of p, then buffer is assigned to p. The result is that p points to the first element of buffer, you could write it equivalently like this:

Code:

---

char buffer[10] = "testing";
char *p;
p = buffer; /* Or p = &buffer[0]; */

---

This is a subtle and confusing issue with C's declaration design. Just remember that when you initialize an object, you're initializing the object that was declared. p is declared as a pointer to char, so any initialization will be assigning to a pointer to char, not to a char.

Also note that p does not point to an array. It points to a char that simply happens to be part of an array. If you want to point to an array then a different declaration is required:

Code:

---

char buffer[10] = "testing";
char (*p)[10];
p = &buffer;

---

The parentheses guarantee that p is a pointer to whatever is outside of the parentheses, an array of 10 char.

As long as you point to memory that is contiguous and that is in your address space, you can increment and decrement pointers:

Code:

---

char buffer[10] = "testing";
char *p;
p = buffer;

p++; /* p now points to &buffer[1] */
p--; /* p now points back at &buffer[0] */

---

You'll often see somebody dereference and increment or decrement with the same expression:

Code:

---

printf ( "%c\n", *p++ ); /* Prints 't', p points to &buffer[1] */
printf ( "%c\n", *p-- ); /* Prints 'e', p points to &buffer[0] */

---

You can force the increment to be performed first by using prefix notation:

Code:

---

printf ( "%c\n", *++p ); /* Prints 'e', p points to &buffer[1] */
printf ( "%c\n", *--p ); /* Prints 't', p points to &buffer[0] */

---

There, that should be enough setup. :)

>So you point to the next location right?
Yes.

>Or are you saying i'm changing the actual value at that location?
No, the pointer and the value being pointed to are different.

>why though?
*p++ and *(p++) are equivalent. :) The parentheses don't do anything meaningful because the postfix increment still works the same way: It copies the current value, increments the pointer, then gives the copy to the rest of the expression to work with. Either way you'll be working with p and incrementing to p + 1. This isn't why your code didn't work.

>however this code seems to be indentical and it works
No, it does the same thing. It writes a word into str and returns a null character because a reference to the beginning of the string was not saved or calculated. Run the function like this and you'll see:

Code:

---

char buffer[BUFSIZ];
printf ( "%s\n", getword ( buffer ) );
printf ( "%s\n", buffer );

---

It will print nothing on the first line, then the first word you typed on the second.

>when you increment *p++ isn't that incrementing buffer as well?
No, they are two different pointers that just happen to point to the same address. When you increment p, buffer still points to the same location that it did before you incremented p. p and buffer are different objects even though the address they point to is the same.

>it always goes to the biginning of that block of memory right?
How do you define the beginning of a block? It's solely dependent on the logic of your program, so pointers cannot magically move to the beginning of a block unless you explicitly tell them to.

okay I'm slowly getting it.

Code:

---

char *GetWord(char *vault){
//get word using advance pointer notation
int ch;

while( (ch = getchar()) !=STOP && ch!='\n' && ch !=EOF)
    *vault++ = ch;
   
*vault ='\0';//whatever indice vault is at
while ( (getchar()) !='\n');
return  vault; 
}

---

ch was saved in vault and it does increment, but as you said when I returned vault it was pointing to noting cause that was what I assigned '\0' to last.
My mistake was assuming that

Code:

---

return vault

---

automatically points to the biggining of vault. Perhaps i was assuming it was done the same way as an array. Since arrays use ptr notation underneath.
when you return an array you return array[0]. And this would return array[0] and start printing from there.

this is where your saying i'm wrong correct. The word was caputred I was just pointing to the wrong address which was NULL.

Code:

---

/* Programming Exercise 11-3 */
#include <stdio.h>
#define LEN 80
char * getword(char * str);
int main(void)
{
  char input[LEN];
    char *chk;
   
    while (getword(input) != NULL)
        puts(input);
    puts("Done.\n");
    getchar();
    return 0;
}

#include <ctype.h>
char * getword(char * str)
{
    //int i;
    int ch;

    while ((ch = getchar()) != EOF && !isspace(ch))
        *str++ = ch;
    *str = '\0';
    if (ch == EOF)
        return NULL;
    else
    {
        while (ch != '\n')
            ch = getchar();
        return str;
    }
}

---

This is the full code in my book in his call to main notice he takes some exception handling into mind.

Code:

---

  while (getword(input) != NULL)
        puts(input);

---

so even though it returns "" he ignores that and prints from the biggining of the string. Thats why your code

Code:

---

char buffer[BUFSIZ];
printf ( "%s\n", getword ( buffer ) );
printf ( "%s\n", buffer );

---

printed out the "" and then the word. what the getword(buffer) returned and what was actally in bufffer. EUREKA!!!!
i'm getting it. and thinking out loud. So my other fragments worked

Code:

---

char *GetWord(char vault[]){
    int ch,ndx=0;
    while( (ch = getchar()) !=STOP && ch !='\n' && ch !=EOF){
        vault[ndx] = ch;
        ndx+=1;
    }
    vault[ndx] = '\0';
    while((getchar()) !='\n');
    return vault;
}

---

and

Code:

---


char *GetWord(char vault[]){
//get word using pointer notation
int ch,ndx=0;
while( (ch = getchar ()) != STOP && ch !='\n' && ch !=EOF){
    *(vault + ndx) = ch;
    ndx+=1;
}
*(vault + ndx) = '\0';
while((getchar() ) !='\n');
return vault;
}

---

because i had used it as a char array and on returning i returned array[0]. These fragments kept count of where i was in the array at any given time. is this correct. please say yes?? kinda like

Code:

---

#include <ctype.h>
#include <stdio.h>

char *getword ( char *buffer )
{
  int i = 0;
  int ch;

  while ( ( ch = getchar() ) != EOF && !isspace ( ch ) ) {
    *buffer++ = (char)ch;
    ++i;
  }

  *buffer = '\0';

  return buffer - i;
}

int main ( void )
{
  char buffer[BUFSIZ];

  printf ( "%s\n", getword ( buffer ) );

  return 0;
}

---

if this is correct. Was my mistake then thinking that vault was a character array and returning vault would automatically go to vault[0].

Quote:

---

when you increment *p++ isn't that incrementing buffer as well?
No, they are two different pointers that just happen to point to the same address. When you increment p, buffer still points to the same location that it did before you incremented p. p and buffer are different objects even though the address they point to is the same.

---

I was about to dispute this and then i did this

Code:

---

/* p_and_s.c -- pointers and strings */
#include <stdio.h>
int main(void)
{
  char * mesg = "Don't be a fool!";
  char * copy;

  copy = mesg;
  printf("%s\n", copy);
  printf("mesg = %s; &mesg = %p; value = %p\n",
      mesg, &mesg, mesg);
  printf("copy = %s; &copy = %p; value = %p\n",
      copy+1, &copy, copy);
  getchar();

  return 0;
}

---

output

Code:

---

Don't be a fool!
mesg = Don't be a fool!; &mesg = 0022FF6C; value = 00401280
copy = on't be a fool!; &copy = 0022FF68; value = 00401280

---

same address, different ouput. That what your getting at? I never knew the compiler or C could do that. I assumed....wrong.

Quote:

---

it always goes to the biginning of that block of memory right?
How do you define the beginning of a block? It's solely dependent on the logic of your program, so pointers cannot magically move to the beginning of a block unless you explicitly tell them to.

---

I was making a fatal mistake. ptrs !=arrays. I think that was it. Please tell me lesson learned. :o

I have to look up more into NULL and exactly what it does because my book doesnt' go into to much detail except to say that it is a address called the null pointer. Sort of like the string version of EOF. I assume he will go into more details in later chapters.

>Since arrays use ptr notation underneath.
This is the part where you start hating me. :) Arrays do not use pointer notation, pointers use array notation. Except for three very specific situations, an array name is converted to a pointer to the first element. So array subscripting is really a convenient sugar coating on top of pointer arithmetic.

>The word was caputred I was just pointing to the wrong address which was NULL.
The address you were pointing to contained the value '\0', yes. It's a good idea to be very specific when you use NULL because NULL is a macro designating a null pointer, which is different from the null character '\0'.

>So my other fragments worked
Yes, but not like you expected. You were treating vault as an array when it was really a pointer. Remember that

Code:

---

void f ( char *a );

---

and

Code:

---

void f ( char a[] );

---

Mean the exact same thing, both designate a as a pointer to char. Unlike a "real" array, you can reseat a and make it point somewhere else. I think that is where your confusion lies. When you changed vault, you didn't realize that you were reseating the pointer and that the reseated pointer would be treated as the beginning of the array instead of the beginning you expected (this is poorly worded, I'm sorry).

>Was my mistake then thinking that vault was a character array and returning vault would automatically go to vault[0].
Yes, precisely. :)

>That what your getting at?
Yep. A pointer is just another variable that holds a value.

>I was making a fatal mistake. ptrs !=arrays.
And another sees the light. :p Pointers and arrays are just similar enough to cause all but the most experienced C programmers fits.

>I have to look up more into NULL and exactly what it does
It's a pointer value that lets you say "no pointer here". The actual value of NULL is something along the lines of ( (void *)0 ), and you can use the integral constant 0 interchangeably with NULL. Just remember that there's nothing magical about a null pointer, it's just a way to give a pointer a value without actually pointing it to anything, thus designating an invalid pointer that can be tested. Note that this is different from an uninitialized pointer that has no predictable value.

>I assume he will go into more details in later chapters
What book?

Quote:

---

Arrays do not use pointer notation, pointers use array notation. Except for three very specific situations, an array name is converted to a pointer to the first element. So array subscripting is really a convenient sugar coating on top of pointer arithmetic.

---

That actually makes sense and I get that. Don't hate you yet. Maybe when i find out what those three specific situations are.;)

Quote:

---

Pointers and arrays are just similar enough to cause all but the most experienced C programmers fits.

---

Once again, i thought I had covered and understood all I needed to know about ptrs and then something shows up again. :rolleyes: Well practice, practice, practice. That's why the board is here.

Quote:

---

What book?

---

This book he does things a certain way but I suspect I will see different POV's when I read other books and tutorials.

>Maybe when i find out what those three specific situations are.
Sizeof, address of, and string literal array initialization. These are work with arrays as objects, not as values, so the conversion to a pointer is not made:

Code:

---

#include <stdio.h>

int main ( void )
{
  char a[] = "This is a test"; /* Object context */

  printf ( "%p\n", (void *)&a ); /* Object context */
  printf ( "%lu\n", (unsigned long)sizeof a ); /* Object context */

  return 0;
}

---