This construct specifies the length in bits for each field.

The advantage of this is that you can control the `sizeof(op)`, if you&#39;re careful. the size of the structure will be the sum of the sizes of the fields inside.

In your case, size of op is 32 bits (that is, `sizeof(op)` is 4).

The size always gets rounded up to the next multiple of 8 for every group of unsigned xxx:yy; construct.

That means:

    struct A
    {
        unsigned a: 4;    //  4 bits
        unsigned b: 4;    // +4 bits, same group, (4+4 is rounded to 8 bits)
        unsigned char c;  // +8 bits
    };
    //                    sizeof(A) = 2 (16 bits)

    struct B
    {
        unsigned a: 4;    //  4 bits
        unsigned b: 1;    // +1 bit, same group, (4+1 is rounded to 8 bits)
        unsigned char c;  // +8 bits
        unsigned d: 7;    // + 7 bits
    };
    //                    sizeof(B) = 3 (4+1 rounded to 8 + 8 + 7 = 23, rounded to 24)

I&#39;m not sure I remember this correctly, but I think I got it right.

It declares a [bit field][1]; the number after the colon gives the length of the field in bits (i.e., how many bits are used to represent it).

  [1]: http://en.wikipedia.org/wiki/Bit_field

    unsigned op_type:9;

Means op_type is an integer variable with 9 bits.

The colon modifier on integral types specifies how many bits the int should take up.

I have a Python script that I&#39;d like to compile into a Windows executable. Now, `py2exe` works fine from Windows, but I&#39;d like to be able to run this from Linux. I _do_ have Windows on my development machine, but Linux is my primary dev platform and I&#39;m getting kind of sick of rebooting into Windows just to create the `.exe`. Nor do I want to have to buy a second Windows license to run in a virtual machine such as VirtualBox. Any ideas?

PS: I am aware that `py2exe` doesn&#39;t exactly compile the python file as much as package your script with the Python interpreter. But either way, the result is that you don&#39;t need Python installed to run the script.

Packaging a Python script on Linux into a Windows executable

Trying to simply close an infowindow?

I already have an array of markers, so something like this would be good. Thanks

    MyMarkers[i].infowindow.close();



Google Map API v3 ~ Simply Close an infowindow?

