By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
455,906 Members | 1,389 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 455,906 IT Pros & Developers. It's quick & easy.

Casting int'** to 'const int * const * const' dosn't work, why?

P: n/a
Hello

I'm porting some C++ stuff to C and having problem to get it through
gcc.
Here is a condensed version of the problem:

void foo(const int * const * const ptr)
{}

main()
{
int i = 5;
int *ptr = &i;

foo(&ptr);
}

The warning is:
warning: passing arg 1 of `foo' from incompatible pointer type.

Can't C implicit cast a int** to 'const int * const * const'? (it
works fine in C++)

/Jonas

Jun 1 '07 #1
Share this Question
Share on Google+
14 Replies


P: n/a
Jo************@gmail.com writes:
Hello

I'm porting some C++ stuff to C and having problem to get it through
gcc.
Here is a condensed version of the problem:

void foo(const int * const * const ptr)
{}

main()
{
int i = 5;
int *ptr = &i;

foo(&ptr);
}

The warning is:
warning: passing arg 1 of `foo' from incompatible pointer type.

Can't C implicit cast a int** to 'const int * const * const'? (it
works fine in C++)
Let me pick a nit. C has no "implicit casts". A cast is an operator
and is always explicit in the code.

Short answer your question: no. C does not consider "int **" and
"const int * const * const" to be compatible types. You need a cast:

foo((const int **)&ptr);

The rules for parameter passing derive from the rules for assignment
(in case you want to look up the standard) and they allow qualifiers to
be added at only one level of indirection. So passing a "T *"
argument to a "const T *" pointer is fine, but passing "T **" where
"const T **" is expected is not.

--
Ben.
Jun 1 '07 #2

P: n/a
Jo************@gmail.com wrote:
Hello

I'm porting some C++ stuff to C and having problem to get it through
gcc.
Here is a condensed version of the problem:

void foo(const int * const * const ptr)
{}

main()
{
int i = 5;
int *ptr = &i;

foo(&ptr);
}

The warning is:
warning: passing arg 1 of `foo' from incompatible pointer type.

Can't C implicit cast a int** to 'const int * const * const'? (it
works fine in C++)
This is really a question for Chris Torek...

Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}
$ cc -ansi -pedantic -Wall -W const_cast.c
const_cast.c: In function âmainâ:
const_cast.c:7: warning: assignment from incompatible pointer type

which requires a diagnostic in C (but perhaps not in C++, since no
const'ness is lost).

In C, two types are compatible if they are the same type (not only if).
A type qualifier (like const), change the type. When it comes to pointer
types, they are compatible, if they point to compatible types.
--
Tor <torust [at] online [dot] no>
Jun 1 '07 #3

P: n/a
Tor Rustad wrote:
>
.... snip ...
>
This is really a question for Chris Torek.
Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}
No. const objects must be initialized at declaration time.

--
<http://www.cs.auckland.ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfocus.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
<http://kadaitcha.cx/vista/dogsbreakfast/index.html>
cbfalconer at maineline dot net
--
Posted via a free Usenet account from http://www.teranews.com

Jun 1 '07 #4

P: n/a
CBFalconer wrote:
Tor Rustad wrote:
... snip ...
>This is really a question for Chris Torek.
Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}

No. const objects must be initialized at declaration time.
Before posting, I even checked that 'pcpci' was a pointer (to const
pointer to const int).

What am I missing exactly?

--
Tor <torust [at] online [dot] no>
Jun 1 '07 #5

P: n/a
CBFalconer <cb********@yahoo.comwrites:
Tor Rustad wrote:
>>
... snip ...
>>
This is really a question for Chris Torek.
Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}

No. const objects must be initialized at declaration time.
I may be missing your point, but pcpci is not a const object.

--
Ben.
Jun 2 '07 #6

P: n/a
Jonas.Holms...@gmail.com wrote:
Hello

I'm porting some C++ stuff to C
and having problem to get it through gcc.
Here is a condensed version of the problem:

void foo(const int * const * const ptr)
{}
The last const is redundant. Don't cloud the issue.
main()
Prefer explicit int...

int main(void)
{
int i = 5;
int *ptr = &i;
Replace this with...

const *ptr = &i;

....and it should work.
>
foo(&ptr);
}

The warning is:
warning: passing arg 1 of `foo' from incompatible pointer type.

