You will need clang 3.3 to use the most relevant feature set from C++ 11. Read [C++ Support in Clang](http://clang.llvm.org/cxx_status.html) for the complete list of up-to-date supported features. Clang 3.3 is claimed to be C++11 feature complete.

Clang&#39;s command line is gcc-compatible so you have to enable C++11 support via the followinf command-line switch

    -std=c++11

There is also a bunch of post-C++11 features (like decltype(auto), member initializers and aggregates) that are supported by Clang 3.3. Use this command line switch to enable them

    -std=c++1y

Here is the always up to date list of features supported by clang: 

http://clang.llvm.org/cxx_status.html

To activate C++11, you have to add -std=c++11 in your clang calls, like for gcc.
If you use an IDE that is clang-aware or gcc-aware, there is a specific project settings option available to do that.

I have a parameterized Jenkins job which requires the input of a specific Git branch in a specific Git repo.  Currently this parameter is a string parameter.

Is there any way to make this parameter a choice parameter and dynamically fill the drop down list with the Git branches?  I don&#39;t want to require someone to maintain this choice parameter by manually configuring the drop down every time a new branch is created.

Dynamically Fill Jenkins Choice Parameter With Git Branches In a Specified Repo

In `R`, I have am running the following script:

    &gt; 1:6 %in% 0:36
    [1] TRUE TRUE TRUE TRUE TRUE TRUE

Which is clearly producing a logical vector.  I have read the documentation but can&#39;t seem to find an operator that would return a scalar based on the result, such that `1:6 %in% 0:36` would simply return `TRUE` while having `0:37 %in% 0:36` return `FALSE`.

Does one exist?

The R %in% operator

How can I use the latest C++ 11 features in Clang? What (sub)set of features is supported?

How can I use C++ 11 features in Clang?

<p>How can I use the latest C++ 11 features in Clang? What (sub)set of features is supported?</p>


How to make multi line preprocessor macro? I know how to make one line:

    #define sqr(X) (X*X)

but I need something like this:

    #define someMacro(X)
        class X : public otherClass
        {
             int foo;
             void doFoo();
        };

How can I get this to work?

This is only an example, the real macro may be very long.


Multi line preprocessor macros

I&#39;m reading &quot;Think in C++&quot; and it just introduced the `extern` declaration. For example: 

    extern int x;
    extern float y;

I think I understand the meaning (declaration without definition), but I wonder when it proves useful. 

Can someone provide an example?



When to use extern in C++

This question was triggered by replie(s) to a [post by Herb Sutter][1] where he explained MS&#39;s decision to not support/make a C99 compiler but just go with the C(99) features that are in the C++(11) standard anyway.

One [commenter replied][2]: 

&gt; (...) C is important and deserves at least a little bit of attention.
&gt; 
&gt; There is a LOT of existing code out there that is valid C but is not
&gt; valid C++. That code is not likely to be rewritten (...) 

Since I only program in MS C++, I really don&#39;t know &quot;pure&quot; C that well, i.e. I have no ready picture of what details of the C++-language I&#39;m using are not in C(99) and I have little clues where some C99 code would not work as-is in a C++ compiler. 

Note that I know about the C99 only `restrict` keyword which to me *seems* to have very narrow application and about variable-length-arrays (of which I&#39;m not sure how widespread or important they are).

Also, I&#39;m very interested whether there are any important semantic differences or gotchas, that is, C(99) code that will *compile* under C++(11) but do something differently with the C++ compiler than with the C compiler.

----
Quick links: External resources from the answers:

* [Wikipedia page][3] 
* [David R. Tribble&#39;s comparison][4] (from 2001) 
* C++11 standard: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3376.pdf (section C.1)


  [1]: http://herbsutter.com/2012/05/03/reader-qa-what-about-vc-and-c99/
  [2]: http://herbsutter.com/2012/05/03/reader-qa-what-about-vc-and-c99/#comment-5446
  [3]: http://en.wikipedia.org/wiki/Compatibility_of_C_and_C++
  [4]: http://david.tribble.com/text/cdiffs.htm

What are the incompatible differences between C(99) and C++(11)?

I am trying to read from stdin using C++, using this code


    #include &lt;iostream&gt;
    using namespace std;
    
    int main() {
        while(cin) {
            getline(cin, input_line);
            cout &lt;&lt; input_line &lt;&lt; endl;
        };
        return 0;
    }

when i compile, i get this error..

    [root@proxy-001 krisdigitx]# g++ -o capture -O3 capture.cpp
    capture.cpp: In function &#226;int main()&#226;:
    capture.cpp:6: error: &#226;input_line&#226; was not declared in this scope



Any ideas whats missing?




reading from stdin in c++

I am totally confused with regards to deleting things in C++. If I declare an array of objects and if I use the `clear()` member function. Can I be sure that the memory was released?

For example : 

    tempObject obj1;
    tempObject obj2;
    vector&lt;tempObject&gt; tempVector;

    tempVector.pushback(obj1);
    tempVector.pushback(obj2);

Can I safely call clear to free up all the memory? Or do I need to iterate through to delete one by one?

    tempVector.clear();

If this scenario is changed to a pointer of objects, will the answer be the same as above?

    vector&lt;tempObject&gt; *tempVector;
    //push objects....
    tempVector-&gt;clear();

C++ delete vector, objects, free memory

[[dcl.attr.noreturn]](http://eel.is/c++draft/dcl.attr.noreturn) provides the following example:

    [[ noreturn ]] void f() {
        throw &quot;error&quot;;
        // OK
    }

but I do not understand what is the point of `[[noreturn]]`, because the return type of the function is already `void`.

So, what is the point of the `noreturn` attribute? How is it supposed to be used?

What is the point of noreturn?

Is there any difference between the two? Or am I safe to replace every occurrence of `boost::bind` by `std::bind` in my code and thereby remove the dependence on Boost?

Difference between C++11 std::bind and boost::bind

Is allocating a buffer via `new char[sizeof(T)]` guaranteed to allocate memory which is properly aligned for the type `T`, where all members of `T` has their natural, implementation defined, alignment (that is, you have not used the `alignas` keyword to modify their alignment).

I have seen this guarantee made in a few answers around here but I&#39;m not entirely clear how the standard arrives at this guarantee.  5.3.4-10 of the standard gives the basic requirement: essentially `new char[]` must be aligned to `max_align_t`.

What I&#39;m missing is the bit which says `alignof(T)` will always be a valid alignment with a maximum value of `max_align_t`. I mean, it seems obvious, but must the resulting alignment of a structure be at most `max_align_t`? Even point 3.11-3 says extended alignments may be supported, so may the compiler decide on its own a class is an over-aligned type?


Does new char actually guarantee aligned memory for a class type?

Let&#39;s imagine we have a struct for holding 3 doubles with some member functions:

    struct Vector {
      double x, y, z;
      // ...
      Vector &amp;negate() {
        x = -x; y = -y; z = -z;
        return *this;
      }
      Vector &amp;normalize() {
         double s = 1./sqrt(x*x+y*y+z*z);
         x *= s; y *= s; z *= s;
         return *this;
      }
      // ...
    };

This is a little contrived for simplicity, but I&#39;m sure you agree that similar code is out there. The methods allow you to conveniently chain, for example:

    Vector v = ...;
    v.normalize().negate();

Or even:

    Vector v = Vector{1., 2., 3.}.normalize().negate();

Now if we provided begin() and end() functions, we could use our Vector in a new-style for loop, say to loop over the 3 coordinates x, y, and z (you can no doubt construct more &quot;useful&quot; examples by replacing Vector with e.g. String):

    Vector v = ...;
    for (double x : v) { ... }

We can even do:

    Vector v = ...;
    for (double x : v.normalize().negate()) { ... }

and also:

    for (double x : Vector{1., 2., 3.}) { ... }

However, the following (it seems to me) is broken:

    for (double x : Vector{1., 2., 3.}.normalize()) { ... }

While it seems like a logical combination of the previous two usages, I think this last usage creates a dangling reference while the previous two are completely fine.

- Is this correct and Widely appreciated?   
- Which part of the above is the &quot;bad&quot; part, that should be avoided?   
- Would the language be improved by changing the definition of the range-based for loop such that temporaries constructed in the for-expression exist for the duration of the loop?

Is this a known pitfall of C++11 for loops?

When compiling C source code with either gcc or Clang, I always use the `-g` flag to generate debugging information for gdb.

`gcc -g -o helloworld helloworld.c`

I noticed that some people recommend `-g3` instead. What is the difference between the `-g` and `-g3` flags? Also is there a difference between `-g` and `-ggdb`?

GCC -g vs -g3 GDB Flag: What is the Difference?

What are the differences between `-std=c++11` and `-std=gnu++11` as compilation parameter for gcc and clang? Same question with `c99` and `gnu99`? I know about C++ and C standards, it&#39;s the differences in the parameters that interest me.

I&#39;ve read somewhere that it has to do with some extensions but it is not clear to me which ones and how to choose between one or the other for a new project.

What are the differences between -std=c++11 and -std=gnu++11?

As [this question](https://stackoverflow.com/questions/199966/how-do-you-use-gcc-to-generate-assembly-code-in-intel-syntax) shows, with g++, I can do `g++ -S -masm=intel test.cpp`.
Also, with clang, I can do `clang++ -S test.cpp`, but `-masm=intel` is not supported by clang (`warning argument unused during compilation: -masm=intel`). How do I get intel syntax with clang?

How to generate assembly code with clang in Intel syntax?

I am working in C++ under Mac OS X (10.8.2) and I recently came up with the need of using C++11 features, which are available through the clang++ compiler using the libc++ stdlib.
However, I also need to use some legacy library compiled and linked against libstdc++ (coming from MacPorts). 

In doing so, I got linking errors, since the headers of the legacy libraries using, e.g., `std::string`, required to be resolved against the `std::__1::basic_string` (i.e., the libc++ implementation of `std::string`) instead of the `std::basic_string` implementation.

Is there a way to mix the two libraries in development (e.g. by using some preprocessors flags?)


Using libstdc++ compiled libraries with clang++ -stdlib=libc++

I&#39;ve got some code in which I need to forward-declare the a template class (or at least, forward-declaring would make things a lot easier for me...). I&#39;ve written a simplified version of the problem I&#39;m having so I can display it here:

    template&lt;bool&gt;
    class MyTemplateClass;
    
    int main( int argc, char* argv[] )
    {
    	MyTemplateClass&lt;false&gt; myTemp;  // error here
    	myTemp.GetTheValue();
    	return 0;
    }
    
    template&lt;bool bShouldMult&gt;
    class MyTemplateClass
    {
    	int m_myint;
    	float m_myfloat;
    
    public:
    	MyTemplateClass() : m_myint(5), m_myfloat(3.0f) {}
    	float GetTheValue()
    	{
    		return m_myint * (bShouldMult ? m_myfloat : 1.0f);
    	}	
    
    };

The error I&#39;m getting at the commented line is:

    Error - implicit instantiation of undefined template &#39;MyTemplateClass&lt;false&gt;&#39;

What other detail do I need to include in a forward declaration of MyTemplateClass? Since the error isn&#39;t coming from the next line down I&#39;m assuming it isn&#39;t due to the fact that the method is undefined. The compiler I&#39;m using is LLVM/CLang, and I&#39;m compiling on Mac.

Content Type	Original Author	Original Content on Stackoverflow
Question	user1368198	View Question on Stackoverflow
Solution 1 - C++	Sergey K.	View Answer on Stackoverflow
Solution 2 - C++	Klaim	View Answer on Stackoverflow

How can I use C++ 11 features in Clang?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

The R %in% operator

Dynamically Fill Jenkins Choice Parameter With Git Branches In a Specified Repo

Attributions