C questions

[sophia.agnes]

Dear all,

I was going through a C book written by an indian author
the following are the questions given in that book

1) consider the following statement:
s1 : an operator may require an lvalue operand, yet yield an r
value
s2: an operator may accept an rvalue operand , yet gives an lvalue

which of the following is true about s1 and s2

(a) both s1 and s2 are true
(b) only s1 correct
(c) only s2 is correct
(d) both are false

answer is given as (a)

& is one such operator
int n;
*n is lvalue
&n is rvalue

operator operand result
& n is l value &n rvalue

* (p + 1) is r value *(p + 1) lvalue
2) which of the following is false

a) a string has type array of characters
b) a string has storage class static
c) adjacent string literals are concatenated into a single string
d) Concatenation of ordinary and wide string literal is a single
string

answer is given as d option

3)consider the following

process1(int counter)
{

if(counter == 1)
{
char buf[80];
--------------
}
}

process2(int counter)
{
char buff[80];
if(counter == 1)
{
--------
}

}

which one of the following is true

(a) both process require same stack space in all cases
(b) process 1 require more stack space
(c) process 2 require more stack space
(d) stack space for process is not allocated if counter == 1

answer is given as a option

4) consider the following statements

s1: evaluating the address of an object value after indirection is
simply object
s2:evaluating an object value from indirecting after taking its
address is not the object

which of the following is true
(a) only s1
(b) both are correct
(c) only s2 is correct
(d) both are wrong

answer is given as b option

5)which operation require more memory access
(a) branch
(b) conditional code test
(c) shift register right /* what is this ?*/
(d) all are same

answer is given as d option

well what do you folks think of all this stuff ?

[=?UTF-8?q?Harald_van_D=C4=B3k?=]

On Mon, 07 Jan 2008 08:50:08 -0800, sophia.agnes wrote:

2) which of the following is false

a) a string has type array of characters
b) a string has storage class static
c) adjacent string literals are concatenated into a single string
d) Concatenation of ordinary and wide string literal is a single

string

>
answer is given as d option

It's possible that it used to be right in the previous version of C -- I
am not sure about that -- but now, this is wrong. Concatenation of a
narrow and a wide string literal is allowed, and produces one single wide
string.

3)consider the following

process1(int counter)
{

if(counter == 1)
{
char buf[80];
--------------
}
}

process2(int counter)
{
char buff[80];
if(counter == 1)
{
--------
}

}

which one of the following is true

(a) both process require same stack space in all cases
(b) process 1 require more stack space
(c) process 2 require more stack space
(d) stack space for process is not allocated if counter == 1

This is implementation-specific; some implementations may always reserve
memory for objects with block scope, but there is no requirement for them
to do so.

4) consider the following statements

s1: evaluating the address of an object value after indirection is
simply object
s2:evaluating an object value from indirecting after taking its address
is not the object

I don't understand these statements. When x is an object, *&x is
completely equivalent to x, and when x is a pointer, &*x is equivalent to
x, except that it is not an lvalue.

5)which operation require more memory access
(a) branch
(b) conditional code test
(c) shift register right /* what is this ?*/
(d) all are same

This is, again, specific to the implementation.

[Richard Tobin]

In article <88************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>I can't think of any operator that /requires/ an lvalue operand.

++

-- Richard
--
:wq

[Richard Heathfield]

Richard Tobin said:

In article <88************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>>I can't think of any operator that /requires/ an lvalue operand.

++

Well, there ya go - it shows that I didn't think very hard...

Of course, it won't take just any old lvalue. It requires a modifiable
lvalue that is not a structure or union.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[jacob navia]

Richard Heathfield wrote:

Richard Tobin said:

>In article <88************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>>I can't think of any operator that /requires/ an lvalue operand.

++

Well, there ya go - it shows that I didn't think very hard...

Of course, it won't take just any old lvalue. It requires a modifiable
lvalue that is not a structure or union.

unless it is overloaded...

:-)
--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32

[Eric Sosman]

so**********@gm ail.com wrote:

Dear all,

I was going through a C book written by an indian author
the following are the questions given in that book

1) consider the following statement:
s1 : an operator may require an lvalue operand, yet yield an r
value
s2: an operator may accept an rvalue operand , yet gives an lvalue

which of the following is true about s1 and s2

(a) both s1 and s2 are true
(b) only s1 correct
(c) only s2 is correct
(d) both are false

answer is given as (a)

& is one such operator
int n;
*n is lvalue
&n is rvalue

operator operand result
& n is l value &n rvalue

* (p + 1) is r value *(p + 1) lvalue

