const char * and char * are compatible pointer types?

Discussion in 'C Programming' started by max, Jan 5, 2006.

  1. max

    max Guest

    Dear all,

    I did the following analysis to conclude that the following pointer
    types are not compatible. Please let me know If my analysis and
    interpretation of the C standard are correct:

    const char * : "pointer to const-qualified char".
    char *: "pointer to char".

    Are these pointed-to types compatibles?

    --------------------------
    C89
    --------------------------
    6.5.4.1
    Pointer declarators
    ....
    For two pointer types to be compatible, both shall be identically
    qualified
    and both shall be pointers to compatible types.
    ....
    --------------------------

    Well, using definition in 6.5.4.1 we can see that we comply with the
    first part
    ("both shall be identically qualified").
    Both are identically qualified (no qualifiers, both are unqualified
    types).

    Let us see now about the second part of definition in 6.5.4.1
    ("and both shall be pointers to compatible types").

    So do these pointers:

    1) const char *; /* pointer to const-qualified char */
    2) char *; /* pointer to char */

    point to compatible types?

    In the case of pointer 1) const char *;
    this pointer points to a 'const-qualified char'.
    In the case of pointer 2) char *;
    this pointer points to a 'char'.

    Is a 'const-qualified char' compatible with a
    'char'?

    --------------------------
    C89
    --------------------------
    6.1.2.5
    Types
    .....
    The qualified or unqualified versions of a type are distinct types that
    belong to the same type category and have the same representation and
    alignment requirements.
    ....
    --------------------------

    As we can see according to 6.1.2.5 and
    6.1.2.6 ("Two types have compatible type if their types are the same").
    A 'const-qualified char' is NOT compatible with a 'char'
    because their types are different.

    And as we can see:

    1) const char *; /* pointer to const-qualified char */
    2) char *; /* pointer to char */

    cannot satisfy second part of definition in
    6.5.4.1 ("and both shall be pointers to compatible types"). Because
    they do not point to compatible types.

    Therefore 1) and 2) are NOT compatible pointers.

    Thank you very much to everybody in advance,

    Max
     
    max, Jan 5, 2006
    #1
    1. Advertising

  2. max

    Malcolm Guest

    "max" <> wrote
    > const char * : "pointer to const-qualified char".
    > char *: "pointer to char".
    >
    > Are these pointed-to types compatibles?
    >

    The technical answer is no. A const char * cannot be converted to a plain
    char *, whilst a char * can be converted to a const char *.
    The reason is that const char * points to strings that may not be modified.
    You can treat a mutable string as immodifiable, but not a string in
    read-only memory as modifiable.

    Unfortunately const was a late addition to the language. As a result, a lot
    of C code uses plain char *s where const char * would have been more
    appropriate. To avoid breaking old code, the conversion between char * and
    const char *was made rather loose.

    (There are also problems with functions like strchr(). It returns a pointer
    to the first instance of a character in a string. So if you pass it a
    mutable string you want a char *, if you pass it a read-only string you want
    a const char * back. However there is no easy way of doing this in the
    language as it stands. Hence the function returns a char *.)
     
    Malcolm, Jan 5, 2006
    #2
    1. Advertising

  3. "Malcolm" <> writes:
    > "max" <> wrote
    >> const char * : "pointer to const-qualified char".
    >> char *: "pointer to char".
    >>
    >> Are these pointed-to types compatibles?
    >>

    > The technical answer is no. A const char * cannot be converted to a plain
    > char *, whilst a char * can be converted to a const char *.
    > The reason is that const char * points to strings that may not be modified.
    > You can treat a mutable string as immodifiable, but not a string in
    > read-only memory as modifiable.


    A char* or const char* doesn't necessarily point to a string. If it's
    valid and non-null, it points to a character; that character may or
    may not be the first element of an array (or, arguably, it's always
    the first element of an array, possibly of length 1), and the array
    may or may not be a string.

    I think you're thinking of the issue of string literals (for which the
    corresponding character array isn't const, but trying to modify it
    invokes undefined behavior) -- but the original question didn't
    mention string literals. Strings and string literals certainly
    motivate the rules, but they aren't necessary to describing them.

    --
    Keith Thompson (The_Other_Keith) <http://www.ghoti.net/~kst>
    San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
    We must do something. This is something. Therefore, we must do this.
     
    Keith Thompson, Jan 5, 2006
    #3
  4. max

    Jordan Abel Guest

    On 2006-01-05, Malcolm <> wrote:
    >
    > "max" <> wrote
    >> const char * : "pointer to const-qualified char".
    >> char *: "pointer to char".
    >>
    >> Are these pointed-to types compatibles?
    >>

    > The technical answer is no. A const char * cannot be converted to a plain
    > char *, whilst a char * can be converted to a const char *.


    However, a const char * can be _cast_ to a plain char *, and will not
    break unexpectedly. That is, if the const char * value was originally
    converted from a modifiable char * in the first place, of if the object
    pointed to by the resulting char * pointer is not in fact modified,
    there is no undefined behavior invoked.

    > The reason is that const char * points to strings that may not be modified.
    > You can treat a mutable string as immodifiable, but not a string in
    > read-only memory as modifiable.
    >
    > Unfortunately const was a late addition to the language. As a result, a lot
    > of C code uses plain char *s where const char * would have been more
    > appropriate. To avoid breaking old code, the conversion between char * and
    > const char *was made rather loose.


    Actually, the only concession made to such issues was that string
    literals, though immutable, are of type char *. This can be changed in
    some modern compilers, and there is some debate as to whether this
    actually causes such implementations to be non-conforming.
     
    Jordan Abel, Jan 5, 2006
    #4
  5. Jordan Abel wrote:
    > Actually, the only concession made to such issues was that string
    > literals, though immutable, are of type char *. This can be changed in
    > some modern compilers, and there is some debate as to whether this
    > actually causes such implementations to be non-conforming.


    There shouldn't be any question about it:
    char *s; // not const-qualified
    s = "Am I const?"; // must be allowed
    If the compiler supports the operation, but also issues a
    diagnostic, then technically it might be conforming but in
    practice it will be a pain.
     
    Douglas A. Gwyn, Jan 6, 2006
    #5
  6. max

    Malcolm Guest

    "Jordan Abel" <> wrote
    > Actually, the only concession made to such issues was that string
    > literals, though immutable, are of type char *. This can be changed in
    > some modern compilers, and there is some debate as to whether this
    > actually causes such implementations to be non-conforming.
    >

    Also strchr(). Also the fact that a cast from a const char * to a char * is
    legal, which ideally it shouldn't be.
     
    Malcolm, Jan 6, 2006
    #6
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. lovecreatesbeauty
    Replies:
    1
    Views:
    1,061
    Ian Collins
    May 9, 2006
  2. coala
    Replies:
    3
    Views:
    375
    coala
    Sep 6, 2006
  3. Replies:
    11
    Views:
    1,405
    James Kanze
    Jun 7, 2007
  4. Javier
    Replies:
    2
    Views:
    567
    James Kanze
    Sep 4, 2007
  5. pantagruel
    Replies:
    0
    Views:
    246
    pantagruel
    Feb 17, 2006
Loading...

Share This Page