«

Hi all,

what exactly is the purpose of multi-character constant..???

wrote:
> Hi all,
>
> what exactly is the purpose of multi-character constant..???

Do you mean UCN?

--
Tor < | tr i-za-h a-z>

Tor Rustad wrote:
> wrote:
>> Hi all,
>>
>> what exactly is the purpose of multi-character constant..???
>
> Do you mean UCN?
>

No. See 6.4.4.4p10: "The value of an integer character constant
containing more than one character (e.g., 'ab'), or containing a
character or escape sequence that does not map to a single-byte
execution character, is implementation-defined."

I have no idea which implementations support meaningful definitions for
multi-character constants, nor what they use them for.I imagine that one
possible form of implementation defined behavior might be to have

int i = 'ab';

have exactly the same effect as

memcpy(&i, "ab", sizeof i);

I'm not sure how useful that would be.

wrote:
> what exactly is the purpose of multi-character constant..???

It's not 100% clear what you mean; an example would be helpful.

If you mean something like 'ab', the best answer is that if you have to
ask, you don't need to know. All the standard says is (C99 6.4.4.4p10):

The value of an integer character constant containing more than
one character (e.g., 'ab') [...] is implementation-defined.

In practice, the value of 'ab' is likely to be either 'a' * 256 + 'b'
or 'b' * 256 + 'a'. It will vary from one compiler to another.

The only place I've seen them actually used is in software for PalmOS,
where, if I recall correctly, they're used to provide unique 16-bit tags
for applications. Something like 'XY' that's related to the name of the
application is easier to remember than a numeric constant. In that
context, the actual value doesn't matter, just that each pair of
characters maps to a consistent and unique integer value. This depends
on every compiler using the same mapping, or on all applications being
compiled with the same compiler.

But a sufficiently perverse compiler could legally have all such
constants have the value 42.

Avoid such constants unless you really need them *and* you're prepared
to deal with the fact that they're inherently non-portable.

--
Keith Thompson (The_Other_Keith) <kst->
Looking for software development work in the San Diego area.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

Do not use them.

On Nov 21, 5:53 pm, Keith Thompson <ks...@mib.org> wrote:
> aark...@gmail.com wrote:
> > what exactly is the purpose of multi-character constant..???
>
> It's not 100% clear what you mean; an example would be helpful.
>
> If you mean something like 'ab', the best answer is that if you have to
> ask, you don't need to know. All the standard says is (C99 6.4.4.4p10):
>
> The value of an integer character constant containing more than
> one character (e.g., 'ab') [...] is implementation-defined.


In practice, the value of 'ab' is likely to be either 'a' * 256 + 'b'
or 'b' * 256 + 'a'. It will vary from one compiler to another.

I don't think that the above argument of yours is correct.

i have seen a program like this:-

#include<stdio.h>
int main(void)
{
char str['11'] = {"work hard"};
printf("%d\n",sizeof(str));
return(EXIT_SUCCESS);
}

and the o/p is given as 12593
now by your reasoning the o/p should be 1*16 +1 = 17 isn't it...???

In article
<e9cdb748-d18c-49dc-8127->,
<> wrote on Thursday 22 Nov 2007
10:45 am:

> On Nov 21, 5:53 pm, Keith Thompson <ks...@mib.org> wrote:
>> aark...@gmail.com wrote:
>> > what exactly is the purpose of multi-character constant..???
>>
>> It's not 100% clear what you mean; an example would be helpful.
>>
>> If you mean something like 'ab', the best answer is that if you have
>> to
>> ask, you don't need to know. All the standard says is (C99
>> 6.4.4.4p10):
>>
>> The value of an integer character constant containing more than
>> one character (e.g., 'ab') [...] is implementation-defined.
>
>
> In practice, the value of 'ab' is likely to be either 'a' * 256 + 'b'
> or 'b' * 256 + 'a'. It will vary from one compiler to another.
>
> I don't think that the above argument of yours is correct.
>
> i have seen a program like this:-
>
> #include<stdio.h>
> int main(void)
> {
> char str['11'] = {"work hard"};
> printf("%d\n",sizeof(str));
> return(EXIT_SUCCESS);
> }
>
> and the o/p is given as 12593
> now by your reasoning the o/p should be 1*16 +1 = 17 isn't it...???

No. By his reasoning it would be:

'1' * 256 + '1'

or

'1' * 256 + '1'

Note the single quotes around 1. The compiler replaces the character
literal with whatever encoding the implementation uses for it. Thus
if '1' is represented by the value 50 (just an example) the expression
would be:

