return discards qualifiers from pointer target type

[Pietro Cerutti]

i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

Please see the code below:

/*** START TEST.C ***/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_NAME_SIZE 80
#define MY_NAME "This is my name"

struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

void set_mys_name(st ruct my_s *, const char *);
char *get_mys_name(c onst struct my_s *);

int main(void) {
struct my_s *mysp;

mysp = malloc(sizeof *mysp);

set_mys_name(my sp, MY_NAME);

printf("My name is %s\n", get_mys_name(my sp));

return (0);
}

void
set_mys_name(st ruct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(co nst struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
/*** START TEST.C ***/

gcc -Wall -o test test.c

test.c: In function `get_mys_name':
test.c:39: warning: return discards qualifiers from pointer target type

./test

My name is This is my name
Thank you!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp

[Ben Bacarisse]

Pietro Cerutti <ga**@gahr.chwr ites:

i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

<snip>

struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

....

char *
get_mys_name(co nst struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

--
Ben.

[Pietro Cerutti]

Ben Bacarisse wrote:

Pietro Cerutti <ga**@gahr.chwr ites:

>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

<snip>

>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

...

>char *
get_mys_name(c onst struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

So, so to speak, when a struct is defined as const, each pointer trying
to reference to a member of that struct using the "->" operator has to
be const as well.
Am I correct?

Thank you for your input!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp

[Pietro Cerutti]

Ben Bacarisse wrote:

Pietro Cerutti <ga**@gahr.chwr ites:

>i Group,

to my understanding, defining a function parameter as "const" means that
the function is not going to change it.

Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

<snip>

>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

...

>char *
get_mys_name(c onst struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

Sorry for double posting:
I though that a const in a parameter only meant that the function itself
isn't going to modify the parameter. The object itself (the struct)
hasn't been defined as const, so a function calling get_mys_name() has
the right to modify the name using the pointer returned by the function.
What's wrong with it?
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp

[CBFalconer]

Pietro Cerutti wrote:

>

.... snip ...

>
I though that a const in a parameter only meant that the function
itself isn't going to modify the parameter. The object itself (the
struct) hasn't been defined as const, so a function calling
get_mys_name() has the right to modify the name using the pointer
returned by the function. What's wrong with it?

Because you aren't returning the component of the original. You
are returning a component of the functional parameter, which you
promised not to disturb.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[CBFalconer]

Pietro Cerutti wrote:

>

.... snip ...

>
Why does the compiler says "return discards qualifiers from pointer
target type" when I *access* a member of an argument defined as const?

Because the struct is const. You can't have a const struct without
having all the components automatically being const.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[Ben Bacarisse]

Pietro Cerutti <ga**@gahr.chwr ites:

Ben Bacarisse wrote:

>Pietro Cerutti <ga**@gahr.chwr ites:

<snip>

>>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};

...

>>char *
get_mys_name( const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

So, so to speak, when a struct is defined as const, each pointer trying
to reference to a member of that struct using the "->" operator has to
be const as well.
Am I correct?

Yes. Your language is a little vague but that is the gist of it.
Section 6.5.2.3 paragraphs 3 and 4 if you want chapter and verse.

When you access a struct member using either . or ->, the expression
takes on the type of the member, qualified in the same way as the
struct object (const is a type qualifier).

--
Ben.

[Pietro Cerutti]

Ben Bacarisse wrote:

Pietro Cerutti <ga**@gahr.chwr ites:

>Ben Bacarisse wrote:

>>Pietro Cerutti <ga**@gahr.chwr ites:

<snip>

>>>struct my_s
{
char mys_name[MAX_NAME_SIZE+1];
};
...
char *
get_mys_name (const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

So, so to speak, when a struct is defined as const, each pointer trying
to reference to a member of that struct using the "->" operator has to
be const as well.
Am I correct?

Yes. Your language is a little vague but that is the gist of it.
Section 6.5.2.3 paragraphs 3 and 4 if you want chapter and verse.

English's not my mother language..

>
When you access a struct member using either . or ->, the expression
takes on the type of the member, qualified in the same way as the
struct object (const is a type qualifier).

Clear, thank you!
--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp

[Ben Bacarisse]

Pietro Cerutti <ga**@gahr.chwr ites:

Ben Bacarisse wrote:

>Pietro Cerutti <ga**@gahr.chwr ites:

<snip>

>>char *
get_mys_name( const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}

The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

Sorry for double posting:
I though that a const in a parameter only meant that the function itself
isn't going to modify the parameter. The object itself (the struct)
hasn't been defined as const, so a function calling get_mys_name() has
the right to modify the name using the pointer returned by the function.
What's wrong with it?

You are little confused about what is const. Your function declares
mys as a pointer to a constant my_s structure. The parameter itself,
mys, is not at all constant. The function can do 'mys += 1;' if it
likes -- it can't do 'mys->mys_name[0] = 'a';' because the whole
structure pointer to by mys is constant.

A few examples:

struct s x; /* x is a struct s */
const struct s y; /* y is a constant struct s */
struct s const w; /* ditto, but some find this one odd to read! */
struct s *const p; /* p is constant pointer to a (non-const) struct */
const struct s *q; /* q is a pointer to a constant struct s */
const struct s *const r; /* both p and the struct it points to are const */

Does that help at all?

--
Ben.

[Pietro Cerutti]

Ben Bacarisse wrote:

Pietro Cerutti <ga**@gahr.chwr ites:

>Ben Bacarisse wrote:

>>Pietro Cerutti <ga**@gahr.chwr ites:

<snip>

>>>char *
get_mys_name (const struct my_s *mys)
{
if(!mys) return (NULL);
return (mys->mys_name);
}
The object pointed to by mys is const. This function returns a plain
(non-const) pointer to part of it (the mys_name array). The caller
could modify the contents of this array through this ponter. The
compiler is warning you that this function breaks the constness of the
object its parameter points to.

Sorry for double posting:
I though that a const in a parameter only meant that the function itself
isn't going to modify the parameter. The object itself (the struct)
hasn't been defined as const, so a function calling get_mys_name() has
the right to modify the name using the pointer returned by the function.
What's wrong with it?

You are little confused about what is const. Your function declares
mys as a pointer to a constant my_s structure. The parameter itself,
mys, is not at all constant. The function can do 'mys += 1;' if it
likes -- it can't do 'mys->mys_name[0] = 'a';' because the whole
structure pointer to by mys is constant.

A few examples:

struct s x; /* x is a struct s */
const struct s y; /* y is a constant struct s */
struct s const w; /* ditto, but some find this one odd to read! */
struct s *const p; /* p is constant pointer to a (non-const) struct */
const struct s *q; /* q is a pointer to a constant struct s */
const struct s *const r; /* both p and the struct it points to are const */

Does that help at all?

No, /*that*/ was clear. I do understand the the pointer is not const,
the structure is, and therefore you haven't got the right to modify its
members.

Now I understood that you can't return members of the structure without
declaring them const as well.

What I still don't understand is why: if the structure is const only
inside the function receiving it as a const parameter (thus not const at
the caller) the function should be able to return to the caller members
of the struct not declared as const, since the caller has the right to
modify them.

--
Pietro Cerutti

PGP Public Key:
http://gahr.ch/pgp