Size of a pointer should be 8 byte on any 64-bit C/C++ compiler, but not necessarily size of int.

Doesn&#39;t have to be; &quot;64-bit machine&quot; can mean many things, but typically means that the CPU has registers that big.  The sizeof a type is determined by the compiler, which doesn&#39;t have to have anything to do with the actual hardware (though it typically does); in fact, different compilers on the same machine can have different values for these.

Not really. for backward compatibility it is 32 bits.  
If you want 64 bits you have `long`, `size_t` or `int64_t`

In C++, the size of `int` isn&#39;t specified explicitly. It just tells you that it must be at least the size of `short int`, which must be at least as large as `signed char`. The size of `char` in bits isn&#39;t specified explicitly either, although sizeof(char) is defined to be 1. If you want a 64 bit int, C++11 specifies `long long` to be at least 64 bits.

Been looking around on the web for one of these, but I&#39;m only finding node.js/ruby hosted implementations.

I&#39;m keen to have a DynamoDB app, something like that of the navicat ilk that comes with an msi installer to get running quickly.

Maybe there&#39;s a valid reason as to why one of these doesn&#39;t exist yet?

Amazon AWS DynamoDB Desktop Client - Does one exist?

I have an application in which I need to implement image editing, which also includes pinch zooming. I am done with pinch zooming but I can test this only on device, not on emulator. 

Is there any way for testing pinch zooming in android emulator, any shortcut key or any other way?



How to pinch zoom on Android emulator?

&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?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/589575/size-of-int-long-etc" target="_blank" rel="noopener noreferrer">size of int, long, etc</a> 
> <a href="https://stackoverflow.com/questions/2331751/does-the-size-of-an-int-depend-on-the-compiler-and-or-processor" target="_blank" rel="noopener noreferrer">Does the size of an int depend on the compiler and/or processor?</a> 
> <a href="https://stackoverflow.com/questions/9689049/what-decides-the-sizeof-an-integer" target="_blank" rel="noopener noreferrer">What decides the sizeof an integer?</a>

I'm using a <code>64-bit</code> machine.
<pre><code class="hljs language-shell">$ 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
$ 
</code></pre>
When I ran the following program, I got the <code>sizeof(int)</code> as <code>4-bytes</code>.
<pre><code class="hljs language-c">#include &#x3C;stdio.h>

int main(void)
{
 printf("sizeof(int) = %d bytes\n", (int) sizeof(int));

 return 0;
}
</code></pre>
If I'm running a <code>16-</code>, <code>32-</code> and <code>64-</code> bit machine, then doesn't it mean that the size of an <code>integer</code> is <code>16-</code>, <code>32-</code> and <code>64-</code> bit respectively?
In my machine, I found the <code>WORD_BIT</code> is <code>32</code>. Shouldn't it be <code>64</code> on a <code>64-bit</code> machine?
<pre><code class="hljs language-ruby">$ getconf WORD_BIT
32
$ 
</code></pre>
And, shouldn't the <code>sizeof(int)</code> be <code>64-bits</code> (<code>8 bytes</code>) in the above case?

In C++, if a constructor throws an exception, what destructors are run?

In particular, does it make any difference if the exception is during the initialization list or the body?

Also, what about inheritance and members?  Presumably all completed constructions get destructed.  If only some members are constructed, do only those get destructed?  If there is multiple inheritance, do all completed constructors get destructed?  Does virtual inheritance change anything?

What destructors are run when the constructor throws an exception?

I&#39;m trying to do something very simple and yet, after an hour of so of searching a I can&#39;t find a suitable answer so I must be missing something fairly obvious.

I&#39;m trying to dynamically create filenames for use with ifstream. Whilst I understand various methods are available of doing this, I have settled on creating a std::string, and the using stringname.c_str to convert to const.

The problem is however that I need to create the string with a mix of variables and predefined text values. I&#39;m getting compiler errors, so this must be a syntax issue.

Pseudo 

    std::string var = &quot;sometext&quot; + somevar + &quot;sometext&quot; + somevar;

Thanks!

C++ create string of text and variables

I heard a recent talk by Herb Sutter who suggested that the reasons to pass `std::vector` and `std::string` by `const &amp;` are largely gone.  He suggested that writing a function such as the following is now preferable:

    std::string do_something ( std::string inval )
    {
       std::string return_val;
       // ... do stuff ...
       return return_val;
    }

I understand that the `return_val` will be an rvalue at the point the function returns and can therefore be returned using move semantics, which are very cheap.  However, `inval` is still much larger than the size of a reference (which is usually implemented as a pointer).  This is because a `std::string` has various components including a pointer into the heap and a member `char[]` for short string optimization.  So it seems to me that passing by reference is still a good idea.

Can anyone explain why Herb might have said this?

Are the days of passing const std::string &amp; as a parameter over?

Can I initialize an STL vector with 10 of the same integer in an initializer list?  My attempts so far have failed me.

Can I initialize an STL vector with 10 of the same integer in an initializer list?

Under which circumstances would you want to use code of this nature in c++?

    void foo(type *&amp;in) {...}
    
    void fii() {
      type *choochoo;
      ...
      foo(choochoo);
    }

Reason to Pass a Pointer by Reference in C++?

I am exploring python. I curious about python bindings. Could anybody explain, how it is possible that you can have access to C libraries from Python.

python bindings, how does it work?

