Velocity Reviews

Velocity Reviews (http://www.velocityreviews.com/forums/index.php)
-   C Programming (http://www.velocityreviews.com/forums/f42-c-programming.html)
-   -   return discards qualifiers from pointer target type (http://www.velocityreviews.com/forums/t533219-return-discards-qualifiers-from-pointer-target-type.html)

Pietro Cerutti 08-28-2007 10:42 AM

return discards qualifiers from pointer target type
 
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(struct my_s *, const char *);
char *get_mys_name(const struct my_s *);

int main(void) {
struct my_s *mysp;

mysp = malloc(sizeof *mysp);

set_mys_name(mysp, MY_NAME);

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

return (0);
}

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

char *
get_mys_name(const 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 08-28-2007 10:51 AM

Re: return discards qualifiers from pointer target type
 
Pietro Cerutti <gahr@gahr.ch> writes:

> 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(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.

--
Ben.

Pietro Cerutti 08-28-2007 11:36 AM

Re: return discards qualifiers from pointer target type
 
Ben Bacarisse wrote:
> Pietro Cerutti <gahr@gahr.ch> writes:
>
>> 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(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?

Thank you for your input!


--
Pietro Cerutti

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

Pietro Cerutti 08-28-2007 11:37 AM

Re: return discards qualifiers from pointer target type
 
Ben Bacarisse wrote:
> Pietro Cerutti <gahr@gahr.ch> writes:
>
>> 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(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?


--
Pietro Cerutti

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

CBFalconer 08-28-2007 12:09 PM

Re: return discards qualifiers from pointer target type
 
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


CBFalconer 08-28-2007 12:12 PM

Re: return discards qualifiers from pointer target type
 
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


Ben Bacarisse 08-28-2007 02:19 PM

Re: return discards qualifiers from pointer target type
 
Pietro Cerutti <gahr@gahr.ch> writes:

> Ben Bacarisse wrote:
>> Pietro Cerutti <gahr@gahr.ch> writes:
>>

<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 08-28-2007 02:33 PM

Re: return discards qualifiers from pointer target type
 
Ben Bacarisse wrote:
> Pietro Cerutti <gahr@gahr.ch> writes:
>
>> Ben Bacarisse wrote:
>>> Pietro Cerutti <gahr@gahr.ch> writes:
>>>

> <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 08-28-2007 02:35 PM

Re: return discards qualifiers from pointer target type
 
Pietro Cerutti <gahr@gahr.ch> writes:

> Ben Bacarisse wrote:
>> Pietro Cerutti <gahr@gahr.ch> writes:

<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 08-28-2007 02:49 PM

Re: return discards qualifiers from pointer target type
 
Ben Bacarisse wrote:
> Pietro Cerutti <gahr@gahr.ch> writes:
>
>> Ben Bacarisse wrote:
>>> Pietro Cerutti <gahr@gahr.ch> writes:

> <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


All times are GMT. The time now is 05:37 AM.

Powered by vBulletin®. Copyright ©2000 - 2014, vBulletin Solutions, Inc.
SEO by vBSEO ©2010, Crawlability, Inc.