As Howard already said in the question, the final draft was completed on March 25, 2011.

There will now be some months of editorial changes, voting and ISO red tape before it officially becomes a standard, but on the 25th, the standards committee themselves officially signed off on it.

Sources:

https://www.ibm.com/developerworks/mydeveloperworks/blogs/5894415f-be62-4bc0-81c5-3956e82276f3/entry/the_c_0x_standard_has_been_approved_to_ship23?lang=en

http://herbsutter.com/2011/03/25/we-have-fdis-trip-report-march-2011-c-standards-meeting/

http://twitter.com/#!/sdt_intel/status/51328822066417665

and of course, Howard Hinnant, who asked the question, is on the committee as well, so he&#39;s not making it up.

(Only posting this as a &quot;real&quot; answer because Howard apparently was unable to answer his own question)

**Edit**  
And as of September 1st, 2011, C++11 has been published by ISO. It doesn&#39;t get any more official than that. We have a new standard.

The Final Draft International Standard (FDIS) _was_ available on the WG21 website, however, it has now been removed, apparently for good.  Herb Sutter [said in reply to an inquiry on his blog](http://herbsutter.com/2011/03/25/we-have-fdis-trip-report-march-2011-c-standards-meeting/#comment-3079):

&gt; All C++ committee documents are public, except for membership lists and the final text of the standard. ISO rules, sorry — I did ask permission to leave the draft unprotected, but ISO prohibits sharing the final text of FCD and FDIS documents, so ISO said no because that draft is technically identical to the FDIS and differs from the final FDIS text by only the cover page.

Therefore, the publicly available document closest to the FDIS in content is the working draft from the mailing that immediately preceded the Madrid meeting, [N3242](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf).

---

&lt;s&gt;The Final Draft International Standard (FDIS) is now available on the WG21 website: 

 * [N3290](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3290.pdf) [10.1MB PDF]&lt;/s&gt;

C++0x will have been finished last Thursday! The [ISO/IEC 14882:2011 standard][1] was published on the 1st of September of 2011. What was informally known as C++0x before is now C++11.


  [1]: http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372

&gt; **Possible Duplicate:**  
&gt; [Xcode 4 - &amp;ldquo;Archive&amp;rdquo; is greyed out?](https://stackoverflow.com/questions/5266350/xcode-4-archive-is-greyed-out)  

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

I want to submit my iOS App via Xcode 4. The problem is that I cant do the Build for Archiving. Its Inactive and Gray (the Menu Item Product-&gt;Build For-&gt;Build For Archiving) and i dont know why.

Anybody an Idea?

Xcode4 - Build for Archiving greyed out

If, for a field that you want to filter by, you have more than ~10 values, the filtering sidebar starts to be ugly and harder to use.

I&#39;m looking for a solution to replace the `&lt;li&gt;` with a dropdown selection (combobox) or something similar that will solve the same problem.

How to change the Django admin filter to use a dropdown instead of list?

Ok, this is the first question I&#39;ve asked and I didn&#39;t know you couldn&#39;t answer your own question.

Answer:

March 25, 2011. :-)  I&#39;m not kidding, it&#39;s official.  Well, at least as far as the committee is concerned.

**Update**

Aug. 12, 2011.

The C++ FDIS has officially been approved by ISO in a unanimous vote.  21 of 21 National Bodies voted to APPROVE.

When will C++0x be finished?

Ok, this is the first question I've asked and I didn't know you couldn't answer your own question.
Answer:
March 25, 2011. :-) I'm not kidding, it's official. Well, at least as far as the committee is concerned.
Update
Aug. 12, 2011.
The C++ FDIS has officially been approved by ISO in a unanimous vote. 21 of 21 National Bodies voted to APPROVE.

How can I read a text file line by line in Qt?

I&#39;m looking for the Qt equivalent to:

    std::ifstream infile;
    std::string line;
    while (std::getline(infile, line))
    {
       ...
    }



Read a text file line by line in Qt

&lt;sup&gt;(With type erasure, I mean hiding some or all of the type information regarding a class, somewhat like [Boost.Any][1].)&lt;/sup&gt;  
I want to get a hold of type erasure techniques, while also sharing those, which I know of. My hope is kinda to find some crazy technique that somebody thought of in his/her darkest hour. :) 

The first and most obvious, and commonly taken approach, that I know, are virtual functions. Just hide the implementation of your class inside an interface based class hierarchy. Many Boost libraries do this, for example [Boost.Any][1] does this to hide your type and [Boost.Shared_ptr][2] does this to hide the (de)allocation mechanic.  

Then there is the option with function pointers to templated functions, while holding the actual object in a `void*` pointer, like [Boost.Function][3] does to hide the real type of the functor. Example implementations can be found at the end of the question.

So, for my actual question:  
What other type erasure techniques do you know of? Please provide them, if possible, with an example code, use cases, your experience with them and maybe links for further reading.

