multi-character constant

[aarklon]

Hi all,

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

[Tor Rustad]

aa*****@gmail.com wrote:

Hi all,

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

Do you mean UCN?

--
Tor <bw****@wvtqvm.vw | tr i-za-h a-z>

[James Kuyper]

Tor Rustad wrote:

aa*****@gmail.com 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.

[Keith Thompson]

aa*****@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.

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) <ks***@mib.org>
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"

[vippstar]

Do not use them.

[aarklon]

On Nov 21, 5:53 pm, Keith Thompson <[e-mail]:

[e-mail] 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...???

[santosh]

In article
<e9**********************************@e23g2000prf. googlegroups.com>,
aa*****@gmail.com <aa*****@gmail.comwrote on Thursday 22 Nov 2007
10:45 am:

On Nov 21, 5:53 pm, Keith Thompson <[e-mail]:

>[e-mail] 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.

[aarklon]

On Nov 22, 1:20 am, santosh <[e-mail]:

In article
<[e-mail]>,
[e-mail] <[e-mail] on Thursday 22 Nov 2007
10:45 am:

On Nov 21, 5:53 pm, Keith Thompson <[e-mail]:

[e-mail] 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...???

[James Kuyper]

aa*****@gmail.com 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.

[Barry Schwarz]

On Wed, 21 Nov 2007 13:08:07 -0800 (PST), aa*****@gmail.com wrote:

>Hi all,

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

Since the implementation is free to define what such a constant
evaluates to, it would seen that the answer to your question depends
on that definition.

If 'ab' will evaluate to 'a' or 'b', then it's only purpose would seem
to be code obfuscation. On the other hand, if it evaluates to some
constant independent of a and b, it doesn't seem to have any purpose.

About the only somewhat useful purpose I can imagine is if
int c = 'ab';
was conceptually equivalent to something along the lines of
int c;
memcpy(&c,"ab",min(sizeof c, strlen("ab"));
with "appropriate" consideration given to endian-ness as well as
excessive or insufficient initialization bytes. But I expect the
number of applications where this has any value to be miniscule.
Remove del for email

[Willem]

Barry wrote:
) About the only somewhat useful purpose I can imagine is if
) int c = 'ab';
) was conceptually equivalent to something along the lines of
) int c;
) memcpy(&c,"ab",min(sizeof c, strlen("ab"));
) with "appropriate" consideration given to endian-ness as well as
) excessive or insufficient initialization bytes. But I expect the
) number of applications where this has any value to be miniscule.

The four-letter chunk identifiers in many file formats come to mind.

I've seen pieces of code similar to this:

switch(read_uint32(stream)) {
case 'ILBM':
/* Do something */
case '8SVX':
/* Do something else */
default:
/* Do nothing */
}

SaSW, Willem
--
Disclaimer: I am in no way responsible for any of the statements
made in the above text. For all I know I might be
drugged or something..
No I'm not paranoid. You all think I'm paranoid, don't you !
#EOT