sizeof of expression & sizeof of type

[Alex Vinokur]

Why does one need to use two kinds of sizeof operator:
* sizeof unary-expression,
* sizeof (type-name)
?

Their behavior seem not to be different (see an example below).

------ C++ code ------
#include <iostream>
using namespace std;

int main()
{
int x = 100;

cout << sizeof ++x << endl; // expression sizeof
cout << x << endl;

x = 100;
cout << endl;
cout << sizeof (++x) << endl; // type sizeof
cout << x << endl;

return 0;
}
----------------------

------ Run ------

4
100

4
100

-----------------

Alex Vinokur
email: alex DOT vinokur AT gmail DOT com
http://mathforum.org/library/view/10978.html
http://sourceforge.net/users/alexvn

[Default User]

Alex Vinokur wrote:

Thomas J. Gritzan wrote:

Which one do you think is redundant?

1) sizeof(int)
2) sizeof(x)
3) sizeof x // redundant

You are confused. 2 and 3 are the same thing, there just are
superfluous parentheses in 2. It's somewhat similar, although not
exactly, to this:
return (2);

return 2;

Those aren't redundant forms of return, just unneeded parentheses.


Brian

[Steve Pope]

Default User <de***********@ yahoo.com> wrote:

Alex Vinokur wrote:

Thomas J. Gritzan wrote:

> Which one do you think is redundant?

1) sizeof(int)
2) sizeof(x)
3) sizeof x // redundant

You are confused. 2 and 3 are the same thing, there just are
superfluous parentheses in 2. It's somewhat similar, although not
exactly, to this: return (2); return 2;

Not exactly indeed, due to operator precedence.

int x;
long long y;
int z = sizeof x, y;

Gives you 4, while

int x=1;
int y=2;
int z = return 1, 2;

Gives you 2.

Steve

[Default User]

Steve Pope wrote:

Default User <de***********@ yahoo.com> wrote:

Alex Vinokur wrote:

Thomas J. Gritzan wrote: Which one do you think is redundant? 1) sizeof(int)
2) sizeof(x)
3) sizeof x // redundant

You are confused. 2 and 3 are the same thing, there just are
superfluous parentheses in 2. It's somewhat similar, although not
exactly, to this:

return (2);

return 2;

Not exactly indeed, due to operator precedence.

int x;
long long y;
int z = sizeof x, y;

Gives you 4, while

int x=1;
int y=2;
int z = return 1, 2;

Gives you 2.

What does any of that have to do with parentheses? The OP didn't
mention the comma operator, nor did I.

Brian

[Steve Pope]

Default User <de***********@ yahoo.com> wrote:

Steve Pope wrote:

Default User <de***********@ yahoo.com> wrote:

> Alex Vinokur wrote:

>> Thomas J. Gritzan wrote:

>> > Which one do you think is redundant?

>> 1) sizeof(int)
>> 2) sizeof(x)
>> 3) sizeof x // redundant

> You are confused. 2 and 3 are the same thing, there just are
> superfluous parentheses in 2. It's somewhat similar, although not
> exactly, to this:

> return (2);

> return 2;

Not exactly indeed, due to operator precedence.

int x;
long long y;
int z = sizeof x, y;

Gives you 4, while

int x=1;
int y=2;
int z = return 1, 2;

Gives you 2.

What does any of that have to do with parentheses? The OP didn't
mention the comma operator, nor did I.

The "sizeof" operator has a certain precedence. (Look at
the table of operator precedences e.g. in Stroustrup.) The "return"
statement is not an operator, therefore has lower precedence
than any operator, therefore the entire expression to the right
of it is evaluated first.

That's how I look at it, in any case.

Steve

[tedu]

Alex Vinokur wrote:

Thomas J. Gritzan wrote:
[snip]

int x;

1) sizeof(int)
2) sizeof(x) (or sizeof x)

Which one do you think is redundant?

1) sizeof(int)
2) sizeof(x)
3) sizeof x // redundant

you forgot
4) sizeof ((x))
5) sizeof (((x)))
....

[Default User]

Steve Pope wrote:

Default User <de***********@ yahoo.com> wrote:

What does any of that have to do with parentheses? The OP didn't
mention the comma operator, nor did I.

The "sizeof" operator has a certain precedence.

That's how I look at it, in any case.

Hence the qualifier, "It's somewhat similar, although not exactly, to
this". Yeah, we can construct some examples where the () could matter,
but they don't for the ones the OP presented.

Brian