While writing an optimized `ftol` function I found some very odd behaviour in `GCC 4.6.1`. Let me show you the code first (for clarity I marked the differences):

fast_trunc_one, C:

    int fast_trunc_one(int i) {
        int mantissa, exponent, sign, r;
    
        mantissa = (i &amp; 0x07fffff) | 0x800000;
        exponent = 150 - ((i &gt;&gt; 23) &amp; 0xff);
        sign = i &amp; 0x80000000;
    
        if (exponent &lt; 0) {
            r = mantissa &lt;&lt; -exponent;                       /* diff */
        } else {
            r = mantissa &gt;&gt; exponent;                        /* diff */
        }
    
        return (r ^ -sign) + sign;                           /* diff */
    }
    
fast_trunc_two, C:

    int fast_trunc_two(int i) {
        int mantissa, exponent, sign, r;
    
        mantissa = (i &amp; 0x07fffff) | 0x800000;
        exponent = 150 - ((i &gt;&gt; 23) &amp; 0xff);
        sign = i &amp; 0x80000000;
    
        if (exponent &lt; 0) {
            r = (mantissa &lt;&lt; -exponent) ^ -sign;             /* diff */
        } else {
            r = (mantissa &gt;&gt; exponent) ^ -sign;              /* diff */
        }
    
        return r + sign;                                     /* diff */
    }

Seems the same right? Well GCC disagrees. After compiling with `gcc -O3 -S -Wall -o test.s test.c` this is the assembly output:

fast_trunc_one, generated:

    _fast_trunc_one:
    LFB0:
    	.cfi_startproc
    	movl	4(%esp), %eax
    	movl	$150, %ecx
    	movl	%eax, %edx
    	andl	$8388607, %edx
    	sarl	$23, %eax
    	orl	$8388608, %edx
    	andl	$255, %eax
    	subl	%eax, %ecx
    	movl	%edx, %eax
    	sarl	%cl, %eax
    	testl	%ecx, %ecx
    	js	L5
    	rep
    	ret
    	.p2align 4,,7
    L5:
    	negl	%ecx
    	movl	%edx, %eax
    	sall	%cl, %eax
    	ret
    	.cfi_endproc

fast_trunc_two, generated:
    
    _fast_trunc_two:
    LFB1:
    	.cfi_startproc
    	pushl	%ebx
    	.cfi_def_cfa_offset 8
    	.cfi_offset 3, -8
    	movl	8(%esp), %eax
    	movl	$150, %ecx
    	movl	%eax, %ebx
    	movl	%eax, %edx
    	sarl	$23, %ebx
    	andl	$8388607, %edx
    	andl	$255, %ebx
    	orl	$8388608, %edx
    	andl	$-2147483648, %eax
    	subl	%ebx, %ecx
    	js	L9
    	sarl	%cl, %edx
    	movl	%eax, %ecx
    	negl	%ecx
    	xorl	%ecx, %edx
    	addl	%edx, %eax
    	popl	%ebx
    	.cfi_remember_state
    	.cfi_def_cfa_offset 4
    	.cfi_restore 3
    	ret
    	.p2align 4,,7
    L9:
    	.cfi_restore_state
    	negl	%ecx
    	sall	%cl, %edx
    	movl	%eax, %ecx
    	negl	%ecx
    	xorl	%ecx, %edx
    	addl	%edx, %eax
    	popl	%ebx
    	.cfi_restore 3
    	.cfi_def_cfa_offset 4
    	ret
    	.cfi_endproc

That&#39;s an __extreme__ difference. This actually shows up on the profile too, `fast_trunc_one` is around 30% faster than `fast_trunc_two`. Now my question: what is causing this?

Why does GCC generate such radically different assembly for nearly the same C code?

if i am defining such function in java file

      /** 
       * Adds two integers, returning their sum
       */
      public native int add( int v1, int v2 );

so i need to code in c file 


    JNIEXPORT jint JNICALL Java_com_marakana_NativeLib_add
      (JNIEnv * env, jobject obj, jint value1, jint value2) {

      printf(&quot;\n this is log messge \n&quot;);

    		return (value1 + value2);
    }

then from where this  printf will print it message ? 
In logcate i dont get it?


How can i debug any NDK application by putting log messages?

How to get &quot;printf&quot; messages written in NDK application?

How do I append a single char to a string in C?

i.e 
 
    char* str = &quot;blablabla&quot;;
    char c = &#39;H&#39;;
    str_append(str,c); /* blablablaH */
 

Append Char To String in C?

I read here [Learn C Before Objective-C?](https://stackoverflow.com/questions/180549/learn-c-first-before-learning-objective-c)

&gt;Usually I then replace some Obj-C code with pure C code (after all you can mix them as much as you like, the content of an Obj-C method can be entirely, pure C code)

Is this true? 

Is it possible to build an iPhone app purely in the C programming language?

How to write iOS app purely in C

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?

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?

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?

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?

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

Content Type	Original Author	Original Content on Stackoverflow
Question	Sangeeth Saravanaraj	View Question on Stackoverflow
Solution 1 - C++	Eugene	View Answer on Stackoverflow
Solution 2 - C++	Scott Hunter	View Answer on Stackoverflow
Solution 3 - C++	Dani	View Answer on Stackoverflow
Solution 4 - C++	juanchopanza	View Answer on Stackoverflow

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

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

How to pinch zoom on Android emulator?

Amazon AWS DynamoDB Desktop Client - Does one exist?

Attributions