#sizeof

I carelessly passed: sizeof(s.st_size+1) to an allocator call, instead of: s.st_size+1 and corrupted memory nicely. What the hell would sizeof(variable+1) even mean, and why on earth would the compiler think that is anything close to valid? Both gcc and clang, both with -Wall, are completely quiet about this error!

The sizeof operator in C tells us how much space the result of an expression would use if we were to evaluate it, but doesn't actually evaluate the expression. For example, sizeof i++ yields the size of the variable i, but doesn't increment i. Many implementations of C provide a typeof operator too, which provides the type of an expression without evaluating it.

That lack of side-effects is useful, for example in macro hygiene. Preprocessor macros have surprising behaviour when invoked with arguments that have side-effects:

#define BAD_MACRO(arg) do { \ /* Aiee, what if someone uses BAD_MACRO(i++)? */ \ printf("%i squared is %i\n", arg, arg * arg); \ } while (0) #define GOOD_MACRO(arg) do { \ typeof (arg) local; /* 'arg' not evaluated, no side-effects */ \ local = arg; /* 'arg' evaluated exactly once, here */ \ printf("%i squared is %i\n", local, local * local); \ } while (0)

Now that's a pretty well known pitfall, and it's common practice to use typeof and sizeof to avoid side-effects this way. But C has one more surprise lying in wait for the unwary: sometimes sizeof and typeof do have side-effects! C supports declaring arrays whose length is determined at run time, e.g.:

void do_something(int i) { char working_array[i]; /* ... */ }

The length of the working array depends on the value of i. And of course we can ask the compiler to tell us the size of a dynamic array, too: sizeof (char[i]) is equivalent to i * sizeof char, and will be evaluated at run time.

We can use any integer expression to specify the length of the array, even one with side-effects. If we do that, the compiler has no (reliable) way to know the size without evaluating the whole expression, including its side-effects. So that's what it does:

int i = 0; printf("%ld\n", sizeof (char[++i]));

increments i and prints "1". More generally, sizeof will evaluate any array-size expression in its argument if the final size depends on the value of the expression. Worse than that, according to the spec, sizeof may evaluate such expressions even if it doesn't have to:

Where a size expression is part of the operand of a sizeof operator and changing the value of the size expression would not affect the result of the operator, it is unspecified whether or not the size expression is evaluated.

Here, "unspecified" means the compiler may choose to do it or not and doesn't even have to document which. That is to say:

/* Not a size expression: won't increment i. */ sizeof (++i); /* Size expression that affects the final size: will increment i. */ sizeof (char[++i]); /* Size expression that doesn't affect the final size (a pointer to * an array is the same size regardless of the size of the array). * May or may not increment i! */ sizeof (char(*)[++i]);

[PHP cơ bản] Dữ liệu mảng (Array)

Mảng (Array) là gì?

Mảng là một kiểu dữ liệu mà nó có thể chứa nhiều giá trị con bên trong. Hãy tưởng tượng như một mảng là một quyển sách, mỗi trang sách bên trong là giá trị (value) được đánh số bằng số trang (key).

Để tạo mảng, chúng ta sử dụng hàm array() trong PHP (Từ PHP 5.4 trở lên bạn chỉ cần viết giá trị trong cặp dấu [] cũng được). Ví dụ bên dưới là tạo một biến hứng mảng.

01 02 03 04 05…

Your C textbook might say sizeof(int) = 2, and another might say its 4 actually! Quite confusing, and yet both are wrong. If your textbook say its either 2, 4 or something else, its either old or wrong! One way or the other, its time to look for a new book!

The C standard mentions nothing about the size of int or other primitive data types. All it does mention is a range of integers it can hold, and in case of int, -32768 to 32767, which requires 16 bits or 2 bytes minimum.

The keyword here is minimum. Int should be able to hold atleast any numbers within -32768 to 32767, or should be 2 bytes in size minimum. But compilers are free to go beyond that minimum. On 32-bit and most 64-bit systems, you shall see sizeof(int) = 4.

Lets write a simple C program.

#include <stdio.h>

int main() {

    printf(”Sizeof int = %d\n”, sizeof(int));

    printf(”Sizeof int* = %d\n”, sizeof(int*));

}

In 16-bit systems, sizeof int shall probably be 16 bits or 2 bytes. On 32-bit systems, sizeof int shall probably be 32 bits or 4 bytes. But when you run it on 64-bit systems, you might be expecting 64 bits or 8 bytes due to the word size. But chances are, sizeof int in 64 bit systems shall still be 4 bytes.

The interesting thing to note here is sizeof(int*), which is same as the word size of your processor. On 64-bit systems, sizeof(int*) = 8 bytes, and on 32-bit systems, its 4 bytes.

Another thing worth mentioning is about sizeof(long) and sizeof(short). On your system, sizeof(int), sizeof(long), sizeof(short) might have the same value. All C standard mentions is the range of values:

short: -32768 to 32767

int: -32768 to 32767

long: 2147483648 to 2147483647

All the above are signed values. Since short, int, long can be held in a 4 byte memory, chances are sizeof int, short, long shall be 4 bytes (if you are having a 64 bit system).

A couple of things to remember:

A short int must not be larger than an int.

An int must not be larger than a long int.

A short int must be at least 16 bits long.

An int must be at least 16 bits long.

A long int must be at least 32 bits long.

A long long int must be at least 64 bits long.

if you need to understand why compilers choose these sizes, have a look though: http://www.unix.org/version2/whatsnew/lp64_wp.html

But sizeof(char) is fixed and is 1 byte. If you need bigger width char types, have a look at the wide character data type - wchar_t.

C Program to Find out the size of the different data types

C Program to find the Size of Different data types. In This program we, find the size of the datatypes in c using sizeof() operator. sizeof() operator returns the its argument memory in bytes.

/*********************************************************** * Author: vinay * Copyright: www.borland-turbo-c.com * version: borland turbo c 3.0 *…

Fixed: How do I determine the size of an object in Python? #it #solution #answer

How do I determine the size of an object in Python?

In C, we can find the size of an int, char, etc. I want to know how to get size of objects like a string, integer, etc. in Python.

Related question: How many bytes per element are there in a Python list (tuple)?

I am using an XML file which contains size fields that specify the size of value. I must parse this XML and do my coding. When I want…

Fixed Why isn't sizeof for a struct equal to the sum of sizeof of each member? #dev #it #asnwer

Why isn’t sizeof for a struct equal to the sum of sizeof of each member?

Why does the ‘sizeof’ operator return a size larger for a structure than the total sizes of the structure’s members?

Answer: Why isn’t sizeof for a struct equal to the sum of sizeof of each member?

This is because of structure alignment. Structure alignmentrefers to the ability of the compiler to insert unused memory into…

How to: How to find the 'sizeof'(a pointer pointing to an array)?

How to find the ‘sizeof'(a pointer pointing to an array)?

First off, here is some code:

int main() { int days[] = {1,2,3,4,5}; int *ptr = days; printf("%u\n", sizeof(days)); printf("%u\n", sizeof(ptr)); return 0; }

Is there a way to find out the size of the array that ptr is pointing to (instead of just giving its size, which is four bytes)?

Answer: How to find the ‘sizeof'(a pointer pointing to…