The following code

    #include &lt;iostream&gt;    
    using namespace std;
    
    int main()
    {
    	const char* const foo = &quot;f&quot;;
    	const char bar[] = &quot;b&quot;;
    	cout &lt;&lt; &quot;sizeof(string literal) = &quot; &lt;&lt; sizeof( &quot;f&quot; ) &lt;&lt; endl;
    	cout &lt;&lt; &quot;sizeof(const char* const) = &quot; &lt;&lt; sizeof( foo ) &lt;&lt; endl;
    	cout &lt;&lt; &quot;sizeof(const char[]) = &quot; &lt;&lt; sizeof( bar ) &lt;&lt; endl;
    }

outputs

    sizeof(string literal) = 2
    sizeof(const char* const) = 4
    sizeof(const char[]) = 2

on a 32bit OS, compiled with GCC.

 1. Why does `sizeof` calculate the length of (the space needed for) the string literal ?
 2. Does the string literal have a different type (from char* or char[]) when given to `sizeof` ?



Sizeof string literal

Is it possible for the sizeof operator to ever return 0 (zero) in C or C++?  If it is possible, is it correct from a standards point of view?

Can sizeof return 0 (zero)

What is the return type of sizeof operator? cppreference.com &amp; msdn  says sizeof returns size_t. Does it really return a size_t?
I&#39;m using VS2010 Professional, and targeting for x64.

    int main()
    {
    	int size   = sizeof(int);     // No warning
    	int length = strlen(&quot;Expo&quot;);  //warning C4267: &#39;initializing&#39; : conversion from &#39;size_t&#39; to &#39;int&#39;, possible loss of data
    	return 0;
    }

I have this question because first line is not issuing any warning, whereas the second does. Even if I change it to char size, I don&#39;t get any warnings.

What is the return type of sizeof operator?

This program is supposed to print out the elements of `array`, but when it is run, no output is shown.

    #include &lt;stdio.h&gt;

    #define TOTAL_ELEMENTS  (sizeof(array) / sizeof(array[0]))

    int array[] = { 23, 34, 12, 17, 204, 99, 16 };

    int main() {
        int d;
        for (d = -1; d &lt;= (TOTAL_ELEMENTS - 2); d++) 
            printf(&quot;%d\n&quot;, array[d + 1]);
        return 0;
    }

Why doesn&#39;t this program show any output?


Loop starting at -1 doesn&#39;t print anything

When looking for a size of an array in a for loop I&#39;ve seen people write


    int arr[10];
    for(int i = 0; i &lt; sizeof(arr) / sizeof(arr[0]); i++){}

How is `sizeof(arr) / sizeof(arr[0])` the length of the array? How does it technically work?

How do sizeof(arr) / sizeof(arr[0]) work?

