Char pointers in C

Hi ,

Does this mean that, delimiter is also a literal string because it has " ";
But for token, we made it as char  pointer.
We are using it and we did not make it to point to any literal string..
Also, we did not malloc it .. Is that  okay ?
Sorry, I am pretty confused...

>> Does this mean that, delimiter is also a literal string

Yes, the delimiter as you defined it is also a string literal : " ; : " is a string literal, and :

      char *delimiter = " ; : ";

delimiter is pointing to it.

>> But for token, we made it as char  pointer.
>> We are using it and we did not make it to point to any literal string..

token is pointing to a character in the str string.

strtok() transforms the string str from :

                ------------------------------------------------------------------------------------
    str -->  | 'H' | 'e' | 'l' | 'l' | 'o' | ';' | ' ' | 'E' | 'v' | 'e' | 'r' | 'y' | 'o' | 'n' | 'e' | '\0' |
                ------------------------------------------------------------------------------------

to :

                ----------------------------------------------------------------------------------------
    str -->  | 'H' | 'e' | 'l' | 'l' | 'o' | '\0' | '\0' | 'E' | 'v' | 'e' | 'r' | 'y' | 'o' | 'n' | 'e' | '\0' |
                ----------------------------------------------------------------------------------------

ie. it replaced all characters from the delimiter string to '\0' (null terminators).

In the first iteration of the loop, token points to the first character of the first token ("Hello") :

                ----------------------------------------------------------------------------------------
    str -->  | 'H' | 'e' | 'l' | 'l' | 'o' | '\0' | '\0' | 'E' | 'v' | 'e' | 'r' | 'y' | 'o' | 'n' | 'e' | '\0' |
                ----------------------------------------------------------------------------------------
                   ^
                    |
                token

In the next iteration of the loop, token points to the first character of the second token ("Everyone") :

                ----------------------------------------------------------------------------------------
    str -->  | 'H' | 'e' | 'l' | 'l' | 'o' | '\0' | '\0' | 'E' | 'v' | 'e' | 'r' | 'y' | 'o' | 'n' | 'e' | '\0' |
                ----------------------------------------------------------------------------------------
                                                                  ^
                                                                   |
                                                               token


>> Also, we did not malloc it .. Is that  okay ?

It is ok, because we're pointing to memory that has already been allocated by this line :

    char str[16] = "Hello; Everyone";



>> Sorry, I am pretty confused...

Don't be sorry ... we've all had to learn this. It's not an easy thing, but once you understand it, it will make a lot of things a lot clearer.

Just remember that a pointer is something pointing to a block of memory. That block of memory has to be allocated in some way.
That can be done either :

1) statically - some examples :

        int a = 10;
        char str[11] = "teststring";
        float point[3] = { 1.0f, 2.0f, 3.0f };
        char c = 'z';

    etc. These are all examples of memory that is statically allocated. You don't need to clean up the memory explicitly - it will be cleaned up automatically at the end of the execution block (like a function).

    you can create pointers that are pointing to this statically allocated memory like this :

        int* pa = &a;
        char *pstr = &str[0];
        float *ppoint = &point[0];
        char *pc = &c;


2) dynamically - some examples :

        int *pa = (int*) calloc(1, sizeof(int));
        *pa = 10;

        char *str = (char*) calloc(11, sizeof(char));
        strcpy(str, "teststring");

        float *point = (float*) calloc(3, sizeof(float));
        ppoint[0] = 1.0f;
        ppoint[1] = 2.0f;
        ppoint[2] = 3.0f;

        char *pc = (char*) calloc(1, sizeof(char));
        *pc = 'z';

    note that this memory needs to be freed once you don't need it any more :

        free(pa);
        free(str);
        free(point);
        free(pc);

strtok(str,delimiter); wants to modify str, but
String literals, and compound literals with const-qualified types, need not designate
distinct objects. 83)

This allows implementations to share storage for string literals and constant compound literals with
the same or overlapping representations.

Thank you very much...
I noticed that when you use for array, you use calloc .

char *p;
p=(char *)calloc(10,sizeof(char));

Can i assume that you are doing this because you want a string....
If I was to do like this:
p=(char *)malloc(sizeof(char));
i would only get one character and not an array of characters ..

Thanks again for the explanation..