Programming

char str[]="abc def ghi jkl";

str[3]='\0';
cout << str << endl;

str[7]='\0';
cout << str+4 << endl;

str[11]='\0';
cout << str+8 << endl;

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

int main() {
         char str[]="abc def ghi";
         char *ptr=strtok(str, " ");

        // printf would crash if we fed it NULL.
        // so we tell assert, "we are assuming ptr != NULL"
        // and if your assumption is incorrect, it dies.
        assert(ptr != NULL);
        printf("%s\n", ptr);

        ptr=strtok(NULL, " ");
        assert(ptr != NULL);
        printf("%s\n", ptr);

        ptr=strtok(NULL, " ");
        assert(ptr != NULL);
        printf("%s\n", ptr);

        ptr=strtok(NULL, " ");
        assert(ptr != NULL);
        printf("%s\n", ptr);

        ptr=strtok(NULL, " ");
        assert(ptr != NULL);
        printf("%s\n", ptr);
}

$ gcc myassert.c
$ ./a.out
abc
def
ghi
a.out: assert.c:24: main: Assertion `ptr != ((void *)0)' failed.
Aborted

$

#include <stdio.h>

char *last; /* Store the last value my_strtok used */

/**
 * A simplified strtok that only uses one char as a token.
 * The real strtok takes a string, and stops at ANY char in it.
 *
 * 'first' points to the first character in the string.
 * If we give it NULL, it assumes 'last'.
 *
 * It points to wherever it left off in the global variable 'last'.
 */
char *my_tok(char *first, char c)
{
        int pos=0;

        /* If given a string, start over here */
        if(first != NULL)       last=first;

        first=last;     /* Pick up wherever we left off */

        /* Our very first char is NULL?  Give up. */
        if(first[0] == '\0') return(NULL);

        /* Increment 'pos' until we find c or NULL */
        while(first[pos] && (first[pos] != c)) pos++;

        /**
         * If we found a separator, replace it with a NULL terminator
         * The string beginning in 'first' will now stop early, here.
         *
         * A 'while' loop is used to catch several in a row.
         */
        while(first[pos]==c)
        {
                first[pos]='\0';
                pos++;
        }

        // Remember exactly where we left off.
        last += pos;

        // Return a pointer to where we started.
        return(first);
}

int main(void) {
        char buf[128]="abcd  efgh  jklm  nop";
        char *tok=my_tok(buf, ' ');

        while(tok != NULL)
        {
                fprintf(stderr, "tok=%s\n", tok);
                tok=my_tok(NULL, ' ');
        }
}

$ gcc mystr.c
$ ./a.out

tok=abcd
tok=efgh
tok=jklm
tok=nop

$

buf1[128]= "This is a test";
buf2[128]= " Second string with a leading space"
buf3[128]= "";
buf4[128] ="\n\t\nForth string with leading unprintable chars"

string1="Thisisatest"; 
string2="Secondstringwithaleadingspace"
string4="Forthstringwithleadingunprintablechars"

string ="ThisisatestSecondstringwithaleadingspaceForthstringwithleadingunprintablechars"

char *last;
char *my_tok(char *first, char c)
{
        int pos=0;

        last=first; /* 'last' now points to "abc def ghi", so becomes red */
        first=last; /* because of the statement above, 'last' is already equal to 'first' */

        /* Increment 'pos' until we find c or NULL */
        while(first[pos] && (first[pos] != c)) pos++;

        // pos will now be '3', because first[3] == ' '

        first[pos]='\0';
        pos++;

        // 'last' currently points to "abc\0def ghi"
        last += pos;
        // Now 4 ahead, pointing to "def ghi".
        // Since it's now different, I've made it green again.

        // Return a pointer to where we started, which still points to
        // "abc def ghi", but changed to "abc\0def ghi".
        // The variable 'last' knows where we left off, pointing to "def ghi".
        return(first);
}

int main() {
        char buf[]="abc def ghi";
        char *tok=my_tok(buf, ' ');
}

char *my_tok(char *first, char c)
{
        int pos=0;

        //last=first;        /* Since 'first' is NULL, this DOES NOT happen: */

        /* Right now, 'first' points to NULL. */
       first=last;
        /* 'first' now points to "def ghi" instead. */

        /* Increment 'pos' until we find c or NULL */
        while(first[pos] && (first[pos] != c)) pos++;

        // pos is now 3 again, since first[3] == ' '

        first[pos]='\0'; // replace that ' ' with '\0'
        pos++; // Increment once, to include that '\0' in the length
        // pos is now 4.  "abc\0" is exactly 4 chars.

        // currently, 'last' points to "def\0ghi"
        last += pos;
        // last now points to "ghi".

        // Return a pointer to where we started, "def\0ghi".
        // 'last' remembers where we left off, four further ahead at "ghi".
        return(first);
}

int main(void) {
        char buf[128]="abc def ghi";
        char *tok=my_tok(buf, ' ');

        while(tok != NULL)
        {
                fprintf(stderr, "tok=%s\n", tok);
                tok=my_tok(NULL, ' ');
        }
}

tok=my_tok(buf, ' ');

tok=strtok(buf, " ");

char *my_tok(char *first, char *t)
{
        int pos=0;

        /* If given a string, start over here */
        if(first != NULL)       last=first;

        first=last;     /* Pick up wherever we left off */

        /* Our very first char is NULL?  Give up. */
        if(first[0] == '\0') return(NULL);

        /* Increment 'pos' until we find c or NULL */
        while(first[pos])
        {
                int n;
                // Check for, and stop at, any token character.
                for(n=0; t[n]; n++) if(first[pos]==t[n]) break;

                //if we found a token, t[n] won't be NULL.
                if(t[n]) break; // Stop at token char
        }

        /**
         * If we found a separator, replace it with a NULL terminator
         * The string beginning in 'first' will now stop early, here.
         *
         * A 'while' loop is used to catch several in a row.
         */
        while(1)
        {
                int n;
                first[pos]='\0';
                pos++;
                for(n=0; t[n]; n++) if(first[pos] == t[n]) break;
                // Rerun while loop if we found another token char
                if(t[n]) continue; 
                break; // Leave the loop if we did not.
        }

        // Remember exactly where we left off.
        last += pos;

        // Return a pointer to where we started.
        return(first);
}