Can't C implicit cast a int** to 'const int * const * const'?
You mean can't C implicitly _convert_. The conversion is well
defined, however the absense of a cast requires a diagnostic
for a constraint violation.

I recall a thread (I may even have started it!) in csc some
time ago where contributing committee members said that once
a constraint was violated, the code invokes undefined behaviour,
even though the behaviour is otherwise defined, and even if
an implementation succeeds to translate the code.
(it works fine in C++)
At the end of the day, C is not C++.

--
Peter

Jun 2 '07 #7

P: n/a
Tor Rustad wrote:
>
CBFalconer wrote:
>Tor Rustad wrote:
... snip ...
>>This is really a question for Chris Torek.
Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}

No. const objects must be initialized at declaration time.

Before posting, I even checked that 'pcpci' was a pointer (to const
pointer to const int).

What am I missing exactly?
You can't write to const objects.

--
<http://www.cs.auckland.ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfocus.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
<http://kadaitcha.cx/vista/dogsbreakfast/index.html>
cbfalconer at maineline dot net

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

Jun 2 '07 #8

P: n/a
Tor Rustad <to********@hotmail.comwrites:
Jo************@gmail.com wrote:
>Hello

I'm porting some C++ stuff to C and having problem to get it through
gcc.
Here is a condensed version of the problem:

void foo(const int * const * const ptr)
{}

main()
{
int i = 5;
int *ptr = &i;

foo(&ptr);
}

