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

 

[Rolf Magnus]

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

Because you might want to use it on a value to find out its size, or you
want to use it on a type to find out its size.

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

(++x) is not a type. int would be a type.

 

[Alex Vinokur]

Alex Vinokur wrote: [snip]

int main()
{
int x = 100;

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

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

(++x) is not a type. int would be a type.

[snip]

I think, ++x is parsed as typename in sizeof (++x).

 

[Markus Schoder]

Alex Vinokur wrote: [snip]

int main()
{
int x = 100;

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

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

(++x) is not a type. int would be a type.

[snip]

I think, ++x is parsed as typename in sizeof (++x).

No it is a unary-expression because a primary-expression is also a
unary-expression and ( expression ) is a primary-expression and clearly
++x is an expression.

 

[Alex Vinokur]

Alex Vinokur wrote: [snip]

int main()
{
int x = 100;

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

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

(++x) is not a type. int would be a type.

[snip]

I think, ++x is parsed as typename in sizeof (++x).

No it is a unary-expression because a primary-expression is also a
unary-expression and ( expression ) is a primary-expression and clearly
++x is an expression.

What is the difference between
sizeof ++x
and
sizeof (++x)
?

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

 

[Phlip]

What is the difference between
sizeof ++x
and
sizeof (++x)
?

Nothing. sizeof takes an expression, and parens in expressions may be
optional.

sizeof(int) is the size of the typecast to int. (int)0.

 

[Alex Vinokur]

Nothing. sizeof takes an expression, and parens in expressions may be
optional.

So, why do we need two kinds of sizeof operator?

sizeof(int) is the size of the typecast to int. (int)0.

[snip]

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

 

[Markus Schoder]

So, why do we need two kinds of sizeof operator?

One takes an expression and returns the size of the expression's type
and one takes a type directly (which must be put in parentheses). It is
mostly a matter of convenience.

 

[Thomas J. Gritzan]

So, why do we need two kinds of sizeof operator?

int x;

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

Which one do you think is redundant?

Thomas

 

[Alex Vinokur]

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

[snip]

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

 

[Default User]

Thomas J. Gritzan wrote:

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]

Alex Vinokur wrote:

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]

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]

Steve Pope 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. (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]

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]

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