50 * 256 + 50

or

50 * 256 + 50

As Keith said this is implementation dependent behaviour and the
Standard has very little to say about how multi-character character
constants are interpreted.

Apply the above formula and see that Keith conclusion was correct for
ASCII based systems. In the ASCII encoding '1' is represented by the
number 49. Thus:

49 * 256 + 49 = 12593

But you cannot depend on this in general.

On Nov 22, 1:20 am, santosh <santosh....@gmail.com> wrote:
> In article
> <e9cdb748-d18c-49dc-8127-25460bf55...@e23g2000prf.googlegroups.com>,
> aark...@gmail.com <aark...@gmail.com> wrote on Thursday 22 Nov 2007
> 10:45 am:
>
>
>
> > On Nov 21, 5:53 pm, Keith Thompson <ks...@mib.org> wrote:
> >> aark...@gmail.com wrote:
> >> > what exactly is the purpose of multi-character constant..???
>
> >> It's not 100% clear what you mean; an example would be helpful.
>
> >> If you mean something like 'ab', the best answer is that if you have
> >> to
> >> ask, you don't need to know. All the standard says is (C99
> >> 6.4.4.4p10):
>
> >> The value of an integer character constant containing more than
> >> one character (e.g., 'ab') [...] is implementation-defined.
>
> > In practice, the value of 'ab' is likely to be either 'a' * 256 + 'b'
> > or 'b' * 256 + 'a'. It will vary from one compiler to another.
>
> > I don't think that the above argument of yours is correct.
>
> > i have seen a program like this:-
>
> > #include<stdio.h>
> > int main(void)
> > {
> > char str['11'] = {"work hard"};
> > printf("%d\n",sizeof(str));
> > return(EXIT_SUCCESS);
> > }
>
> > and the o/p is given as 12593
> > now by your reasoning the o/p should be 1*16 +1 = 17 isn't it...???
>
> No. By his reasoning it would be:
>
> '1' * 256 + '1'
>
> or
>
> '1' * 256 + '1'
>
> Note the single quotes around 1. The compiler replaces the character
> literal with whatever encoding the implementation uses for it. Thus
> if '1' is represented by the value 50 (just an example) the expression
> would be:
>
> 50 * 256 + 50
>
> or
>
> 50 * 256 + 50
>
> As Keith said this is implementation dependent behaviour and the
> Standard has very little to say about how multi-character character
> constants are interpreted.
>
> Apply the above formula and see that Keith conclusion was correct for
> ASCII based systems. In the ASCII encoding '1' is represented by the
> number 49. Thus:
>
> 49 * 256 + 49 = 12593
>
> But you cannot depend on this in general.

okay you are correct i got the point. but i made a mistake in earlier
post it should have been '1' *256 + '1'

BTW on what basis we are selecting this value of 256...???

wrote:
....
> okay you are correct i got the point. but i made a mistake in earlier
> post it should have been '1' *256 + '1'
>
> BTW on what basis we are selecting this value of 256...???

The value of mult-character literals is implementation-defined, 256 is
just part of an example. It's CHAR_MAX+1 if char is unsigned and 8 bits,
a rather common case. In my own example, I side-stepped the character
size and signedness issues by using memcpy(). On bigendian systems where
sizeof(int)==2, my example is equivalent to Keith's.

wrote:
> On Nov 22, 1:20 am, santosh <santosh....@gmail.com> wrote:
>> In article
>> <e9cdb748-d18c-49dc-8127-25460bf55...@e23g2000prf.googlegroups.com>,
>> aark...@gmail.com <aark...@gmail.com> wrote on Thursday 22 Nov 2007
>> 10:45 am:
>>> On Nov 21, 5:53 pm, Keith Thompson <ks...@mib.org> wrote:
>>> In practice, the value of 'ab' is likely to be either 'a' * 256 + 'b'
>>> or 'b' * 256 + 'a'. It will vary from one compiler to another.
>
> okay you are correct i got the point. but i made a mistake in earlier
> post it should have been '1' *256 + '1'
>
> BTW on what basis we are selecting this value of 256...???

Multiplying by 256 is the same as shifting left eight bits. So if you
have 'a' * 256 + 'b' then you have an integer whose representation
corresponds to the least-significant byte containing the value 'b' and
the next-least-significant byte containing the value 'a'.

Or, in picture form, showing a 32-bit 'int' split into its constituent
8-bit bytes with big-endian byte order:

+---+---+---+---+
| 0 | 0 |'a'|'b'|
+---+---+---+---+

Note that all this assumes that CHAR_BIT == 8.