Home     |     .Net Programming    |     cSharp Home    |     Sql Server Home    |     Javascript / Client Side Development     |     Ajax Programming

Ruby on Rails Development     |     Perl Programming     |     C Programming Language     |     C++ Programming     |     IT Jobs

Python Programming Language     |     Laptop Suggestions?    |     TCL Scripting     |     Fortran Programming     |     Scheme Programming Language


 
 
Cervo Technologies
The Right Source to Outsource

MS Dynamics CRM 3.0

C Programming Language

assigning const char* to char*


Hi,

This is a very simple question but I couldn't find it in your FAQ.

I'm using VC++ and compiling a C program, using the /TC flag.

I've got a function for comparing two strings

int strspcmp(const char * s1, const char * s2)
{

        char* pS1 = s1;
        char* pS2 = s2;
        ...
        ...

}

As you can see, I assign the two const ptrs to some non-const ptrs to
do some ptr arithmetic,
like incrementing the ptrs to compare the strings.
But I'm getting warning C4090 complaining about the assignment.
I thought I was doing the standard thing for ptr arithmetic. What am I
doing wrong?
How do I get rid of the warning?
Peithon said:

> Hi,

> This is a very simple question but I couldn't find it in your FAQ.

> I'm using VC++ and compiling a C program, using the /TC flag.

> I've got a function for comparing two strings

> int strspcmp(const char * s1, const char * s2)

Although it has nothing to do with your question, I should perhaps point
out that the name strspcmp is reserved. str_spcmp is not, however.

> {

> char* pS1 = s1;
> char* pS2 = s2;
> ...
> ...

> }

> As you can see, I assign the two const ptrs to some non-const ptrs to
> do some ptr arithmetic,
> like incrementing the ptrs to compare the strings.

You don't need to do that, and in fact it's a bad idea. The const char *
syntax doesn't mean "this pointer can't change". It means "you can't
write through this pointer". ++s1 is fine. *s1 = '\0', however, is not.
And since you don't want to do that anyway, I suggest that you use
const char * - in which case pS1 and pS2 become redundant; you might as
well use s1 and s2 directly. (Remember that C is pass-by-value, so ++s1
only changes your local copy of the pointer, not the value of the
pointer passed by the caller.)

<snip>

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

For a start you post the warning you are getting :-;

Peithon <Peit@googlemail.com> writes:
> Hi,

> This is a very simple question but I couldn't find it in your FAQ.

> I'm using VC++ and compiling a C program, using the /TC flag.

> I've got a function for comparing two strings

> int strspcmp(const char * s1, const char * s2)

You are invading the implementation's name space.

> {

>    char* pS1 = s1;
>    char* pS2 = s2;
>    ...
>    ...

> }

> As you can see, I assign the two const ptrs to some non-const ptrs

The pointers are not const.  They point to const char.  Subtle but
important distinction.

> to do some ptr arithmetic,

Odd.  You can do arithmetic on const char * as well and you would not
get the warnings.

> like incrementing the ptrs to compare the strings.
> But I'm getting warning C4090 complaining about the assignment.

As you must.  It requires a diagnostic.

> I thought I was doing the standard thing for ptr arithmetic. What am I
> doing wrong?
> How do I get rid of the warning?

Just to the pointer arithmetic on the const char *s1 and s2.

--
Ben.

On 1 Jun, 18:47, Ben Bacarisse <ben.use@bsb.me.uk> wrote:

Thanks, I didn't see the distinction between const char * and char *
const.
Much appreciated.

typing

const char *a;

means you have a pointer to a char and are not allowed to modify what it
  points to (but you are allowed to modify the pointer).
that means

char b;

a="hello";
a++;
b=*a;

is valid code, but not:
a=&b;
*a=' ';  /* this line is not valid */

since this is valid:

char *c;
c=&b;
*c=' ';

but modifying something pointed to by a const pointer is not is this
also not valid:

a=&b;
c=a; /* gives the warning you mentioned */
*c=' '; /* this statement is still valid */

This has already been ably answered, but perhaps a simpler example
might make the point clearer.  I think your point of confusion is that
"const char*" means "pointer to const char", not "const pointer to
char", but I'll explore other issues as well.

int main(void)
{
    const char *ptr = "hello";
    char *copy_of_ptr = ptr;
    *ptr = 'H';
    return 0;

}

The declaration "const char *ptr" doesn't make ptr const; it makes
what it points to const.  Here I've initialized ptr to point to a
string literal, i.e., to an array of 6 characters 'h', 'e', 'l', 'l',
'o', '\0'.  This array could be stored in read-only memory; attempting
to modify it could cause the program crash (it's undefined behavior).

The declaration of copy_of_ptr doesn't use the "const" keyword, which
means I'm allowed to modify either the pointer object itself *or* what
it points to.  By "allowed to", I mean that the compiler won't
complain if I try to do it; it will go ahead and generate code to do
what I asked.  It's up to me to make sure that I actually *can* modify
whatever I'm trying to modify.  If I lie to the compiler, it may or
may not complain.

But in this case, I *tried* to lie to the compiler and it caught me at
it.  I attempted to initialize a char* to the value of ptr.  If I
could do this, it would allow me to (attempt to) modify whatever
copy_of_ptr points to.  And that's exactly why the language forbids
assigning the value of ptr to copy_of_ptr (it's a constraint
violation, requiring a diagnostic).  My error is caught during
compilation, when I attempt to copy the pointer, which is much better
than not catching it until run time, when I actually try to modify the
string.

If the language, and therefore the compiler, allowed me to copy the
value of ptr to copy_of_ptr, then it would also allow me to attempt to
modify the string that it points to (remember that it might be in
read-only memory), all without telling me that I've done something
dangerous.  Fortunately, the rules of the language are such that I
can't get away with this particular error quite so easily.  (It is
overly lax about string literals, but that's another story.)

If you want a pointer to const char, declare it as:

    const char *ptr;

If you want a const pointer to char (you can't modify the pointer, but
you can modify what it points to):

    char *const ptr;

And if you want both the pointer *and* what it points to be read-only:

    const char *const p;

The placement of the "const" keyword is tricky.  If you can find a
program called "cdecl", it can help you with this kind of thing; I
used it to confirm these declarations.

% cdecl
Type `help' or `?' for help
cdecl> declare p as const pointer to char
char * const p
cdecl> declare p as const pointer to const char
const char * const p
cdecl> explain const char *p
declare p as pointer to const char
cdecl>

One thing to watch out for: cdecl treats "ptr" as a synonym for
"pointer", so if you tell it "declare ptr as pointer to const char" it
will report a syntax error.

--
Keith Thompson (The_Other_Keith) k@mib.org  <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."
    -- Antony Jay and Jonathan Lynn, "Yes Minister"

Keith Thompson wrote:

... snip ...

> One thing to watch out for: cdecl treats "ptr" as a synonym for
> "pointer", so if you tell it "declare ptr as pointer to const
> char" it will report a syntax error.

[OT] A devilish concoction.  Not mentioned in the help material.
And there are others of this type.

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

Declare the local variables as const:

        const char *pS1 = s1;

etc.  You have declared the input as pointers to const, which are
therefore not modifiable.

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

You mean you can't see the problem?

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

Add to del.icio.us | Digg this | Stumble it | Powered by Megasolutions Inc