int main()
{
   const char delimiters[] = "[]";
   char *teststr = "[1]";    /***** notice this declaration *****/
   char *token;

   printf("%s\n", delimiters);
   printf("%s\n", teststr);

   token = strtok(teststr, delimiters);
   printf("%s\n", token);

   token = strtok(NULL, delimiters);
   printf("%s\n", token);

   return 1;

I thought char * is the same as char[]?  It's not that I needed
preallocated space by putting teststr[512] or something. I looked up the
text bk & sure enough char * is more flexible than char [], & strtok()
takes in a char * anyway.  any comments why only a char [] works here?

I also have another query : how do I reset a char * back to the 1st char
in the string when I've done ++ operations to the pointer?  there's no
way, and I'll need a 2nd ptr to point to the head, much like a linked
list, right?

thanx for the enlightenment,
Aaron

--
        Regards,
                Alex Krol
Disclaimer: I'm not speaking for Scitex
Corporation Ltd

Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.

- snip -
Yes,
char *teststr;
and
char teststr[];
are different animals.

Question:  What does the (very simple) expression
teststr
mean, say when used as an argument value in a function call?
That was the source of confusion - but not of the core dump.
The name of an array, when appearing alone, is interpreted
as the value of a pointer to its first element, just as if you had
written  &teststr[0].

Note that your first declaration also makes some sense.
But the problem here is that the char array it points to is a
constant (unmodifiable).  And it will be modified by strtok().
That caused the core dump.  Luckily, since this is OS dependent.

char *p = "hello";  /* p points to a location in unwritable memory */
char q[] = "world"; /* q is a static buffer, 6 chars long, and */
                    /* "world" is copied into it */

The problem is that strtok() modifies the buffer you are scanning,
replacing the delimiters with a '\0' character.  Passing a string
constant or a pointer to a string constant will cause it to choke.

t = strtok ("hello", "l"); /* bad */
t = strtok (p, "l"); /* bad */
t = strtok (q, "l"); /* ok */

There's one other thing you'll need to watch out for when using
strtok().  You can't nest calls -- that is, you can't read one token,
then parse it, then try to read from the original string again.  Here's
an example (error checking omitted for brevity):

void get_date_tokens(char *buf, char *delim, char *m, char *d, char *y)
{
    m = strtok (buf, delim);
    d = strtok (NULL, delim);
    y = strtok (NULL, delim);

    /*
    ** The following code won't work properly.  Calls to
    ** strtok() cannot be nested.
    ** After calling get_date_tokens, we will have lost our original
    ** place in the date buffer.
    */
    bufd = strtok (date, " ");
    get_date_tokens (bufd, "/", m, d, y);
    buft = strtok (NULL, " ");
    get_time_tokens (buft, ":", H, M);

    /*
    ** This is the proper way to handle the problem.  You fully parse
    ** the original string first, *then* work on each part of it.
    */
    bufd = strtok (date, " ");
    buft = strtok (NULL, " ");
    get_date_tokens (bufd, "/", m, d, y);
    get_time_tokens (buft, ":", H, M);

Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.

As you have noticed yourself (below) the "char *teststr" causes Undefined
Behaviour (in the form of a "core dump") in the call to "strtok()". That's
because "strtok()" is defined to modify the given source string. But a
string literal is read-only, which means that you are not allowed to
modify it. Changing the declaration like this:
    char teststr[] = "[1]";
places (copies) the string literal into a local variable.

I urge you to read the section 6 of the comp.lang.c FAQ, which explains
the differences between "Arrays and Pointers" in a very good and
understandable way, including several examples.

For using "strtok()" you must supply modifiable memory. Either by
declaring a real array or by dynamically allocating the memory using
"malloc()".

The reason why "strtok()" (and any other string processing function) takes
a "char*" is explained in the FAQ. Please read that first, it should make
things clear. If it does not, feel free to ask here again.

You can get the FAQ at http://www.eskimo.com/~scs/C-faq/top.html or
at ftp://rtfm.mit.edu/pub/usenet/comp.lang.c/C-FAQ-list and it gets
posted to this newsgroup and to news.answers regularly (at the
beginning of each month).

Stephan
(initiator of the campaign against grumpiness in c.l.c)

--

Paul Lutus
www.arachnoid.com

char *myPtr;
char myArray[] = "Hello!";

myPtr = myArray;        /* myPtr points to myArray[0], which is 'H' */
myPtr++;                /* myPtr points to myArray[1], which is 'e' */
myPtr--;                /* myPtr points back to myArray[0] */

--
_________________________________
Jordan Katz

I'll stick to arrays then.
Thanks for the clarifications!

Aaron

PS - yea, I'm having real weird probs with my news server? I posted the
1st msg but didn't see any update for a day or so & thought it got
lost.  It only appeared after I posted the 2nd, which also took a few
hrs to appear, even when other posts were coming thru.  And it appeared
both appeared at my face at the same time!  Is it my side or my news
server or the newsgrp host????

#include <stdio.h>
#include <stdlib.h>

void foo(char *s1, char *s2)
{
        while ((*s2++ = *s1++) != '\0')
                ;
         --s1;
        if (*--s1 == 't')
                printf("This is only a test.\n");

Anyway, I guess the above code is both dangerous and wrong? Thanks folks.

--
Bishop

--

Paul Lutus
www.arachnoid.com

<snip>

include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
        char    *p;

        p = malloc(6 * sizeof *p);
        if (p == NULL) {
                fprintf(stderr, "FATAL: out of memory.\n");
                exit(EXIT_FAILURE);
        strcpy(p, "hello");
        printf("%s\n", ++p);
        printf("%s\n", ++p);
        printf("%s\n", --p);
        printf("%s\n", --p);

        return EXIT_SUCCESS;

Also your code is uncompilable -- a missing brace. Always copy your code
directly from your program editor, never just type it in.

Also your program uses exit() in one path, which will not deallocate the
malloc'd memory.

--

Paul Lutus
www.arachnoid.com

--

Paul Lutus
www.arachnoid.com

#include <stdio.h>                                          /* mha */
#include <stdlib.h>
#include <string.h>

int main()
{
    char *p;

    p = malloc(6 * sizeof *p);
    if (p == NULL) {
        fprintf(stderr, "FATAL: out of memory.\n");
        exit(EXIT_FAILURE);
    }                           /* mha */
    printf("After %s, p is %p\n", "allocaton", (void *)p);  /* mha */
    strcpy(p, "hello");
    printf("After %s, p is %p\n", "strcpy", (void *)p);     /* mha */
    printf("%s\n", ++p);
    printf("After %s, p is %p\n", "first ++p", (void *)p);  /* mha */
    printf("%s\n", ++p);
    printf("After %s, p is %p\n", "second ++p", (void *)p);     /* mha
*/
    printf("%s\n", --p);
    printf("After %s, p is %p\n", "first --p", (void *)p);  /* mha */
    printf("%s\n", --p);
    printf("After %s, p is %p\n", "second --p", (void *)p);     /* mha
*/
    free(p);                    /* mha */

    return EXIT_SUCCESS;

__________________________________________________________
Fight spam now!
Get your free anti-spam service: http://www.brightmail.com

       [#1]  If  the  return  type  of  the main function is a type
       compatible with int, a return from the initial call  to  the
       main  function  is  equivalent  to calling the exit function
       with  the  value  returned  by  the  main  function  as  its
       argument;9) reaching the } that terminates the main function
       returns  a value of 0.  If the return type is not compatible
       with int,  the  termination  status  returned  to  the  host
       environment is unspecified.

That's from C9X, I'm afraid - no C89 here.

Anyway, the point is that if return from main() frees the memory, so does
exit().

I do agree, though, that it's good programming practice to wash your own
dishes.

--
Richard Heathfield

"Usenet is a strange place." - Dennis M Ritchie, 29 July 1999.