From [[5.3.3/1]](http://eel.is/c++draft/expr.sizeof#1), I found that:

&gt; The&#160;sizeof&#160;operator shall not be applied to an expression that has function or incomplete type

From [[3.9/5]](http://eel.is/c++draft/basic.types#5) I found that:

&gt; Incompletely-defined object types and&#160;cv void&#160;are&#160;incomplete types

Anyway, for `sizeof` does not evaluate it&#39;s operands, I would have said that `sizeof(void())` was a legal expression (actually GCC compiles it and the result is 1).  
On the other side, from [here](http://eel.is/c++draft/expr.sizeof), `void` is not mentioned while discussing `sizeof`, neither when the types having size 1 are mentioned, nor in the list of the ones having an _implementation defined_ size.

The question is thus: is `sizeof(void())` a legal expression?  
Is it guaranteed to have size equal to 1?  
Or is it a legal expression resulting in an UB and that&#39;s all?


Is sizeof(void()) a legal expression?

I found that both MSVC and GCC compilers allocate at least one byte per each class instance even if the class is a predicate with no member variables (or with just static member variables). The following code illustrates the point.

    #include &lt;iostream&gt;
    
    class A
    {
    public:
       bool operator()(int x) const
       {
          return x&gt;0;
       }
    };
    
    class B
    {
    public:
       static int v;
       static bool check(int x)
       {
          return x&gt;0;
       }
    };
    
    int B::v = 0;
    
    void test()
    {
       A a;
       B b;
       std::cout &lt;&lt; &quot;sizeof(A)=&quot; &lt;&lt; sizeof(A) &lt;&lt; &quot;\n&quot;
                 &lt;&lt; &quot;sizeof(a)=&quot; &lt;&lt; sizeof(a) &lt;&lt; &quot;\n&quot;
                 &lt;&lt; &quot;sizeof(B)=&quot; &lt;&lt; sizeof(B) &lt;&lt; &quot;\n&quot;
                 &lt;&lt; &quot;sizeof(b)=&quot; &lt;&lt; sizeof(b) &lt;&lt; &quot;\n&quot;;
    }
    
    int main()
    {
       test();
       return 0;
    }

Output:

    sizeof(A)=1
    sizeof(a)=1
    sizeof(B)=1
    sizeof(b)=1

My question is why does compiler need it? The only reason that I can come up with is ensure that all member var pointers differ so we can distinguish between two members of type A or B by comparing pointers to them. But the cost of this is quite severe when dealing with small-size containers. Considering possible data alignment, we can get up to 16 bytes per class without vars (?!). Suppose we have a custom container that will typically hold a few int values. Then consider an array of such containers (with about 1000000 members). The overhead will be 16*1000000! A typical case where it can happen is a container class with a comparison predicate stored in a member variable. Also, considering that a class instance should always occupy some space, what type of overhead should be expected when calling A()(value) ?

Why do C++ classes without member variables occupy space?

What is the sizeof the union in C/C++? Is it the sizeof the largest datatype inside it? If so, how does the compiler calculate how to move the stack pointer if one of the smaller datatype of the union is active?

sizeof a union in C/C++

Suppose I have a base class with some member variables and no virtual functions:


    class Base {
       int member;
    };

and a derived class that derives in a non-virtual way from `Base` and has no new member variables an again no virtual functions:

    class Derived : Base {
    };

Obviously `sizeof(Derived)` can&#39;t be smaller than `sizeof(Base)`.

Is `sizeof(Derived)` required to be equal to `sizeof(Base)`?

Is C++ allowed to increase the derived class size if there&#39;re no new member variables compared to the base class?

For example:
`sizeof(char*)` returns 4.  As does `int*`, `long long*`, everything that I&#39;ve tried.  Are there any exceptions to this?

Is the sizeof(some pointer) always equal to four?

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)?][1]

  [1]: https://stackoverflow.com/questions/135664/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 to change the value of a particular field, I will check the size field of that value. Here I want to compare whether the new value that I&#39;m gong to enter is of the same size as in XML. I need to check the size of new value. In case of a string I can say its the length. But in case of int, float, etc. I am confused.

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

Why does the `sizeof` operator return a size larger for a structure than the total sizes of the structure&#39;s members?

Why isn&#39;t sizeof for a struct equal to the sum of sizeof of each member?

I have a small piece of code about the `sizeof` operator with the ternary operator:

    #include &lt;stdio.h&gt;
    #include &lt;stdbool.h&gt;

    int main()
    {
        bool a = true;
        printf(&quot;%zu\n&quot;, sizeof(bool));  // Ok
        printf(&quot;%zu\n&quot;, sizeof(a));     // Ok
        printf(&quot;%zu\n&quot;, sizeof(a ? true : false)); // Why 4?
        return 0;
    }

**Output ([GCC][1]):**

    1
    1
    4 // Why 4?

But here,

    printf(&quot;%zu\n&quot;, sizeof(a ? true : false)); // Why 4?

the ternary operator returns `boolean` type and sizeof `bool` type is `1` byte in C. 

Then **why does `sizeof(a ? true : false)` give an output of four bytes?**

  [1]: http://ide.geeksforgeeks.org/NE9Cfo
  [2]: https://msdn.microsoft.com/en-us/library/e4213hs1.aspx


Why does &quot;sizeof(a ? true : false)&quot; give an output of four bytes?

I can&#39;t find an answer in the standard documentation. Does the C++ language standard require `sizeof(bool)` to always be 1 (for 1 byte), or is this size implementation-defined?

Is sizeof(bool) defined in the C++ language standard?

Why does this code compile?

    _Static uint32_t my_arr[2];
    _Static_assert(sizeof(my_arr) == 8, &quot;&quot;);
    _Static_assert(sizeof(my_arr[0]) == 4, &quot;&quot;);
    _Static_assert(sizeof(my_arr)[0] == 4, &quot;&quot;);

The first 2 asserts are obviously correct, but I would have expected the last line to fail, as my understanding is that `sizeof()` should evaluate to an integer literal, which can&#39;t be treated as an array. In other words, it would fail in the same way that the following line fails:

    _Static_assert(4[0] == 4, &quot;&quot;);

Interestingly, the following does indeed fail to compile (which should be doing the same thing, no?):

    _Static_assert(*sizeof(my_arr) == 4, &quot;&quot;);

&gt; error: invalid type argument of unary &#39;*&#39; (have &#39;long unsigned int&#39;) 
&gt; _Static_assert(*sizeof(my_arr) == 4, &quot;&quot;);

If it matters, I&#39;m using gcc 5.3.0

Why does sizeof(my_arr)[0] compile and equal sizeof(my_arr[0])?

I am trying to declare a struct that is dependent upon another struct.
I want to use `sizeof` to be safe/pedantic.

    typedef struct _parent
    {
      float calc ;
      char text[255] ;
      int used ;
    } parent_t ;

Now I want to declare a struct `child_t` that has the same size as `parent_t.text`.

How can I do this?  (Pseudo-code below.)

    typedef struct _child
    {
      char flag ;
      char text[sizeof(parent_t.text)] ;
      int used ;
    } child_t ;

I tried a few different ways with `parent_t` and `struct _parent`, but my compiler will not accept.

As a trick, this seems to work:

    parent_t* dummy ;
    typedef struct _child
    {
      char flag ;
      char text[sizeof(dummy-&gt;text)] ;
      int used ;
    } child_t ;

Is it possible to declare `child_t` without the use of `dummy`?

sizeof single struct member in C

If I use `malloc` in my code:

    int *x = malloc(sizeof(int));

I get this warning from `gcc`:

    new.c:7: warning: implicit declaration of function ‘malloc’  
    new.c:7: warning: incompatible implicit declaration of built-in function ‘malloc’


Why do I get a warning every time I use malloc?

Why isn&#39;t the size of an array sent as a parameter the same as within main?

    #include &lt;stdio.h&gt;

    void PrintSize(int p_someArray[10]);

    int main () {
    	int myArray[10];
    	printf(&quot;%d\n&quot;, sizeof(myArray)); /* As expected, 40 */
    	PrintSize(myArray);/* Prints 4, not 40 */
    }

    void PrintSize(int p_someArray[10]){
    	printf(&quot;%d\n&quot;, sizeof(p_someArray));
    }


Why isn&#39;t the size of an array parameter the same as within main?

In C++, `sizeof(&#39;a&#39;) == sizeof(char) == 1`. This makes intuitive sense, since `&#39;a&#39;` is a character literal, and `sizeof(char) == 1` as defined by the standard.&lt;br&gt;

In C however, `sizeof(&#39;a&#39;) == sizeof(int)`. That is, it appears that C character literals are actually integers. Does anyone know why? I can find plenty of mentions of this C quirk but no explanation for why it exists.

Why are C character literals ints instead of chars?

Here is the code compiled in dev c++ windows:

    #include &lt;stdio.h&gt;
    
    int main() {
        int x = 5;
        printf(&quot;%d and &quot;, sizeof(x++)); // note 1
        printf(&quot;%d\n&quot;, x); // note 2
        return 0;
    }

I expect `x` to be 6 after executing **note 1**. However, the output is:

    4 and 5

Can anyone explain why `x` does not increment after **note 1**?

Why does sizeof(x++) not increment x?

Are there machines (or compilers), where `sizeof(char) != 1`?

Does **C99 standard** says that `sizeof(char)` on standard compliance implementation MUST be exactly 1? If it does, please, give me section number and citation.

*Update:*
If I have a machine (CPU), which can&#39;t address bytes (minimal read is 4 bytes, aligned), but only 4-s of bytes (`uint32_t`), &lt;strike&gt;can compiler for this machine define `sizeof(char)` to 4?&lt;/strike&gt; *`sizeof(char)` will be 1, but char will have 32 bits* (`CHAR_BIT` macros)

*Update2:* 
But sizeof result is NOT a BYTES ! it is the size of CHAR. And char can be 2 byte, or (may be) 7 bit?

*Update3:*
Ok. All machines have `sizeof(char) == 1`. But what machines have `CHAR_BIT &gt; 8` ?

Are there machines, where sizeof(char) != 1, or at least CHAR_BIT &gt; 8?

Why is `sizeof` considered an operator and not a function?

What property is necessary to qualify as an operator?


Why is sizeof considered an operator?

We know that `sizeof` is an operator used for calculating the size of any datatype and expression, and when the operand is an expression, the parentheses can be omitted.

    int main()
    {
            int a;
    
            sizeof int;
            sizeof( int );
            sizeof a;
            sizeof( a );
    
            return 0;
    }

the first usage of `sizeof` is wrong, while others are right.

When it is compiled using gcc, the following error message will be given:

    main.c:5:9: error: expected expression before ‘int’

My question is why the C standard does not allow this kind of operation. Will `sizeof int` cause any ambiguity? 

Why sizeof int is wrong, while sizeof(int) is right?

&gt; **Possible Duplicate:**  
&gt; [C++: What is the size of an object of an empty class?](https://stackoverflow.com/questions/621616/c-what-is-the-size-of-an-object-of-an-empty-class)  

&lt;!-- End of automatically inserted text --&gt;

Why does the following output `1`?
    
    #include &lt;iostream&gt;

    class Test
    {
    };
    
    int main()
    {
    	std::cout &lt;&lt; sizeof(Test);
    	return 0;
    }

Why is the size of an empty class in C++ not zero?

I am working with the memory of some lambdas in C++, but I am a bit puzzled by their size. 

Here is my test code: 

    #include &lt;iostream&gt;
    #include &lt;string&gt;

    int main()
    {
      auto f = [](){ return 17; };
      std::cout &lt;&lt; f() &lt;&lt; std::endl;
      std::cout &lt;&lt; &amp;f &lt;&lt; std::endl;
      std::cout &lt;&lt; sizeof(f) &lt;&lt; std::endl;
    }

The ouptut is:

    17
    0x7d90ba8f626f
    1

This suggests that the size of my lambda is 1. 

 * How is this possible? 

 * Shouldn&#39;t the lambda be, at minimum, a pointer to its implementation? 

Why does a lambda have a size of 1 byte?

When we check the size of a function using `sizeof()`, we always get **1 byte**.
What does this 1 byte signify?

Why is the size of a function in C always 1 byte?

The below fails to compile:

    typedef int arr[10];
    int main(void) {
    	return sizeof arr;
    }

    sizeof.c:3: error: expected expression before ‘arr’
but if I change it to

    sizeof(arr);
everything is fine. Why?

Why (and when) do I need to use parentheses after sizeof?

&gt; **Possible Duplicate:**  
&gt; [size of int, long, etc](https://stackoverflow.com/questions/589575/size-of-int-long-etc)  
&gt; [Does the size of an int depend on the compiler and/or processor?](https://stackoverflow.com/questions/2331751/does-the-size-of-an-int-depend-on-the-compiler-and-or-processor)  
&gt; [What decides the sizeof an integer?](https://stackoverflow.com/questions/9689049/what-decides-the-sizeof-an-integer)  

&lt;!-- End of automatically inserted text --&gt;

I&#39;m using a `64-bit` machine.

    $ uname -m
    x86_64
    $ file /usr/bin/file
    /usr/bin/file: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, stripped
    $ 

When I ran the following program, I got the `sizeof(int)` as `4-bytes`.

    #include &lt;stdio.h&gt;
    
    int main(void)
    {
        printf(&quot;sizeof(int) = %d bytes\n&quot;, (int) sizeof(int));
    
        return 0;
    }

If I&#39;m running a `16-`, `32-` and `64-` bit machine, then doesn&#39;t it mean that the size of an `integer` is `16-`, `32-` and `64-` bit respectively?

In my machine, I found the `WORD_BIT` is `32`. Shouldn&#39;t it be `64` on a `64-bit` machine? 

    $ getconf WORD_BIT
    32
    $ 

And, shouldn&#39;t the `sizeof(int)` be `64-bits` (`8 bytes`) in the above case?

What should be the sizeof(int) on a 64-bit machine?

What would this statement yield?

    void *p = malloc(sizeof(void));


----------


Edit: An extension to the question. 

If sizeof(void) yields 1 in GCC compiler, then 1 byte of memory is allocated and the pointer p points to that byte and would p++ be incremented to 0x2346? Suppose p was 0x2345. I am talking about p and not *p.


What is the size of void?

There is an old post asking for a construct for which `sizeof` would return `0`. There are some high score answers from high reputation users saying that by the standard no type or variable can have sizeof 0. And I agree 100% with that.

However there is [this new answer][1] which presents this solution:

    struct ZeroMemory {
        int *a[0];
    };

I was just about to down-vote and comment on it, but time spent here taught me to check even the things that I am 100% sure on. So... to my surprise both `gcc` and `clang` show the same results: `sizeof(ZeroMemory) == 0`. Even more, sizeof a variable is `0`:

    ZeroMemory z{};
    static_assert(sizeof(z) == 0); // Awkward...

Whaaaat...?

[Godbolt link][2]

How is this possible?

  [1]: https://stackoverflow.com/a/47352302/2805305
  [2]: https://godbolt.org/g/hyVr9u


How can this structure have sizeof == 0?

How can I print the result of sizeof() at compile time in C?

For now I am using a static assert (home brewed based on other web resources) to compare the sizeof() result to various constants.  While this works...  it is far from elegant or fast.  I can also create an instance of the variable/struct and look in the map file but this is also less elegant and fast than a direct call/command/operator.  Further, this is an embedded project using multiple cross-compilers...  so building and loading a sample program to the target and then reading out a value is even more of a hassle than either of the above.

In my case (old GCC), `#warning sizeof(MyStruct)` does not actually interpret sizeof() before printing the warning.

How can I print the result of sizeof() at compile time in C?

For example result of this code snippet depends on which machine: the compiler machine or the machine executable file works?

    sizeof(short int)



Is sizeof in C++ evaluated at compilation time or run time?

I want to know the size occupied by a JavaScript object.

Take the following function:

    function Marks(){
      this.maxMarks = 100;
    }
    
    function Student(){
      this.firstName = &quot;firstName&quot;;
      this.lastName = &quot;lastName&quot;;
      this.marks = new Marks();
    }

Now I instantiate the `student`:

    var stud = new Student();

so that I can do stuff like

    stud.firstName = &quot;new Firstname&quot;;
    
    alert(stud.firstName);
    
    stud.marks.maxMarks = 200;

etc.

Now, the `stud` object will occupy some size in memory. It has some data and more objects.

How do I find out how much memory the `stud` object occupies? Something like a `sizeof()` in JavaScript? It would be really awesome if I could find it out in a single function call like `sizeof(stud)`.

I’ve been searching the Internet for months—couldn’t find it (asked in a couple of forums—no replies).

How to get the size of a JavaScript object?

Is the size of a pointer the same as the size as the type it&#39;s pointing to, or do pointers always have a fixed size?  For example...

    int x = 10;
    int * xPtr = &amp;x;
    char y = &#39;a&#39;;
    char * yPtr = &amp;y;

    std::cout &lt;&lt; sizeof(x) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; sizeof(xPtr) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; sizeof(y) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; sizeof(yPtr) &lt;&lt; &quot;\n&quot;;

What would the output of this be?  Would `sizeof(xPtr)` return 4 and `sizeof(yPtr)` return 1, or would the 2 pointers actually return the same size?

The reason I ask this is because the pointers are storing a memory address and not the values of their respective stored addresses.





What is the size of a pointer?

This is a C++ interview test question not homework. 

    #include &lt;iostream&gt;
    using namespace std;
    enum months_t { january, february, march, april, may, june, july, august, september,    
      october, november, december} y2k;

     int main ()
      {
        cout &lt;&lt; &quot;sizeof months_t is  &quot; &lt;&lt; sizeof(months_t) &lt;&lt; endl;
        cout &lt;&lt; &quot;sizeof y2k is  &quot; &lt;&lt; sizeof(y2k) &lt;&lt; endl;
        enum months_t1 { january, february, march, april, may, june, july, august,    
           september, october, november, december} y2k1;
        cout &lt;&lt; &quot;sizeof months_t1 is  &quot; &lt;&lt; sizeof(months_t1) &lt;&lt; endl;
        cout &lt;&lt; &quot;sizeof y2k1 is  &quot; &lt;&lt; sizeof(y2k1) &lt;&lt; endl;
     }

Output:
&gt; sizeof months_t is  4  
&gt; sizeof y2k is  4  
&gt; sizeof months_t1 is  4  
&gt; sizeof y2k1 is  4  

Why is the size of all of these 4 bytes? Not 12 x 4 = 48 bytes?  
I know union elements occupy the same memory location, but this is an enum.


what is the size of an enum type data in C++?

Given the following program,

    #include &lt;iostream&gt;
    
    using namespace std;
    
    void foo( char a[100] )
    {
        cout &lt;&lt; &quot;foo() &quot; &lt;&lt; sizeof( a ) &lt;&lt; endl;
    }
    
    int main()
    {
        char bar[100] = { 0 };
        cout &lt;&lt; &quot;main() &quot; &lt;&lt; sizeof( bar ) &lt;&lt; endl;
        foo( bar );
        return 0;
    }

outputs

    main() 100
    foo() 4

 1. Why is the array passed as a pointer to the first element?
 2. Is it a heritage from C?
 3. What does the standard say?
 4. Why is the strict type-safety of C++ dropped?


When a function has a specific-size array parameter, why is it replaced with a pointer?

I have an `int` array and I need to find the number of elements in it. I know it has something to do with `sizeof` but I&#39;m not sure how to use it exactly.

How can I find the number of elements in an array?

First off, here is some code:

    int main() 
    {
        int days[] = {1,2,3,4,5};
        int *ptr = days;
        printf(&quot;%u\n&quot;, sizeof(days));
        printf(&quot;%u\n&quot;, 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 on a 32-bit system)? 


How to find the &#39;sizeof&#39; (a pointer pointing to an array)?

The C standard allows pointers to different types to have different sizes, e.g. `sizeof(char*) != sizeof(int*)` is permitted.  It does, however, require that if a pointer is converted to a `void*` and then converted back to its original type, it must compare as equal to its original value.  Therefore, it follows logically that `sizeof(void*) &gt;= sizeof(T*)` for all types `T`, correct?

On most common platforms in use today (x86, PPC, ARM, and 64-bit variants, etc.), the size of all pointers equals the native register size (4 or 8 bytes), regardless of the pointed-to type.  Are there any esoteric or embedded platforms where pointers to different types might have different sizes?  I&#39;m specifically asking about *data* pointers, although I&#39;d also be interested to know if there are platforms where *function* pointers have unusual sizes.

I&#39;m definitely *not* asking about C++&#39;s pointer-to-members and pointer-to-member-functions.  Those take on unusual sizes on common platforms, and can even vary within one platform, depending on the properties of the pointer-to class (non-polymorphic, single inheritance, multiple inheritance, virtual inheritance, or incomplete type).

Are there any platforms where pointers to different types have different sizes?

I do not understand why the `sizeof` operator is producing the following results:

    sizeof( 2500000000 ) // =&gt; 8 (8 bytes).

... it returns 8, and when I do the following:

    sizeof( 1250000000 * 2 ) // =&gt; 4 (4 bytes).

... it returns 4, rather than 8 (which is what I expected). Can someone clarify how `sizeof` determines the size of an expression (or data type) and why in my specific case this is occurring?

My best guess is that the `sizeof` operator is a compile-time operator.

**Bounty Question:** Is there a run time operator that can evaluate these expressions and produce my expected output (without casting)?

In C, sizeof operator returns 8 bytes when passing 2.5m but 4 bytes when passing 1.25m * 2

What&#39;s the difference between sizeof and alignof?

    #include &lt;iostream&gt;

    #define SIZEOF_ALIGNOF(T) std::cout&lt;&lt; sizeof(T) &lt;&lt; &#39;/&#39; &lt;&lt; alignof(T) &lt;&lt; std::endl
    
    int main(int, char**)
    {
            SIZEOF_ALIGNOF(unsigned char);
            SIZEOF_ALIGNOF(char);
            SIZEOF_ALIGNOF(unsigned short int);
            SIZEOF_ALIGNOF(short int);
            SIZEOF_ALIGNOF(unsigned int);
            SIZEOF_ALIGNOF(int);
            SIZEOF_ALIGNOF(float);
            SIZEOF_ALIGNOF(unsigned long int);
            SIZEOF_ALIGNOF(long int);
            SIZEOF_ALIGNOF(unsigned long long int);
            SIZEOF_ALIGNOF(long long int);
            SIZEOF_ALIGNOF(double);
    }

will output

1/1
1/1
2/2
2/2
4/4
4/4
4/4
4/4
4/4
8/8
8/8
8/8

I think I don&#39;t get what the alignment is...?

What&#39;s the difference between sizeof and alignof?

Can someone explain how this code works? I know that the purpose of this code is to get the length of an array, but I don&#39;t know how this code works:

    template&lt;typename T, int size&gt;
    int GetArrLength(T(&amp;)[size]){return size;}

How does this &quot;size of array&quot; template function work?

Assuming you&#39;re using a compiler that supports C99 (or even just stdint.h), is there any reason not to use fixed-width integer types such as uint8_t?

One reason that I&#39;m aware of is that it makes much more sense to use `char`s when dealing with characters instead of using `(u)int8_t`s, as mentioned in [this question][1].

But if you are planning on storing a number, when would you want to use a type that you don&#39;t know how big it is? I.e. In what situation would you want to store a number in an `unsigned short` without knowing if it is 8, 16, or even 32 bits, instead of using a `uint16t`?

Following on from this, is it considered better practice to use fixed-width integers, or to use the normal integer types and just never assume anything and use `sizeof` wherever you need to know how many bytes they are using?


  [1]: https://stackoverflow.com/questions/1725855/uint8-t-vs-unsigned-char

Is there any reason not to use fixed width integer types (e.g. uint8_t)?

On a 64-bit system, `sizeof(unsigned long)` depends on the data model implemented by the system, for example, it is 4 bytes on LLP64 (Windows), 8 bytes on LP64 (Linux, etc.).  What&#39;s `sizeof(size_t)` supposed to be?  Does it vary with data model like `sizeof(long)` does?  If so, how?


----------

References:

[64-bit data models on Wikipedia][1]


  [1]: http://en.wikipedia.org/wiki/64-bit#64-bit_data_models &quot;64-bit computing, 64-bit data models. On Wikipedia.&quot;

What&#39;s sizeof(size_t) on 32-bit vs the various 64-bit data models?

I&#39;m trying to use 64 bit integers in C, but am getting mixed signals as to whether it should be possible.

When I execute the printf:

    printf(&quot;Size of long int:%d\nSize of long long int:%d\n\n&quot;,(int)sizeof(long int), (int)sizeof(long long int));

The response I get is:

Size of long int:4
Size of long long int:8

This makes me feel that a long long int has 8 bytes = 64 bits.

However, when I try to declare the following variables:

    long long int a2 = 0x00004444;
    long long int b2 = 0x000044440;
    long long int c2 = 0x0000444400;
    long long int d2 = 0x00004444000;
    long long int e2 = 0x000044440000;
    long long int f2 = 0x0000444400004;
    long long int g2 = 0x00004444000044;
    long long int h2 = 0x000044440000444;
    long long int i2 = 0x0000444400004444;

The last 4 variables (f2,g2,h2,i2) give me the error message:  

warning: integer constant is too large for ‘long’ type 

I get the same result when I replace &#39;long long int&#39; with &#39;int64_t&#39;. I assume &#39;int64_t&#39; was recognized, since it didn&#39;t generate any error messages of its own.

So, it appears my 8 byte long long int is really a 6 byte long long int, and I don&#39;t understand what I&#39;m missing here. If it&#39;s any help, here is the information on my gcc compiler:
 

    me@ubuntu:~$ gcc -v  
    Using built-in specs.  
    Target: i686-linux-gnu  
    Configured with: ../src/configure -v   
    --with-pkgversion=&#39;Ubuntu/Linaro 4.4.4-14ubuntu5&#39;  
    --with-bugurl=file:///usr/share/doc/gcc-4.4/README.Bugs   
    --enable-languages=c,c++,fortran,objc,obj-c++  
    --prefix=/usr   
    --program-suffix=-4.4   
    --enable-shared   
    --enable-multiarch   
    --enable-linker-build-id   
    --with-system-zlib   
    --libexecdir=/usr/lib   
    --without-included-gettext   
    --enable-threads=posix   
    --with-gxx-include-dir=/usr/include/c++/4.4   
    --libdir=/usr/lib   
    --enable-nls   
    --with-sysroot=/ -  
    -enable-clocale=gnu   
    --enable-libstdcxx-debug   
    --enable-objc-gc   
    --enable-targets=all 
    --disable-werror   
    --with-arch-32=i686   
    --with-tune=generic   
    --enable-checking=release   
    --build=i686-linux-gnu   
    --host=i686-linux-gnu   
    --target=i686-linux-gnu  
    Thread model: posix  
    gcc version 4.4.5 (Ubuntu/Linaro 4.4.4-14ubuntu5)   

If anyone knows how (or if) 64 bit integers are accessible to me, I&#39;d really appreciate any help. Thanks....







All Sizeof Solutions on Gang of Coders

Total of 45 Sizeof Solutions