For what GCC and GCC-compatible compilers use `__attribute__` most other compilers use `#pragma` directives.

I think GCC&#39;s solution is better since the required behavior of an unrecognised `#pragma` is to ignore it, whereas if you use a compiler that does not understand an `__attribute__` specification, it will not compile - which is generally better, since you then know what you need to port.

Attribute specifications are used to specify aspects of types, data, and functions such as storage and alignment that cannot be specified using C. Often these are target specific, mostly they are non-portable, certainly between compilers, and often between targets. Avoid their use except where it is absolutely necessary to use correct functions of code.

One use is for enforcing memory alignment on variables and structure members.  For example

    float vect[4] __attribute__((aligned(16)));

Will ensure that &lt;code&gt;vect&lt;/code&gt; will be placed on a 16 byte memory boundary.  I do not know if that is a gcc-ism or more generally applicable.

The compiler will typically only aligned &lt;code&gt;vect&lt;/code&gt; on a 4 byte boundary.  With 16 byte alignment it can be used directly with SIMD load instructions where you&#39;d load it up into a 128 bit registers that allows addition, subtraction, dot products and all manner of vector operations.

Sometimes you want alignment so that a structure can be directly overlaid onto memory-mapped hardware registers.  Or it has to be aligned so the hardware can write into it directly used a direct memory access (DMA) mechanism.

Why is it used in C programs?  To limit their portability.

It begins with a double-underscore, so it&#39;s in the implementor&#39;s namespace - it&#39;s not something defined by the language standard, and each compiler vendor is free to use it for any purpose whatsoever.

*Edit:* Why is it used in GNU C programs? See the other answers that address this.

In Ruby, how can I copy a variable such that changes to the original don&#39;t affect the copy?

For example:

    phrase1 = &quot;Hello Jim&quot;
    phrase2 = phrase1
    phrase1.gsub!(&quot;Hello&quot;,&quot;Hi&quot;)
    p phrase2 #outputs &quot;Hi Jim&quot; - I want it to remain &quot;Hello Jim&quot;

In this example, the two variables point to the same object; I want to create a new object for the second variable but have it contain the same information initially.



Ruby: how can I copy a variable without pointing to the same object?

There is a git controlled folder on a server  where the main branch is checked out and a whole pile of files have been modified and not committed. Is there a way for me to commit the changes to a separate branch so I can go back to a clean version?

ie  I want to effecitvely undo all this persons changes but store them in another chance so if that person wants their changes they can switch to that branch.

(Yes I know this is not how git is designed to work but that is my situation!) Any ideas very much appreciated.

Git create branch from current checked out master?

Why and how is  `__attribute__` used in GNU C programs?

__attribute__ in GNU C

<p>Why and how is  <code>__attribute__</code> used in GNU C programs?</p>


Is there a single command in gdb which can set breakpoints on all the functions in a given file ?
I know about rbreak regex which sets breakpoints in matching regular expression functions, but my file doesnt have fixed patterned functions. 

In another way, is there a command by which I can set a breakpoint on a filename. Which will mean, whenever control gets inside this file, it should break ?

I personally think this should not be much difficult to implement in gdb, but just wondering if somebody has already done this.

gdb, set breakpoint on all functions in a file

What is the simplest/cleanest way to implement the [singleton pattern][1] in JavaScript?

  [1]: https://en.wikipedia.org/wiki/Singleton_pattern


Simplest/cleanest way to implement a singleton in JavaScript

e.g.:

    $functions = array(
      &#39;function1&#39; =&gt; function($echo) { echo $echo; }
    );

Is this possible? What&#39;s the best alternative?


Can you store a function in a PHP array?

In my .bashrc, I have a function called hello:

    function hello() {
       echo &quot;Hello, $1!&quot;
    }

I want to be able to invoke hello() from the shell as follows:

    $ hello Lloyd

And get the output:

    &gt; Hello, Lloyd!

What&#39;s the trick?

(The real function I have in mind is more complicated, of course.)