The warning is:
warning: passing arg 1 of `foo' from incompatible pointer type.

Can't C implicit cast a int** to 'const int * const * const'? (it
works fine in C++)

This is really a question for Chris Torek...

Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}
$ cc -ansi -pedantic -Wall -W const_cast.c
const_cast.c: In function âmainâ:
const_cast.c:7: warning: assignment from incompatible pointer type

which requires a diagnostic in C (but perhaps not in C++, since no
const'ness is lost).

In C, two types are compatible if they are the same type (not only
if). A type qualifier (like const), change the type. When it comes to
pointer types, they are compatible, if they point to compatible
types.
If it were that simple, then assigning a char * to a const char *
would also be a constraint violation and it is not.

6.5.16.1 Simple assignment
Says that (amongst other things):

-- both operands are pointers to qualified or unqualified versions of
compatible types, and the type pointed to by the left has all the
qualifiers of the type pointed to by the right;

So assignment (and, by extension, parameter passing) is allowed to "add
qualifiers" to the pointed-to type (but not to the type pointed-to by
the pointed-to type).

As far as I can tell, this rule is somewhat arbitrary and is intended,
presumably, to simplify the compiler's job. It (or something like it)
is required because without it a constraint-free program could modify
a const object[1] but at least one other language took the view that
all "safe" assignments would be allowed. Thus the OP's original
example (with const at every level) causes not a peep from a C++
compiler.

Does anyone know the reason C chose this safe but restrictive rule?
Does it significantly simplify the compiler?

[1] Like this:

char *p;
const char foo = 'F';
const char **cp = &p; /* Innocent at first glance */
*cp = &foo;
*p = 'B'; /* Pow! */

This (correctly) raises the alarm from both C and C++ compiler, but
changing the key line to:

const char *const *cp = &p; /* Entirely safe. */

causes C++ to complain only at the now obviously illegal line following
where a now const object is being modified. Both this new line and
the following one are constraint violations as far as C is concerned.

--
Ben.
Jun 2 '07 #9

P: n/a
Ben Bacarisse wrote:
CBFalconer <cb********@yahoo.comwrites:
>Tor Rustad wrote:
>>>
... snip ...
>>>
This is really a question for Chris Torek.
Here is a simpler example:

$ cat const_cast.c
int main(void)
{
int **ppi;
const int * const *pcpci;

pcpci = ppi;
return 0;
}

No. const objects must be initialized at declaration time.

I may be missing your point, but pcpci is not a const object.
By George, you're right. I missed that in the declaration.
However ppi is uninitialized, which would be a reason to complain.

--
<http://www.cs.auckland.ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfocus.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
<http://kadaitcha.cx/vista/dogsbreakfast/index.html>
cbfalconer at maineline dot net

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

Jun 2 '07 #10

P: n/a
Ben Bacarisse wrote:

<snip>
If it were that simple, then assigning a char * to a const char *
would also be a constraint violation and it is not.
<snip>

That was an excellent clarification, great post Ben!

--
Tor <torust [at] online [dot] no>
Jun 2 '07 #11

P: n/a
CBFalconer wrote:
Tor Rustad wrote:
>CBFalconer wrote:
[...]
>>No. const objects must be initialized at declaration time.
Before posting, I even checked that 'pcpci' was a pointer (to const
pointer to const int).

What am I missing exactly?

You can't write to const objects.
I know that, and didn't do such a thing. :-)

--
Tor <torust [at] online [dot] no>
Jun 2 '07 #12

P: n/a
On Sat, 02 Jun 2007 05:47:06 +0100, Ben Bacarisse
<be********@bsb.me.ukwrote:
<snip: 6.5.16.1>
So assignment (and, by extension, parameter passing) is allowed to "add
qualifiers" to the pointed-to type (but not to the type pointed-to by
the pointed-to type).

As far as I can tell, this rule is somewhat arbitrary and is intended,
presumably, to simplify the compiler's job. It (or something like it)
is required because without it a constraint-free program could modify
a const object[1] but at least one other language took the view that
all "safe" assignments would be allowed. Thus the OP's original
example (with const at every level) causes not a peep from a C++
compiler.

Does anyone know the reason C chose this safe but restrictive rule?
Does it significantly simplify the compiler?
In ~1989 when const was added they chose they simplest rule that was
obviously safe. It may or may not have significantly simplified the
compiler, but it did significantly simplify programmers', and standard
writers' and voters', rapid understanding of this new feature.

With several years of experience, C++ could choose the somewhat more
flexible rule of adding qualification at all or multiple inner levels.

C99 probably could have followed C++(98) but didn't. I don't know if
it was proposed, although they did have plently of other work to do.
- formerly david.thompson1 || achar(64) || worldnet.att.net
Jul 1 '07 #13

P: n/a
David Thompson <da************@verizon.netwrites:
On Sat, 02 Jun 2007 05:47:06 +0100, Ben Bacarisse
<be********@bsb.me.ukwrote:
<snip: 6.5.16.1>
>So assignment (and, by extension, parameter passing) is allowed to "add
qualifiers" to the pointed-to type (but not to the type pointed-to by
the pointed-to type).
<snip>
>Does anyone know the reason C chose this safe but restrictive rule?
Does it significantly simplify the compiler?
In ~1989 when const was added they chose they simplest rule that was
obviously safe. It may or may not have significantly simplified the
compiler, but it did significantly simplify programmers', and standard
writers' and voters', rapid understanding of this new feature.
Ah, yes. I was ignoring the value a simple rule would have for
understanding and acceptance.

--
Ben.
Jul 1 '07 #14

P: n/a
David Thompson <da************@verizon.netwrote:
>
C99 probably could have followed C++(98) but didn't. I don't know if
it was proposed, although they did have plently of other work to do.
It was certainly considered, but there are substantial (and sometimes
quite subtle) differences between the way the C and C++ standards
describe their respective languages such that the rules couldn't just be
transplanted intact, but would have to be rewritten. And C99 added the
restrict qualifier that isn't covered by the existing C++ rules and
behaves quite differently from const and volatile. All in all, it would
have been a good bit of work and no one volunteered to undertake it.

I'm reasonably sure the committee would be happy to consider relaxed
conversion rules if someone were to work out the details and propose
them.

-Larry Jones

If I get a bad grade, it'll be YOUR fault for not doing the work for me!
-- Calvin
Jul 1 '07 #15

This discussion thread is closed

Replies have been disabled for this discussion.