The answer is correct, but the explanation seems at best
"confused." In particular, `*n' is not an lvalue, but an
error requiring a diagnostic. Also `(p + 1)' is not always
an rvalue (consider `void *p'), and `*(p + 1)' is not always
an lvalue (consider `int *p = &n').

2) which of the following is false

a) a string has type array of characters
b) a string has storage class static
c) adjacent string literals are concatenated into a single string
d) Concatenation of ordinary and wide string literal is a single
string

answer is given as d option

Certainly (b) is also false.

3)consider the following

process1(int counter)
{

if(counter == 1)
{
char buf[80];
--------------
}
}

process2(int counter)
{
char buff[80];
if(counter == 1)
{
--------
}

}

which one of the following is true

(a) both process require same stack space in all cases
(b) process 1 require more stack space
(c) process 2 require more stack space
(d) stack space for process is not allocated if counter == 1

answer is given as a option

All four answers are false (or perhaps "undecidabl e") from
the point of view of the C language, although one or more may
be true of particular implementations of C.

4) consider the following statements

s1: evaluating the address of an object value after indirection is
simply object
s2:evaluating an object value from indirecting after taking its
address is not the object

which of the following is true
(a) only s1
(b) both are correct
(c) only s2 is correct
(d) both are wrong

answer is given as b option

I don't know, because I cannot make sense of either s1 or s2.

5)which operation require more memory access
(a) branch
(b) conditional code test
(c) shift register right /* what is this ?*/
(d) all are same

answer is given as d option

As in #3, the question is meaningless as far as the C
language goes, but may have meaning for some implementations .

well what do you folks think of all this stuff ?

Not much. I've seen worse, but I've seen much better.

--
Er*********@sun .com

[jameskuyper]

Richard Heathfield wrote:

so**********@gm ail.com said:

Dear all,

I was going through a C book written by an indian author
the following are the questions given in that book

1) consider the following statement:
s1 : an operator may require an lvalue operand, yet yield an r
value

Without actually doing an exhaustive study, I'm pretty sure this is false.

a=3

....

& can take the name of a function, which is far from being an lvalue! I
can't think of any operator that /requires/ an lvalue operand.

The increment, decrement, and assignment operators all require an
lvalue operands.

....

d) Concatenation of ordinary and wide string literal is a single
string

False - the behaviour is undefined.

C99 Section 6.4.5p4:
"In translation phase 6, the multibyte character sequences specified
by any sequence of adjacent character and wide string literal tokens
are concatenated into a single multibyte character sequence. If any of
the tokens are wide string literal tokens, the resulting multibyte
character sequence is treated as a wide string literal; otherwise, it
is treated as a character string literal."

[sophia.agnes]

On Jan 7, 10:07 pm, Harald van D©¦k <true...@gmail. comwrote:

On Mon, 07 Jan 2008 08:50:08 -0800, sophia.agnes wrote:

>

4) consider the following statements

s1: evaluating the address of an object value after indirection is
simply object
s2:evaluating an object value from indirecting after taking its address
is not the object

I don't understand these statements. When x is an object, *&x is
completely equivalent to x, and when x is a pointer, &*x is equivalent to
x, except that it is not an lvalue.

answer is given as follows:-

consider the following program

main()
{
char x[] = "abcde";
printf("%d %d", x+3,&*x+3);
printf("%d %d", x+3,*&(x + 3));

}

x[i] = (*(x + i));
&x[i] = &(*(x+i));

C precedence rule evaluate & and * from right to left, so we can
remove the outer parenthesis i.e
&x[i] = &*(x + i) reduced to &x[i] = (x+i)

[Chris Torek]

In article <88************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>... I can't think of any operator that /requires/ an lvalue operand.

All of the assignment operators (e.g., +=), and the pre- and
post-fix ++ and -- operators, require at least one lvalue operand.

(As you note, unary & requires an lvalue only when it is applied
to objects, since function designators are not lvalues.)
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[Richard Tobin]

In article <88************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>& is one such operator
int n;
*n is lvalue

Close. n is an object. *n is illegal.

>&n is rvalue

& can take the name of a function, which is far from being an lvalue!

Though you are of course right about that, the answer does come close
to the *idea* of lvalues. The idea of an lvalue is that it's
something on the left-hand side of an assignment - something that can
be assigned to - a place rather than a value. The ability to take the
address of something clearly implies that it is a place.

The fact that you can't say

int foo(void) {...}
int bar(void) {...}
....
foo = bar;

is not really any different from the situation with

int foo[10];
int bar[10];
....
foo = bar;

so there's no real reason why function names should not be considered
lvalues just as array names are.

-- Richard
--
:wq