EDIT: This is REALLY caused by a syntax error in the function, I think! :(

    function coolness() {
    
    	if[ [-z &quot;$1&quot;] -o [-z &quot;$2&quot;] ]; then
    		echo &quot;Usage: $0 [sub_package] [endpoint]&quot;;
    		exit 1;
    	fi
            echo &quot;Hi!&quot;
    }



How do you call a function defined in .bashrc from the shell?

According to [http://www.faqs.org/docs/diveintopython/fileinfo_private.html][1]:

&gt; Like most languages, Python has the
&gt; concept of private elements: 
&gt;
&gt; - Private
&gt; functions, which can&#39;t be called from
&gt; **outside their module**

However, if I define two files:

    #a.py
    __num=1
and:

    #b.py
    import a
    print a.__num
when i run `b.py` it prints out `1` without giving any exception. Is diveintopython wrong, or did I misunderstand something? And is there some way to **do** define a module&#39;s function as private?

  [1]: http://www.faqs.org/docs/diveintopython/fileinfo_private.html


Defining private module functions in python

Say I have this small function in a source file

    static void foo() {}

and I build an optimized version of my binary yet I don&#39;t want this function inlined (for optimization purposes). is there a macro I can add in a source code to prevent the inlining?

How can I tell gcc not to inline a function?

I have three files: `program.c`, `program.h` and `headers.h`.

`program.c` includes `program.h` and `headers.h`.

I need to compile this on Linux using _gcc_ compiler.  I&#39;m not sure how to do this. Netbeans created one for me, but it&#39;s empty.

How do I make a simple makefile for gcc on Linux?

I have a cross platform application and in a few of my functions not all the values passed to functions are utilised.  Hence I get a warning from GCC telling me that there are unused variables.

What would be the best way of coding around the warning?

An #ifdef around the function? 

    #ifdef _MSC_VER
    void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal qrLeft, qreal qrTop, qreal qrWidth, qreal qrHeight)
    #else
    void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal /*qrLeft*/, qreal /*qrTop*/, qreal /*qrWidth*/, qreal /*qrHeight*/)
    #endif
    {

This is so ugly but seems like the way the compiler would prefer.

Or do I assign zero to the variable at the end of the function? (which I hate because it&#39;s altering something in the program flow to silence a compiler warning).

Is there a correct way?

How do I best silence a warning about unused variables?

Due to using Gentoo, it often happens that after an update programs are linked against old versions of libraries. Normally, revdep-rebuild helps resolving that, but this time it&#39;s a dependency on a python library, and `python-updater` won&#39;t pick it up.

Is there a &quot;hierarchical&quot; variant of `ldd` which shows me what shared library depends on which another shared library? Most of the time libraries and executables are linked only against a handful of other shared libraries, which in turn were linked against a handful, turning the library dependency into a big list. I want to know which dependency I&#39;ve got to rebuild with the new version of another library that I upgraded.



Hierarchical ldd(1)

The [GCC 4.1.2 documentation][1] has this to say about the `-pipe` option:

&gt; -pipe
&gt;
&gt; Use pipes rather than temporary files for communication between the various stages of compilation. This fails to work on some systems where the assembler is unable to read from a pipe; but the GNU assembler has no trouble.

I assume I&#39;d be able to tell from error message if my systems&#39; assemblers didn&#39;t support pipes, so besides that issue, when does it matter whether I use that option? What factors should go into deciding to use it?

[1]: http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Overall-Options.html

When should I use GCC&#39;s -pipe option?

If in C I write:

    int num;

Before I assign anything to `num`, is the value of `num` indeterminate?

What happens to a declared, uninitialized variable in C? Does it have a value?

I&#39;m curious about the benefits/detriments of different constant declaration and definition options in C++.  For the longest time, I&#39;ve just been declaring them at the top of the header file before the class definition:

    //.h
    const int MyConst = 10;
    const string MyStrConst = &quot;String&quot;;
    class MyClass {
    ...
    };
While this pollutes the global namespace (which I know is a bad thing, but have never found a laundry list of reasons why it is bad), the constants will still be scoped to individual translation units, so files that don&#39;t include this header won&#39;t have access to these constants.  But you can get name collisions if other classes define a constant of the same name, which is arguably not a bad thing as it may be a good indication of an area that could be refactored.

Recently, I decided that it would be better to declare class specific constants inside of the class definition itself:

    //.h
    class MyClass {
        public:
             static const int MyConst = 10;
    ...
        private:
             static const string MyStrConst;
    ...
    };
    //.cpp
    const string MyClass::MyStrConst = &quot;String&quot;;

The visibility of the constant would be adjusted depending on whether the constant is used only internally to the class or is needed for other objects that use the class.  This is what I&#39;m thinking is the best option right now, mainly because you can keep internal class constants private to the class and any other classes using the public constants would have a more detailed reference to the source of the constant (e.g. MyClass::MyConst).  It also won&#39;t pollute the global namespace.  Though it does have the detriment of requiring non-integral initialization in the cpp file.

I&#39;ve also considered moving the constants into their own header file and wrapping them in a namespace in case some other class needs the constants, but not the whole class definition.

Just looking for opinions and possibly other options I hadn&#39;t considered yet.

Where to declare/define class scope constants in C++?

Is it possible to declare two variables of different types in the initialization body of a for loop in C++?

For example:

    for(int i=0,j=0 ...

defines two integers. Can I define an `int` and a `char` in the initialization body? How would this be done?

Is it possible to declare two variables of different types in a for loop?

My understanding is that C++ allows static const members to be defined inside a class so long as it&#39;s an integer type.

Why, then, does the following code give me a linker error?

    #include &lt;algorithm&gt;
    #include &lt;iostream&gt;
    
    class test
    {
    public:
        static const int N = 10;
    };
    
    int main()
    {
        std::cout &lt;&lt; test::N &lt;&lt; &quot;\n&quot;;
        std::min(9, test::N);
    }

The error I get is:

    test.cpp:(.text+0x130): undefined reference to `test::N&#39;
    collect2: ld returned 1 exit status

Interestingly, if I comment out the call to std::min, the code compiles and links just fine (even though test::N is also referenced on the previous line).

Any idea as to what&#39;s going on?

My compiler is gcc 4.4 on Linux.

Defining static const integer members in class definition

I recently tried to create an object like this:

    var carousel = {
          $slider: $(&#39;#carousel1 .slider&#39;),
          panes: carousel.$slider.children().length
        };

My intentions were to improve jQuery&#39;s selector performance by caching the results of `$(&#39;#carousel1 .slider&#39;)` in an object property, and to keep the code concise and relatively DRY.

However, this didn&#39;t work. When the code executed, it threw an exception when trying to parse the value of `panes`, complaining that `carousel` was undefined.

This makes sense, since I&#39;d assume that `carousel` isn&#39;t fully declared until the assignment statement has been fully executed. However, I&#39;d like to avoid resorting to this:

    var carousel = {};
    carousel.$slider = $(&#39;#carousel1 .slider&#39;);
    carousel.panes = carousel.$slider.children().length;

That&#39;s not too much worse, but the `carousel` object will have several more properties that rely on the values of other properties, so that could quickly become verbose.

I tried using `this`, but to no avail. I may well not have been using it correctly, or that may not be a valid approach anyway.

Is there a way for properties of an object to refer to other properties of the same object, while that object is still being declared?

&lt;hr /&gt;

Based on Matthew Flaschen and casablanca&#39;s answers (thanks, guys!), I think these are the versions of my actual code that I&#39;d end up with, based on each approach:

    // Matthew Flaschen

    var carousel = new (function() {
      this.$carousel = $(&#39;.carousel&#39;);
      this.$carousel_window = this.$carousel.find(&#39;.window&#39;);
      this.$carousel_slider = this.$carousel.find(&#39;.slider&#39;);
      this.$first_pane = this.$carousel.find(&#39;.slider&#39;).children(&#39;:first-child&#39;);
      this.panes = this.$carousel_slider.children().length;
      this.pane_gap = this.$first_pane.css(&#39;margin-right&#39;);
    })();

and

    // casablanca

    var $carousel = $(&#39;.carousel&#39;),
        $carousel_slider = $carousel.find(&#39;.slider&#39;),
        $first_pane: $carousel.find(&#39;.slider&#39;).children(&#39;:first-child&#39;);
    
    var properties = {
      $carousel_window: $carousel.find(&#39;.window&#39;),
      panes: $carousel_slider.children().length,
      pane_gap: $first_pane.css(&#39;margin-right&#39;)
    };

    properties.$carousel = $carousel;
    properties.$carousel_slider = $carousel_slider;
    properties.$first_pane = $first_pane;

Assuming those are both correct (I haven&#39;t tested them), it&#39;s kind of a tough call. I think I slightly prefer Matthew Flaschen&#39;s approach, since the code is contained to a structure that more closely resembles an object declaration. There&#39;s also ultimately only one variable created. However, there&#39;s a lot of `this` in there, which seems repetitive - although that may be just the price to pay.

Content Type	Original Author	Original Content on Stackoverflow
Question	sud03r	View Question on Stackoverflow
Solution 1 - Function	Clifford	View Answer on Stackoverflow
Solution 2 - Function	George Phillips	View Answer on Stackoverflow
Solution 3 - Function	mlp	View Answer on Stackoverflow

attribute in GNU C

Function Problem Overview

Function Solutions

Solution 1 - Function

Solution 2 - Function

Solution 3 - Function

Git create branch from current checked out master?

Ruby: how can I copy a variable without pointing to the same object?

Attributions