&gt; **Possible Duplicate:**  
&gt; [What does this C++ code mean?](https://stackoverflow.com/questions/1604968/what-does-this-c-code-mean)  

&lt;!-- End of automatically inserted text --&gt;

I&#39;m trying to map a C structure to Java using JNA. I came across something that I&#39;ve never seen.

The `struct` definition is as follows:

    struct op 
    {
        unsigned op_type:9;  //---&gt; what does this mean? 
        unsigned op_opt:1; 
        unsigned op_latefree:1; 
        unsigned op_latefreed:1; 
        unsigned op_attached:1; 
        unsigned op_spare:3; 
        U8 op_flags; 
        U8 op_private;
    };

You can see some variable being defined like `unsigned op_attached:1` and I&#39;m unsure what would that mean. Would that effect the number of bytes to be allocated for this particular variable?

What does &#39;unsigned temp:3&#39; in a struct or union mean?

> Possible Duplicate: 
> <a href="https://stackoverflow.com/questions/1604968/what-does-this-c-code-mean" target="_blank" rel="noopener noreferrer">What does this C++ code mean?</a>

I'm trying to map a C structure to Java using JNA. I came across something that I've never seen.
The <code>struct</code> definition is as follows:
<pre><code class="hljs language-ini">struct op 
{
 unsigned op_type:9; //---> what does this mean? 
 unsigned op_opt:1; 
 unsigned op_latefree:1; 
 unsigned op_latefreed:1; 
 unsigned op_attached:1; 
 unsigned op_spare:3; 
 U8 op_flags; 
 U8 op_private;
};
</code></pre>
You can see some variable being defined like <code>unsigned op_attached:1</code> and I'm unsure what would that mean. Would that effect the number of bytes to be allocated for this particular variable?

Is there a standard function that returns the position (not value) of the maximum element of an array of values?

For example:

Suppose I have an array like this:

    sampleArray = [1, 5, 2, 9, 4, 6, 3]

I want a function that returns the integer of 3 that tells me that `sampleArray[3]` is the largest value in the array.


Finding the position of the maximum element

Is there some equivalent class for C++1x&#39;s std::unique_ptr in the boost libraries? The behavior I&#39;m looking for is being able to have an exception-safe factory function, like so...

    std::unique_ptr&lt;Base&gt; create_base()
    {
        return std::unique_ptr&lt;Base&gt;(new Derived);
    }

    void some_other_function()
    {
        std::unique_ptr&lt;Base&gt; b = create_base();

        // Do some stuff with b that may or may not throw an exception...

        // Now b is destructed automagically.
    }

EDIT: Right now, I&#39;m using this hack, which seems like the best I can get at this point...

    Base* create_base()
    {
        return new Derived;
    }

    void some_other_function()
    {
        boost::scoped_ptr&lt;Base&gt; b = create_base();

        // Do some stuff with b that may or may not throw an exception...

        // Now b is deleted automagically.
    }

unique_ptr boost equivalent?

What part of the C++ specification restricts argument dependent lookup from finding function templates in the set of associated namespaces? In other words, why does the last call in `main` below fail to compile?

    namespace ns {
        struct foo {};
        template&lt;int i&gt; void frob(foo const&amp;) {}
        void non_template(foo const&amp;) {}
    }
    
    int main() {
        ns::foo f;
        non_template(f); // This is fine.
        frob&lt;0&gt;(f); // This is not.
    }

Why doesn&#39;t ADL find function templates?

Some time ago I read an article that explained several pitfalls of argument dependent lookup, but I cannot find it anymore. It was about gaining access to things that you should not have access to or something like that. So I thought I&#39;d ask here: what are the pitfalls of ADL?

What are the pitfalls of ADL?

How can I make GNU Make use a different compiler without manually editing the makefile?

Make GNU make use a different compiler

There are three loops in C: `for`, `while`, and `do-while`. What&#39;s the difference between them?

For example, it seems nearly all `while` statements can be replaced by `for` statements, right? Then, what&#39;s the advantage using `while`?


For vs. while in C programming?

I have a C project that produces ten executables, all of which I would like to be linked in statically. The problem I am facing is that one of these executables uses a 3rd-party library of which only the shared-object version is available.

  If I pass the `-static` flag to gcc, ld will error saying it can&#39;t find the library in question (I presume it&#39;s looking for the .a version) and the executable will not be built.  Ideally, I would like to be able to tell &#39;ld&#39; to statically link as much as it can and fail over to the shared object library if a static library cannot be found.

In the interium I tried something like `gcc -static -lib1 -lib2 -shared -lib3rdparty foo.c -o foo.exe` in hopes that &#39;ld&#39; would statically link in lib1 and lib2 but only have a run-time dependence on lib3rdparty. Unfortunatly, this did not work as I intended; instead the `-shared` flag overwrote the `-static` flag and everything was compiled as shared-objects.

Is statically linking an all-or-nothing deal, or is there some way I can mix and match?

Can I mix static and shared-object libraries when linking?

In [gcc-strict-aliasing-and-casting-through-a-union](https://stackoverflow.com/questions/2906365/gcc-strict-aliasing-and-casting-through-a-union) I asked whether anyone had encountered problems with union punning through pointers.  So far, the answer seems to be _No_.

This question is broader: Do you have _any_ horror stories about gcc and strict-aliasing?

Background: Quoting from [AndreyT&#39;s answer in c99-strict-aliasing-rules-in-c-gcc](https://stackoverflow.com/questions/2771023/c99-strict-aliasing-rules-in-c-gcc/2771041#2771041):

&gt;&quot;Strict aliasing rules are rooted in parts of the standard that were present in C and C++ since the beginning of [standardized] times. The clause that prohibits accessing object of one type through a lvalue of another type is present in C89/90 (6.3) as well as in C++98 (3.10/15). ... It is just that not all compilers wanted (or dared) to enforce it or rely on it.&quot;

Well, **gcc** is now daring to do so, with its `-fstrict-aliasing` switch.  And this has caused some problems.  See, for example, the excellent article  http://davmac.wordpress.com/2009/10/ about a Mysql bug, and the equally excellent discussion in http://cellperformance.beyond3d.com/articles/2006/06/understanding-strict-aliasing.html.

Some other less-relevant links:

 * [performance-impact-of-fno-strict-aliasing](https://stackoverflow.com/questions/1225741/performance-impact-of-fno-strict-aliasing)  
 * [strict-aliasing](https://stackoverflow.com/questions/754929/strict-aliasing)  
 * [when-is-char-safe-for-strict-pointer-aliasing](https://stackoverflow.com/questions/262379/when-is-char-safe-for-strict-pointer-aliasing)  
 * [how-to-detect-strict-aliasing-at-compile-time](https://stackoverflow.com/questions/725138/how-to-detect-strict-aliasing-at-compile-time)  

So to repeat, do you have a horror story of your own?  Problems ***not*** indicated by `-Wstrict-aliasing` would, of course, be preferred.  And other C compilers are also welcome.

***Added June 2nd***:  The first link in [Michael Burr&#39;s answer](https://stackoverflow.com/a/2959468/4095830), which does ***indeed*** qualify as a horror story, is perhaps a bit dated (from 2003).  I did a quick test, but the problem has apparently gone away.

Source:

    #include &lt;string.h&gt;
    struct iw_event {               /* dummy! */
        int len;
    };
    char *iwe_stream_add_event(
        char *stream,               /* Stream of events */
        char *ends,                 /* End of stream */
        struct iw_event *iwe,       /* Payload */
        int event_len)              /* Real size of payload */
    {
        /* Check if it&#39;s possible */
        if ((stream + event_len) &lt; ends) {
                iwe-&gt;len = event_len;
                memcpy(stream, (char *) iwe, event_len);
                stream += event_len;
        }
        return stream;
    }

The specific complaint is:

&gt;Some users have complained that when the [above] code is compiled without the -fno-strict-aliasing, the order of the write and memcpy is inverted (which means a bogus len is mem-copied into the stream).

Compiled code, using **gcc** 4.3.4 on CYGWIN wih -O3 (please correct me if I am wrong--my assembler is a bit rusty!):

    _iwe_stream_add_event:
            pushl       %ebp
            movl        %esp, %ebp
            pushl       %ebx
            subl        $20, %esp
            movl        8(%ebp), %eax       # stream    --&gt; %eax
            movl        20(%ebp), %edx      # event_len --&gt; %edx
            leal        (%eax,%edx), %ebx   # sum       --&gt; %ebx
            cmpl        12(%ebp), %ebx      # compare sum with ends
            jae L2
            movl        16(%ebp), %ecx      # iwe       --&gt; %ecx
            movl        %edx, (%ecx)        # event_len --&gt; iwe-&gt;len (!!)
            movl        %edx, 8(%esp)       # event_len --&gt; stack
            movl        %ecx, 4(%esp)       # iwe       --&gt; stack
            movl        %eax, (%esp)        # stream    --&gt; stack
            call        _memcpy
            movl        %ebx, %eax          # sum       --&gt; retval
    L2:
            addl        $20, %esp
            popl        %ebx
            leave
            ret

And for the second link in Michael&#39;s answer,

    *(unsigned short *)&amp;a = 4;

**gcc** will usually (always?) give a warning.  But I _believe_ a valid solution to this (for **gcc**)  is to use:

    #define CAST(type, x) (((union {typeof(x) src; type dst;}*)&amp;(x))-&gt;dst)
    // ...
    CAST(unsigned short, a) = 4;

I&#39;ve asked SO whether this is OK in [gcc-strict-aliasing-and-casting-through-a-union](https://stackoverflow.com/questions/2906365/gcc-strict-aliasing-and-casting-through-a-union), but so far nobody disagrees.



gcc, strict-aliasing, and horror stories

I&#39;ve always used clock() to measure how much time my application took from start to finish, as; 

    int main(int argc, char *argv[]) {
      const clock_t START = clock();
    
      // ...
    
      const double T_ELAPSED = (double)(clock() - START) / CLOCKS_PER_SEC;
    }

Since I&#39;ve started using POSIX threads this seem to fail. It looks like clock() increases N times faster with N threads. As I don&#39;t know how many threads are going to be running simultaneously, this approach fails. So how can I measure how much time has passed ?

C: using clock() to measure time in multi-threaded programs

I have a function that is doing memcpy, but it&#39;s taking up an enormous amount of cycles. Is there a faster alternative/approach than using memcpy to move a piece of memory?

faster alternative to memcpy?

Is it worthwhile using C&#39;s bit-field implementation? If so, when is it ever used?

I was looking through some emulator code and it looks like the registers for the chips are not being implemented using bit fields.

Is this something that is avoided for performance reasons (or some other reason)?

Are there still times when bit-fields are used?  (ie firmware to put on actual chips, etc)


When is it worthwhile to use bit fields?

Any portable code that uses bitfields seems to distinguish between little- and big-endian platforms. See the [declaration of struct iphdr in linux kernel](http://lxr.linux.no/#linux+v2.6.38/include/linux/ip.h) for an example of such code. I fail to understand why bit endianness is an issue at all.

As far as I understand, bitfields are purely compiler constructs, used to facilitate bit level manipulations.

For instance, consider the following bitfield:
&lt;code&gt;&lt;pre&gt;
struct ParsedInt {
    unsigned int f1:1;
    unsigned int f2:3;
    unsigned int f3:4;
};
uint8_t i;
struct ParsedInt *d = &amp;i;
&lt;/pre&gt;&lt;/code&gt;
Here, writing &lt;code&gt;d-&gt;f2&lt;/code&gt; is simply a compact and readable way of saying &lt;code&gt;(i&gt;&gt;1) &amp;  (1&lt;&lt;4 - 1)&lt;/code&gt;.

However, bit operations are well-defined and work regardless of the architecture. So, how come bitfields are not portable?

Why bit endianness is an issue in bitfields?

I&#39;m working on a microcontroller with only 2KB of SRAM and desperately need to conserve some memory. Trying to work out how I can put 8 `0`/`1` values into a single byte using a bitfield but can&#39;t quite work it out.

    struct Bits
    {
        int8_t b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1;
    };
    
    int main(){
    	Bits b;
    	b.b0 = 0;
    	b.b1 = 1;
    
    	cout &lt;&lt; (int)b.b0; // outputs 0, correct
    	cout &lt;&lt; (int)b.b1; // outputs -1, should be outputting 1
    }

What gives?

Storing 8 logical true/false values inside 1 byte?

I saw the below code in [this Quora post](https://www.quora.com/What-is-something-that-almost-nobody-knows-about-the-C-coding-language/answer/%C3%81lvaro-Lopes):

    #include &lt;stdio.h&gt;
     
    struct mystruct { int enabled:1; };
    int main()
    {
      struct mystruct s;
      s.enabled = 1;
      if(s.enabled == 1)
        printf(&quot;Is enabled\n&quot;); // --&gt; we think this to be printed
      else
        printf(&quot;Is disabled !!\n&quot;);
    }

In both C &amp; C++, the output of the code is *unexpected*, 

&gt; Is disabled  !!

Though the &quot;sign bit&quot; related explanation is given in that post, I am unable to understand, how it is possible that we set something and then it doesn&#39;t reflect as it is.

Can someone give a more elaborate explanation?

---

**Note**: Both the tags [tag:c] &amp; [tag:c++] are required, because their standards slightly differ for describing the bit-fields. See answers for [C specification](https://stackoverflow.com/a/53853737/514235) and [C++ specification](https://stackoverflow.com/a/53867011/514235).

Why is assigning a value to a bit field not giving the same value back?

I&#39;m learning how to use Redis for a project of mine. One thing I haven&#39;t got my head around is what exactly the colons are used for in the names of keys.

I have seen names of key such as these:

    users:bob
    color:blue
    item:bag

Does the colon separate keys into categories and make finding the keys faster? If so can you use multiple colons when naming keys to break them down into sub categories? Lastly do they have anything to do with defining different databases within the Redis server?

I have read through documentation and done numerous Google searches on the matter but oddly I can&#39;t find anything discussing this.

What is the purpose of colons within Redis keys

I&#39;ve never seen it before. I thought it was a typo for &quot;::sample&quot;, but when I saw it actually compiles I was very confused. Can anyone help me find out please? I don&#39;t think it&#39;s a `goto` label.

    void f() {
      class: sample {
        // there were some members declared here
      } x;
    }



What does &quot;class :&quot; mean in C++?

What does this code refer too?
&lt;!-- language-all: lang-js --&gt;
    
    queryString: function() {

    //some code

    }

I tested it in the WebConsole (Firefox) but it wouldn&#39;t execute, so I&#39;m thinking that it isn&#39;t equivalent to `function queryString() {}`.

So what is it exactly?

Javascript &#39;colon&#39; for labeling anonymous functions?

I am getting errors from customers who are uploading files with a colon in the file name, i.e. `C:/uploads/test : doc.html`

I assume that some Unix or Linux system is generating the file but I&#39;m not sure how the users are saving them with the invalid filename. I have coded a piece that should rename the document on upload. My problem is that I can&#39;t test it because I can&#39;t get a file on Windows that has a colon in the filename. 

How to get a file in Windows with a colon in the filename?

I was recently modifying some code, and found a pre-existing bug on one line within a function:

    std:;string x = y;

This code still compiles and has been working as expected.

The string definition works because this file is `using namespace std;`, so the `std::` was unnecessary in the first place.

The question is, why is `std:;` compiling and what, if anything, is it doing?

Content Type	Original Author	Original Content on Stackoverflow
Question	Munir Ahmed	View Question on Stackoverflow
Solution 1 - C++	utnapistim	View Answer on Stackoverflow
Solution 2 - C++	James McNellis	View Answer on Stackoverflow
Solution 3 - C++	goedson	View Answer on Stackoverflow
Solution 4 - C++	plinth	View Answer on Stackoverflow

What does 'unsigned temp:3' in a struct or union mean?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

Google Map API v3 ~ Simply Close an infowindow?

Packaging a Python script on Linux into a Windows executable

Attributions