**Edit**  
(Since I wasn&#39;t sure wether to add this as an answer, or just edit the question, I&#39;ll just do the safer one.)  
Another nice technique to hide the actual type of something **without** virtual functions or `void*` fiddling, is the one GMan employs [here][5], with relevance to [my question][6] on how exactly this works.


----------
Example code:

    #include &lt;iostream&gt;
    #include &lt;string&gt;
     
    // NOTE: The class name indicates the underlying type erasure technique
     
    // this behaves like the Boost.Any type w.r.t. implementation details
    class Any_Virtual{
            struct holder_base{
                    virtual ~holder_base(){}
                    virtual holder_base* clone() const = 0;
            };
     
            template&lt;class T&gt;
            struct holder : holder_base{
                    holder()
                            : held_()
                    {}
     
                    holder(T const&amp; t)
                            : held_(t)
                    {}
     
                    virtual ~holder(){
                    }
     
                    virtual holder_base* clone() const {
                            return new holder&lt;T&gt;(*this);
                    }
     
                    T held_;
            };
     
    public:
            Any_Virtual()
                    : storage_(0)
            {}
     
            Any_Virtual(Any_Virtual const&amp; other)
                    : storage_(other.storage_-&gt;clone())
            {}
     
            template&lt;class T&gt;
            Any_Virtual(T const&amp; t)
                    : storage_(new holder&lt;T&gt;(t))
            {}
     
            ~Any_Virtual(){
                    Clear();
            }
     
            Any_Virtual&amp; operator=(Any_Virtual const&amp; other){
                    Clear();
                    storage_ = other.storage_-&gt;clone();
                    return *this;
            }
     
            template&lt;class T&gt;
            Any_Virtual&amp; operator=(T const&amp; t){
                    Clear();
                    storage_ = new holder&lt;T&gt;(t);
                    return *this;
            }
     
            void Clear(){
                    if(storage_)
                            delete storage_;
            }
     
            template&lt;class T&gt;
            T&amp; As(){
                    return static_cast&lt;holder&lt;T&gt;*&gt;(storage_)-&gt;held_;
            }
     
    private:
            holder_base* storage_;
    };
     
    // the following demonstrates the use of void pointers 
    // and function pointers to templated operate functions
    // to safely hide the type
     
    enum Operation{
            CopyTag,
            DeleteTag
    };
     
    template&lt;class T&gt;
    void Operate(void*const&amp; in, void*&amp; out, Operation op){
            switch(op){
            case CopyTag:
                    out = new T(*static_cast&lt;T*&gt;(in));
                    return;
            case DeleteTag:
                    delete static_cast&lt;T*&gt;(out);
            }
    }
     
    class Any_VoidPtr{
    public:
            Any_VoidPtr()
                    : object_(0)
                    , operate_(0)
            {}
     
            Any_VoidPtr(Any_VoidPtr const&amp; other)
                    : object_(0)
                    , operate_(other.operate_)
            {
                    if(other.object_)
                            operate_(other.object_, object_, CopyTag);
            }
     
            template&lt;class T&gt;
            Any_VoidPtr(T const&amp; t)
                    : object_(new T(t))
                    , operate_(&amp;Operate&lt;T&gt;)
            {}
     
            ~Any_VoidPtr(){
                    Clear();
            }
     
            Any_VoidPtr&amp; operator=(Any_VoidPtr const&amp; other){
                    Clear();
                    operate_ = other.operate_;
                    operate_(other.object_, object_, CopyTag);
                    return *this;
            }
     
            template&lt;class T&gt;
            Any_VoidPtr&amp; operator=(T const&amp; t){
                    Clear();
                    object_ = new T(t);
                    operate_ = &amp;Operate&lt;T&gt;;
                    return *this;
            }
     
            void Clear(){
                    if(object_)
                            operate_(0,object_,DeleteTag);
                    object_ = 0;
            }
     
            template&lt;class T&gt;
            T&amp; As(){
                    return *static_cast&lt;T*&gt;(object_);
            }
     
    private:
            typedef void (*OperateFunc)(void*const&amp;,void*&amp;,Operation);
     
            void* object_;
            OperateFunc operate_;
    };
     
    int main(){
            Any_Virtual a = 6;
            std::cout &lt;&lt; a.As&lt;int&gt;() &lt;&lt; std::endl;
     
            a = std::string(&quot;oh hi!&quot;);
            std::cout &lt;&lt; a.As&lt;std::string&gt;() &lt;&lt; std::endl;
     
            Any_Virtual av2 = a;
     
            Any_VoidPtr a2 = 42;
            std::cout &lt;&lt; a2.As&lt;int&gt;() &lt;&lt; std::endl;
     
            Any_VoidPtr a3 = a.As&lt;std::string&gt;();
            a2 = a3;
            a2.As&lt;std::string&gt;() += &quot; - again!&quot;;
            std::cout &lt;&lt; &quot;a2: &quot; &lt;&lt; a2.As&lt;std::string&gt;() &lt;&lt; std::endl;
            std::cout &lt;&lt; &quot;a3: &quot; &lt;&lt; a3.As&lt;std::string&gt;() &lt;&lt; std::endl;
     
            a3 = a;
            a3.As&lt;Any_Virtual&gt;().As&lt;std::string&gt;() += &quot; - and yet again!!&quot;;
            std::cout &lt;&lt; &quot;a: &quot; &lt;&lt; a.As&lt;std::string&gt;() &lt;&lt; std::endl;
            std::cout &lt;&lt; &quot;a3-&gt;a: &quot; &lt;&lt; a3.As&lt;Any_Virtual&gt;().As&lt;std::string&gt;() &lt;&lt; std::endl;
     
            std::cin.get();
    }

  [1]: http://www.boost.org/doc/libs/1_46_0/doc/html/any.html
  [2]: http://www.boost.org/doc/libs/1_46_1/libs/smart_ptr/shared_ptr.htm
  [3]: http://www.boost.org/doc/libs/1_46_1/doc/html/function.html
  [4]: http://ideone.com/hwe0H
  [5]: https://stackoverflow.com/questions/2552839/which-c-standard-library-wrapper-functions-do-you-use/2553109#2553109
  [6]: https://stackoverflow.com/questions/4985800/why-is-the-derived-classs-destructor-invoked-on-a-const-reference-to-the-base-cl

Type erasure techniques

I was searching for an implementation of extension methods in c++ and came upon [this comp.std.c++ discussion][1] which mentions that `polymorphic_map` can be used to associated methods with a class, but, the provided link seems to be dead.  Does anyone know what that answer was referring to, or if there is another way to extend classes in a similar manner to extension methods (perhaps through some usage of mixins?).  

I know the canonical C++ solution is to use free functions; this is more out of curiosity than anything else.


  [1]: http://groups.google.com/group/comp.std.c++/browse_thread/thread/c8b7234e249bc107

Extension methods in c++

I&#39;ve been looking into some of the new features of C++11 and one I&#39;ve noticed is the double ampersand in declaring variables, like `T&amp;&amp; var`.

For a start, what is this beast called? I wish Google would allow us to search for punctuation like this.

What exactly does it _mean?_

At first glance, it appears to be a double reference (like the C-style double pointers `T** var`), but I&#39;m having a hard time thinking of a use case for that.


What does T&amp;&amp; (double ampersand) mean in C++11?

Pure virtual functions (when we set `= 0`) can also have a function body.

What is the use to provide a function body for pure virtual functions, if they are not going to be called at all?

C++ pure virtual function have body

Short example:

    #include &lt;iostream&gt;

    int main()
    {
        int n;
        [&amp;](){n = 10;}();             // OK
        [=]() mutable {n = 20;}();    // OK
        // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
        std::cout &lt;&lt; n &lt;&lt; &quot;\n&quot;;       // &quot;10&quot;
    }

The question: Why do we need the `mutable` keyword? It&#39;s quite different from traditional parameter passing to named functions. What&#39;s the rationale behind?

I was under the impression that the whole point of capture-by-value is to allow the user to change the temporary -- otherwise I&#39;m almost always better off using capture-by-reference, aren&#39;t I?

Any enlightenments?

(I&#39;m using MSVC2010 by the way. AFAIK this should be standard)


Why does C++11&#39;s lambda require &quot;mutable&quot; keyword for capture-by-value, by default?

    class my_class
    {
    	...
    	my_class(my_class const &amp;) = delete;
    	...
    };

What does `= delete` mean in that context?

Are there any other &quot;modifiers&quot; (other than `= 0` and `= delete`)?

Meaning of = delete after function declaration

I&#39;m getting up to speed with C++0x, and testing things out with g++ 4.6

I just tried the following code, thinking it would work, but it doesn&#39;t compile. I get the error:

`incompatible types in assignment of ‘std::initializer_list&lt;const int&gt;’ to ‘const int [2]’`


    struct Foo
      {
        int const data[2];

        Foo(std::initializer_list&lt;int const&gt;&amp; ini)
        : data(ini)
        {}
      };

    Foo f = {1,3};


Content Type	Original Author	Original Content on Stackoverflow
Question	Howard Hinnant	View Question on Stackoverflow
Solution 1 - C++	jalf	View Answer on Stackoverflow
Solution 2 - C++	James McNellis	View Answer on Stackoverflow
Solution 3 - C++	R. Martinho Fernandes	View Answer on Stackoverflow

When will C++0x be finished?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

How to change the Django admin filter to use a dropdown instead of list?

Xcode4 - Build for Archiving greyed out

Attributions