«

hi all,

i want to know that what is the actual difference b/w the character
array
& character pointer.then how u will get the addrees of a char array[]

char str[]="be silent like u"
char *p1="be eloquent r u"
char *p2;
p2=str;

but printing the p2 will give me the str

<> wrote in message
news: oups.com...
> hi all,
>
> i want to know that what is the actual difference b/w the character
> array
> & character pointer.then how u will get the addrees of a char array[]
>
> char str[]="be silent like u"
> char *p1="be eloquent r u"
> char *p2;
> p2=str;
>
> but printing the p2 will give me the str

Most print routines (std::cout, printf, etc...) treat a char pointer as a
c-style string and do indeed print the string. One simple work aroiund is
to cast it to some other pointer type and output that. Such as:

std::cout << reinterpret_cast<int*>( p2 );
static_cast may(?) also work.
You can treat str the same way in output to output the address.

On 9 Jun., 08:52, rajm2...@gmail.com wrote:
> hi all,
>
> i want to know that what is the actual difference b/w the character
> array
> & character pointer.then how u will get the addrees of a char array[]
>
> char str[]="be silent like u"
This is an array to 17 chars (remember the leading zero). You can
change the variable, e.g. str[0] = 'B';.
> char *p1="be eloquent r u"
This is a const pointer to an array of char. Do not be fooled about
the missing const.
> char *p2;
> p2=str;
>
> but printing the p2 will give me the str
You can of course print both str and p2 because of the way arrays
decay to a pointer to the first element.

/Peter

On 9 Jun, 08:15, peter koch <peter.koch.lar...@gmail.com> wrote:
> On 9 Jun., 08:52, rajm2...@gmail.com wrote:> hi all,
> > char str[]="be silent like u"
>
> This is an array to 17 chars (remember the leading zero).

trailing, not leading.

> > char *p1="be eloquent r u"
>
> This is a const pointer to an array of char. Do not be fooled about
> the missing const.

It's a non-const pointer to const char.

To the OP: The declaration above is deprecated. You should use

const char *p1="be eloquent r u";

for string literals.

Gavin Deane

On Jun 9, 8:52 am, rajm2...@gmail.com wrote:

> i want to know that what is the actual difference b/w the
> character array & character pointer.

One is an array, and the other is a pointer. What more
difference do you want?

> then how u will get the addrees of a char array[]

By taking its address, using the & operator.

> char str[]="be silent like u"

This defines an array, initialized with the characters in the
string literal.

> char *p1="be eloquent r u"

This defines both a pointer and an (unnamed) array---a string
literal is an unnamed unmodifiable array. The pointer is
initialized with the address of the first character in the
unnamed array.

Note that this is not really correct C++. It's supported for
historical reasons, but you really should write:

char const* p1 = "be eloquent r u" ;

> char *p2;
> p2=str;

Here, there is the same implicit conversion as in the previous
initialization: an array (str) is implicitly converted to the
address of its first member.

> but printing the p2 will give me the str

That's because of a long standing tradition that functions
(most, anyway) receiving a pointer to a char will treat it as
the address of the first element of an array of char, and will
process all of the following elements as well, up to but not
including a final '\0'.

In practice, the case almost never comes up in C++, because we
rarely if ever declare arrays of char, nor use pointer to char.

--
James Kanze (Gabi Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

On Jun 9, 8:15 pm, Gavin Deane <deane_ga...@hotmail.com> wrote:
> On 9 Jun, 08:15, peter koch <peter.koch.lar...@gmail.com> wrote:
> > On 9 Jun., 08:52, rajm2...@gmail.com wrote:> hi all,
>
> > > char *p1="be eloquent r u"
>
> > This is a const pointer to an array of char.
> > Do not be fooled about the missing const.
>
> It's a non-const pointer to const char.

To clarify, the type of p1 is 'pointer to char',
i.e. non-const pointer to non-const char.

Despite this, the chars it is pointing at are const.