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:

Ben Bacarisse wrote:

<snip>

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

OK, but just so you see why I thought you had that confused, here is
what you said:

| I though that a const in a parameter only meant that the function itself
| isn't going to modify the parameter.

"modify the parameter" is confusing here. Strictly speaking, the
parameter is mys and not the thing mys points to. mys can be modified
by this function because it is not declared as being const. I get
that you get that, but it was not at all clear from the above!

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.

The reason is that the compiler can't know and thus needs a general
rule:

struct s { char name[100]; };

char *open_up(const struct s *sp)
{
return sp->name; /* example code: this is an error! */
}

void safe(void)
{
struct s data;
open_up(&data)[0] = 'a';
}

void unsafe(void)
{
const struct s data;
open_up(&data)[0] = 'a';
}

You are right that the function 'open_up' does not allow 'safe' to do
anything that it can't already do, but 'usafe' should be stopped. How
can the compiler tell the difference? All three can be compiled
separately, of course.

When an object is declared const, it does not just mean that you won't
change it. It also means that you won't hand out the means by which
it may be changed (not at least with out a diagnostic message).

--
Ben.

[Pietro Cerutti]

Ben Bacarisse wrote:

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

>Ben Bacarisse wrote:

<snip>

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

OK, but just so you see why I thought you had that confused, here is
what you said:

| I though that a const in a parameter only meant that the function itself
| isn't going to modify the parameter.

"modify the parameter" is confusing here. Strictly speaking, the
parameter is mys and not the thing mys points to. mys can be modified
by this function because it is not declared as being const. I get
that you get that, but it was not at all clear from the above!

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

The reason is that the compiler can't know and thus needs a general
rule:

struct s { char name[100]; };

char *open_up(const struct s *sp)
{
return sp->name; /* example code: this is an error! */
}

void safe(void)
{
struct s data;
open_up(&data)[0] = 'a';
}

void unsafe(void)
{
const struct s data;
open_up(&data)[0] = 'a';
}

You are right that the function 'open_up' does not allow 'safe' to do
anything that it can't already do, but 'usafe' should be stopped. How
can the compiler tell the difference? All three can be compiled
separately, of course.

When an object is declared const, it does not just mean that you won't
change it. It also means that you won't hand out the means by which
it may be changed (not at least with out a diagnostic message).

Yep. Got it. Thanks again!
--
Pietro Cerutti

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

[karthikbalaguru]

On Aug 28, 3:42 pm, Pietro Cerutti <[e-mail] ote:

i Group,

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

'Const' is a very poor term used in C language that misleads many
people initially.
Const means 'Read-Only'. It is a qualifier which states that it cannot
be changed using
that particular variable. But, it can be manipulated by accessing the
address of it using pointers.

Karthik Balaguru

[Ben Pfaff]

karthikbalaguru <ka************ ***@gmail.comwr ites:

'Const' is a very poor term used in C language that misleads many
people initially.
Const means 'Read-Only'. It is a qualifier which states that it cannot
be changed using
that particular variable. But, it can be manipulated by accessing the
address of it using pointers.

Actually, the term is 'const'. In C, the case of letters is
important, so you should take care to be precise.

There is a little more confusion surrounding the C use of 'const'
than your article lets on. In particular, its meaning is quite
different when it is applied to an object definition versus the
target of a pointer. An object whose definition is qualified
with 'const' may not be modified; attempting to modify it yields
undefined behavior. On the other hand, you can always cast
away 'const' from a 'const'-qualified pointer type, and then
attempt to modify the object pointed to. Whether that is valid
depends entirely on how the target object was defined: if it is
modifiable (not 'const'-qualified, not a string literal, etc.),
then it is OK.
--
Just another C hacker.

[Barry Schwarz]

On Tue, 28 Aug 2007 12:42:42 +0200, Pietro Cerutti <ga**@gahr.ch >
wrote:

>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(s truct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(c onst 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

Based on the subsequent discussion, if you want get_mys_name to accept
a pointer to a non-const struct but still want the function to treat
it as const (so you get diagnostics if you try to modify it), one
approach would be

get_mys_name(st ruct my_s *pmys) /*const removed, p added*/
{
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}
Remove del for email

[Pietro Cerutti]

Barry Schwarz wrote:

On Tue, 28 Aug 2007 12:42:42 +0200, Pietro Cerutti <ga**@gahr.ch >
wrote:

>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(s truct my_s *mys, const char *name)
{
if(!mys) return;
strncpy(mys->mys_name, name, MAX_NAME_SIZE);
}

char *
get_mys_name(c onst 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

Based on the subsequent discussion, if you want get_mys_name to accept
a pointer to a non-const struct but still want the function to treat
it as const (so you get diagnostics if you try to modify it), one
approach would be

get_mys_name(st ruct my_s *pmys) /*const removed, p added*/
{
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}

Thank you, unfortunately it doesn't help to reach my goal, which would
just be to inform the user that the function doesn't modify the
parameter. I though it could be done using simply the function signature.

--
Pietro Cerutti

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

[CBFalconer]

Pietro Cerutti wrote:

Barry Schwarz wrote:

.... snip ...

>>
get_mys_name(s truct my_s *pmys) /*const removed, p added*/ {
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}

Thank you, unfortunately it doesn't help to reach my goal, which
would just be to inform the user that the function doesn't modify
the parameter. I though it could be done using simply the function
signature.

Why the fuss? Simply define the function as:

char *get_mys_name(s truct my_s *mys) /* const removed */ {
if (mys) return mys->mys_name;
return NULL;
}

No fuss, no muss, no complaints. Ball, keep eye on.

If the function handles objects that are initially const, use:

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

and now errors will show up at the correct points.

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

[Barry Schwarz]

On Thu, 30 Aug 2007 15:17:10 +0200, Pietro Cerutti <ga**@gahr.ch >
wrote:

>Barry Schwarz wrote:

>On Tue, 28 Aug 2007 12:42:42 +0200, Pietro Cerutti <ga**@gahr.ch >
wrote:

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

Based on the subsequent discussion, if you want get_mys_name to accept
a pointer to a non-const struct but still want the function to treat
it as const (so you get diagnostics if you try to modify it), one
approach would be

get_mys_name(s truct my_s *pmys) /*const removed, p added*/
{
const struct my_s *mys = pmys;
if(!mys) return (NULL);
return (pmys->mys_name); /*only use pmys in return*/
}

Thank you, unfortunately it doesn't help to reach my goal, which would
just be to inform the user that the function doesn't modify the
parameter. I though it could be done using simply the function signature.

In that case, go back to your original code and add a *single* cast to
your return statement.
Remove del for email