Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

May i know the difference between these initializations?

  1. Nov 25, 2006 #1
    May i know the difference between

    (1) char a[] = "string literal"
    (2) char *p = "string literal"

    char a[] is a array which will include the word "string literal"
    whilw char *p is a pointer that points to a address that store the words "string literal"?

    Is that correct? Please advise.
     
  2. jcsd
  3. Nov 25, 2006 #2

    Hurkyl

    User Avatar
    Staff Emeritus
    Science Advisor
    Gold Member

    I believe an array type is effectively the same thing as a pointer constant. (not a constant pointer!)

    i.e. these two statements mean exactly the same thing

    char a[] = something;
    char *const a = something;


    Functionally, going back to your original example, it simply means that p = a is a valid assignment, because you're allowed to change where p points, but a = p is not, because you're not allowed to change where a points.
     
    Last edited: Nov 26, 2006
  4. Nov 27, 2006 #3

    DrGreg

    User Avatar
    Science Advisor
    Gold Member

    Actually there is a subtle difference between a and b.

    sizeof(a) is 10 but sizeof(b) is 4 (typically, in a compiler where chars are one byte ("something" is 9 chars plus a NUL) and pointers are 4 bytes).

    But in most other contexts, a and b behave identically.
     
  5. Nov 27, 2006 #4
    And sizeof does make a difference!

    For example, let's try to make a copy of each string dynamically.

    Code (Text):
        char a[] = "1 String Literal";
        char *a_p = malloc (sizeof (char) * sizeof (a));
        memcpy (a_p, a, sizeof (char) * sizeof (a));
        printf ("%s\n", a_p);
        free (a_p);
    Perfect! It works.

    Now let's make a copy of the other string.

    Code (Text):
        char *p = "2 String Literal";
        char *p_p = malloc (sizeof (char) * sizeof (p));
        memcpy (p_p, p, sizeof (char) * sizeof (p));
        printf ("%s\n", p_p);
        free (p_p);
    Uh oh! It only outputs the first four characters!

    Oh? But can't we just fix it by using the correct sizeof?

    Code (Text):
        char a[] = "1 String Literal";
        char *p = "2 String Literal";
        char *p_p = malloc (sizeof (char) * sizeof (a));
        memcpy (p_p, p, sizeof (char) * sizeof (a));
        printf ("%s\n", p_p);
        free (p_p);
    Hurray! It works.

    Now... in a real-world situation, you will not have an alternate initialization with the exact same number of characters to use a sizeof on. In that case, further methods can be used to acquire the correct size. Such as strlen under the string.h library, for example.
     
    Last edited: Nov 27, 2006
  6. Nov 30, 2006 #5

    DrGreg

    User Avatar
    Science Advisor
    Gold Member

    By the way, sizeof(char) is always 1.

    (And even if it wasn't, the correct formulation would still be char* a_p = malloc(sizeof(a));)
     
  7. Nov 30, 2006 #6
    Yes, you are right. However, I was trying to be as clear as possible.

    Half of programming is knowing how to write efficiently and elegantly, the other half is showing clear and concise intentions with your code. This was an example of choosing to go with the latter, readability.
     
Know someone interested in this topic? Share this thread via Reddit, Google+, Twitter, or Facebook

Have something to add?



Similar Discussions: May i know the difference between these initializations?
Loading...