Yes, you can compare it to `nullptr` after the `move` and it is guaranteed to compare equal.

From *&#167;20.8.1/4 [unique.ptr]*

&gt; Additionally, `u` can, upon request, transfer ownership to another unique pointer `u2`. Upon completion of such a transfer, the following postconditions hold:&lt;br/&gt;
— `u2.p` is equal to the pre-transfer `u.p`,&lt;br/&gt;
— **`u.p` is equal to `nullptr`**, and&lt;br/&gt;
...

(the member `p` is described earlier as &amp;mdash; *a unique pointer is an object `u` that stores a pointer to a second object `p`*)

Yes. From C++2011 Standard Section *20.7.1/4*:

&gt; Additionally, u can, upon request, transfer ownership to another unique pointer u2. Upon completion of
such a transfer, the following postconditions hold [...] [the source unique_ptr] is equal to nullptr...

I added `UICollectionView` by code.&lt;br&gt;
Now, the app crash with message: `UICollectionView must be initialized with a non-nil layout parameter`.&lt;br&gt;
Do you have any idea to fix it?&lt;br&gt;
`CollectionCell` is custom class of `UICollectionViewCell`.

    @property (nonatomic, strong) UICollectionView* collectionView;

    - (void)viewDidLoad
    {
        [super viewDidLoad];
    
        self.collectionView = [[UICollectionView alloc]init];
        [self.collectionView registerClass:[CollectionCell class] forCellWithReuseIdentifier:@&quot;cell&quot;];
        UICollectionViewFlowLayout* flowLayout = [[UICollectionViewFlowLayout alloc]init];
        flowLayout.itemSize = CGSizeMake(100, 100);
        [flowLayout setScrollDirection:UICollectionViewScrollDirectionHorizontal];
        [self.collectionView setCollectionViewLayout:flowLayout];
    
        self.collectionView.frame = CGRectMake(0, 60, 320, 500);
        self.collectionView.backgroundColor = [UIColor whiteColor];
        self.collectionView.delegate = self;
        self.collectionView.dataSource = self;
        [self.view addSubview:self.eventCollection];
    }

    - (NSInteger)numberOfSectionsInCollectionView:(UICollectionView *)collectionView
    {
        return 1;
    }
    
    - (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section
    {
        return 20;
    }
    
    - (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath
    {
        CollectionCell* cell = [self.eventCollection dequeueReusableCellWithReuseIdentifier:@&quot;cell&quot; forIndexPath:indexPath];
        cell.label.text = [NSString stringWithFormat:@&quot;%d&quot;, indexPath.item];
        return cell;
    }



UICollectionView: must be initialized with a non-nil layout parameter

Is it possible to skip/exclude some tests from being run with ```go test```?

I have a fairly large amount of integration type tests which call a rest service written as standard go tests, and run with ```go test```. When a new feature is developed its sometimes useful to be able to skip some of the tests, for example if the new feature is not yet deployed on the testing server and I still want to run all the existing tests (except those new ones which tests the new feature).

I know about ```-run```, but I dont want to specify all tests I want to run, that would be a long list. At the same time I have not been able to write a regex for excluding tests.

Another option would be to not commit the tests which dont run in the same branch, but it would be easier if I could just specify what to exclude.

Skip some tests with go test

Is `unique_ptr` guaranteed to store `nullptr` after move?

    std::unique_ptr&lt;int&gt; p1{new int{23}};
    std::unique_ptr&lt;int&gt; p2{std::move(p1)};
    assert(!p1); // is this always true?

Is unique_ptr guaranteed to store nullptr after move?

Is <code>unique_ptr</code> guaranteed to store <code>nullptr</code> after move?
<pre><code class="hljs language-c">std::unique_ptr&#x3C;int> p1{new int{23}};
std::unique_ptr&#x3C;int> p2{std::move(p1)};
assert(!p1); // is this always true?
</code></pre>

I tried to use incomplete type in nested name specifier as the following:

    class A;
    
    int b= A::c; // error: incomplete type ‘A’ used in nested name specifier
    
    class A {
        static const int c=5;
    };

There is says nothing about it in the 3.4.3/1 of N3797 working draft:

&gt; The name of a class or namespace member or enumerator can be referred
&gt; to after the :: scope resolution operator (5.1) applied to a
&gt; nested-name-specifier that denotes its class, namespace, or
&gt; enumeration

So is that behavior implementation dependent?

Incomplete type in nested name specifier

I am trying to compile a C++ program like this:

    $ g++ -o Sniffer_Train main.cpp Sniffer_train.cpp Sniffer_train.h -lmysqlclient -lpcap

However I get the following error:

    /usr/bin/ld: /tmp/cct6xeXD.o: undefined reference to symbol
    &#39;pthread_join@@GLIBC_2.4&#39; //lib/arm-linux-gnueabihf/libpthread.so.0:
    error adding symbols: DSO missing from command line
     
    collect2: error: ld returned 1 exit status

I have no idea what this error means. Any help will be greatly appreciated.


DSO missing from command line

In c++14 the `decltype(auto)` idiom is introduced. 

Typically its use is to **allow `auto` declarations to use the `decltype` rules on the given expression**. 

Searching for examples of &quot;good&quot; usage of the idiom I can only think of things like the following (by [Scott Meyers](http://scottmeyers.blogspot.gr/2013/07/when-decltype-meets-auto.html)), namely for **a function&#39;s return type deduction**:

    template&lt;typename ContainerType, typename IndexType&gt;                // C++14
    decltype(auto) grab(ContainerType&amp;&amp; container, IndexType&amp;&amp; index)
    {
      authenticateUser();
      return std::forward&lt;ContainerType&gt;(container)[std::forward&lt;IndexType&gt;(index)];
    }

Are there any other examples where this new language feature is useful?

What are some uses of decltype(auto)?

I tracked down an obscure logging bug to the fact that initializer lists of length 2 appear to be a special case!  How is this possible?

The code was compiled with Apple LLVM version 5.1 (clang-503.0.40), using `CXXFLAGS=-std=c++11 -stdlib=libc++`.


    #include &lt;stdio.h&gt;

    #include &lt;string&gt;
    #include &lt;vector&gt;

    using namespace std;

    typedef vector&lt;string&gt; Strings;

    void print(string const&amp; s) {
        printf(s.c_str());
        printf(&quot;\n&quot;);
    }

    void print(Strings const&amp; ss, string const&amp; name) {
        print(&quot;Test &quot; + name);
        print(&quot;Number of strings: &quot; + to_string(ss.size()));
        for (auto&amp; s: ss) {
            auto t = &quot;length = &quot; + to_string(s.size()) + &quot;: &quot; + s;
            print(t);
        }
        print(&quot;\n&quot;);
    }

    void test() {
        Strings a{{&quot;hello&quot;}};                  print(a, &quot;a&quot;);
        Strings b{{&quot;hello&quot;, &quot;there&quot;}};         print(b, &quot;b&quot;);
        Strings c{{&quot;hello&quot;, &quot;there&quot;, &quot;kids&quot;}}; print(c, &quot;c&quot;);

        Strings A{&quot;hello&quot;};                    print(A, &quot;A&quot;);
        Strings B{&quot;hello&quot;, &quot;there&quot;};           print(B, &quot;B&quot;);
        Strings C{&quot;hello&quot;, &quot;there&quot;, &quot;kids&quot;};   print(C, &quot;C&quot;);
    }

    int main() {
        test();
    }


Output:

    Test a
    Number of strings: 1
    length = 5: hello

    Test b
    Number of strings: 1
    length = 8: hello

    Test c
    Number of strings: 3
    length = 5: hello
    length = 5: there
    length = 4: kids

    Test A
    Number of strings: 1
    length = 5: hello

    Test B
    Number of strings: 2
    length = 5: hello
    length = 5: there

    Test C
    Number of strings: 3
    length = 5: hello
    length = 5: there
    length = 4: kids

I should also add that the length of the bogus string in test b seems to be indeterminate - it&#39;s always greater than the first initializer string but has varied from one more than the length of the first string to the total of the lengths of the two strings in the initializer. 

C++11 initializer list fails - but only on lists of length 2

Parentheses in C++ are used in many places: e.g. in function calls and grouping expressions to override operator precedence. **Apart from illegal extra parentheses** (such as around function call argument lists), a general -but not absolute- rule of C++ is that **extra parentheses never hurt**:

**5.1 Primary expressions [expr.prim]**

**5.1.1 General [expr.prim.general]**

&gt; 6 A parenthesized expression is a primary expression whose type and
&gt; value are identical to those of the enclosed expression. The presence
&gt; of parentheses does not affect whether the expression is an lvalue.
&gt; The parenthesized expression can be used in exactly the same contexts
&gt; as those where the enclosed expression can be used, and with the same
&gt; meaning, **except as otherwise indicated**.

**Question**: in which contexts do extra parentheses change the meaning of a C++ program, other than overriding basic operator precedence?

**NOTE**: I consider the restriction of **pointer-to-member** syntax to `&amp;qualified-id` without parentheses to be outside the scope because it [**restricts syntax**](https://stackoverflow.com/a/7135001/819272) rather than allowing two syntaxes with different meanings. Similarly, the use of **parentheses inside preprocessor macro definitions** also guards against unwanted operator precedence.

When do extra parentheses have an effect, other than on operator precedence?

With C++11, we now have the ability to initialize class members in a header declaration:

    class aClass
    {
    	private:
    		int mInt{100};
    	public:
    		 aClass();
    		~aClass();
    };

So I&#39;m a bit confused. Traditionally initialization lists in constructors have been used for member initialization:

    aClass::aClass()
    : mInt(100)
    {
    	...
    }


Has the new C++11 member initialization feature at declaration made initialization lists obsolete? If not, what are the advantages of one over the other? What situations would make initialization at declaration advantageous, or initialization lists advantageous? When should one be used over the other?




Has the new C++11 member initialization feature at declaration made initialization lists obsolete?

I have some pre-C++11 code in which I use `const` references to pass large parameters like `vector`&#39;s a lot. An example is as follows:

    int hd(const vector&lt;int&gt;&amp; a) {
       return a[0];
    }

I heard that with new C++11 features, you can pass the `vector` by value as follows without performance hits.

    int hd(vector&lt;int&gt; a) {
       return a[0];
    }

For example, [this answer][1] says

&gt; C++11&#39;s move semantics make passing and returning by value much more attractive even for complex objects.

Is it true that the above two options are the same performance-wise?

If so, when is using const reference as in option 1 better than option 2? (i.e. why do we still need to use const references in C++11).

One reason I ask is that const references complicate deduction of template parameters, and it would be a lot easier to use pass-by-value only, if it is the same with const reference performance-wise.

  [1]: https://stackoverflow.com/a/2139254/683218


When is a const reference better than pass-by-value in C++11?

I am trying to compile the following thread pool program posted on code review to test it.

https://codereview.stackexchange.com/questions/55100/platform-independant-thread-pool-v4

But I am getting the errors

    threadpool.hpp: In member function ‘std::future&lt;decltype (task((forward&lt;Args&gt;)(args)...))&gt; threadpool::enqueue_task(Func&amp;&amp;, Args&amp;&amp; ...)’:
    threadpool.hpp:94:28: error: ‘make_unique’ was not declared in this scope
         auto package_ptr = make_unique&lt;task_package_impl&lt;R, decltype(bound_task)&gt;&gt;  (std::move(bound_task), std::move(promise));
                            ^
    threadpool.hpp:94:81: error: expected primary-expression before ‘&gt;’ token
         auto package_ptr = make_unique&lt;task_package_impl&lt;R, decltype(bound_task)&gt;&gt;(std::move(bound_task), std::move(promise));
                                                                                 ^
    main.cpp: In function ‘int main()’:
    main.cpp:9:17: error: ‘make_unique’ is not a member of ‘std’
     auto ptr1 = std::make_unique&lt;unsigned&gt;();
                 ^
    main.cpp:9:34: error: expected primary-expression before ‘unsigned’
     auto ptr1 = std::make_unique&lt;unsigned&gt;();
                                  ^
    main.cpp:14:17: error: ‘make_unique’ is not a member of ‘std’
     auto ptr2 = std::make_unique&lt;unsigned&gt;();
                 ^
    main.cpp:14:34: error: expected primary-expression before ‘unsigned’
     auto ptr2 = std::make_unique&lt;unsigned&gt;();


error::make_unique is not a member of ‘std’

Suppose I have the following:

    #include &lt;memory&gt;
    struct A { int x; };

    class B {
      B(int x, std::unique_ptr&lt;A&gt; a);
    };
    
    class C : public B {
      C(std::unique_ptr&lt;A&gt; a) : B(a-&gt;x, std::move(a)) {}
    };



If I understand the C++ rules about &quot;unspecified order of function parameters&quot; correctly, this code is unsafe. If the second argument to `B`&#39;s constructor is constructed first using the move constructor, then `a` now contains a `nullptr` and the expression `a-&gt;x` will trigger undefined behavior (likely segfault). If the first argument is constructed first, then everything will work as intended.

If this were a normal function call, we could just create a temporary:

    auto x = a-&gt;x
    B b{x, std::move(a)};

But in the class initialization list we don&#39;t have the freedom to create temporary variables.

Suppose I cannot change `B`, is there any possible way to accomplish the above? Namely dereferencing and moving a `unique_ptr` in the same function call expression without creating a temporary?

What if you could change `B`&#39;s constructor but not add new methods such as `setX(int)`? Would that help?

Thank you


Move semantics and function order evaluation

Because `std::function` is copyable, the standard requires that callables used to construct it also be copyable:

  n337 (20.8.11.2.1) 

&gt;`template&lt;class F&gt; function(F f);`
&gt;
&gt;Requires: `F` shall be CopyConstructible. `f` shall be Callable (20.8.11.2) for argument types `ArgTypes` and return type `R`. The copy constructor and destructor of A shall not throw exceptions.`


This implies that it is not possible to form an `std::function` from a non-copyable bind object or a lambda that captured a move-only type such as `std::unique_ptr`.  

It seems possible to implement such a move-only wrapper for move-only callables.  Is there a standard library move-only equivalent for `std::function` or, is there a common workaround for this problem?

Move-only version of std::function

In C++11 ```emplace_back()``` is generally preferred (in terms of efficiency) to ```push_back()``` as it allows in-place construction, **but is this still the case when using ```push_back(std::move())``` with an already-constructed object?**

For instance, is ```emplace_back()``` still preferred in cases like the following?

&lt;!-- language-all: lang-c++11 --&gt;

    std::string mystring(&quot;hello world&quot;);
    std::vector&lt;std::string&gt; myvector;

    myvector.emplace_back(mystring);
    myvector.push_back(std::move(mystring));
    // (of course assuming we don&#39;t care about using the value of mystring after)

Additionally, is there any benefit in the above example to instead doing:

    myvector.emplace_back(std::move(mystring));

or is the move here entirely redundant, or has no effect?

Efficiency of C++11 push_back() with std::move versus emplace_back() for already constructed objects

It is sometimes claimed that C++11/14 can get you a performance boost even when merely compiling C++98 code. The justification is usually along the lines of move semantics, as in some cases the rvalue constructors are automatically generated or now part of the STL. Now I&#39;m wondering whether these cases were previously actually already handled by RVO or similar compiler optimizations. 

My question then is if you could give me an actual example of a piece of C++98 code that, without modification, runs faster using a compiler supporting the new language features. I do understand that a standard conforming compiler is not required to do the copy elision and just by that reason move semantics might bring about speed, but I&#39;d like to see a less pathological case, if you will.

EDIT: Just to be clear, I am not asking whether new compilers are faster than old compilers, but rather if there is code whereby adding -std=c++14 to my compiler flags it would run faster (avoid copies, but if you can come up with anything else besides move semantics, I&#39;d be interested, too)

Can modern C++ get you performance for free?

I don&#39;t understand the error `cannot move out of borrowed content`. I have received it many times and I have always solved it, but I&#39;ve never understood why.

For example:

    for line in self.xslg_file.iter() {
        self.buffer.clear();
        
        for current_char in line.into_bytes().iter() {
            self.buffer.push(*current_char as char);
        }
        
        println!(&quot;{}&quot;, line);
    }

produces the error:

```none
error[E0507]: cannot move out of borrowed content
  --&gt; src/main.rs:31:33
   |
31 |             for current_char in line.into_bytes().iter() {
   |                                 ^^^^ cannot move out of borrowed content
```

In newer versions of Rust, the error is

```none
error[E0507]: cannot move out of `*line` which is behind a shared reference
  --&gt; src/main.rs:31:33
   |
31 |             for current_char in line.into_bytes().iter() {
   |                                 ^^^^ move occurs because `*line` has type `std::string::String`, which does not implement the `Copy` trait
```

I solved it by cloning `line`:

    for current_char in line.clone().into_bytes().iter() {

I don&#39;t understand the error even after reading other posts like:

- https://stackoverflow.com/questions/28034646/cant-borrow-file-from-mut-self-error-msg-cannot-move-out-of-borrowed-content
- https://stackoverflow.com/questions/28008585/changing-a-node-in-a-tree-in-rust

What is the origin of this kind of error?


Cannot move out of borrowed content / cannot move out of behind a shared reference

Is this code correct? 

    auto v =  make_unique&lt;int&gt;(12);
    v.release();     // is this possible?

Is it equivalent to `delete` of a raw pointer?

Does unique_ptr::release() call the destructor?

If I understand correctly, a `weak_ptr` doesn&#39;t increment the reference count of the managed object, therefore it doesn&#39;t represent ownership. It simply lets you access an object, the lifetime of which is managed by someone else.
So I don&#39;t really see why a `weak_ptr` can&#39;t be constructed from a `unique_ptr`, but only a `shared_ptr`.

Can someone briefly explain this?

Why can&#39;t a weak_ptr be constructed from a unique_ptr?

How can I pass a `std::unique_ptr` into a function? Lets say I have the following class:

    class A
    {
    public:
        A(int val)
        {
            _val = val;
        }

        int GetVal() { return _val; }
    private:
        int _val;
    };

The following does not compile:


    void MyFunc(unique_ptr&lt;A&gt; arg)
    {
        cout &lt;&lt; arg-&gt;GetVal() &lt;&lt; endl;
    }

    int main(int argc, char* argv[])
    {
        unique_ptr&lt;A&gt; ptr = unique_ptr&lt;A&gt;(new A(1234));
        MyFunc(ptr);

	    return 0;
    }

Why can I not pass a `std::unique_ptr` into a function? Surely this is the primary purpose of the construct? Or did the C++ committee intend for me to fall back to raw C-style pointers and pass it like this:
    
    MyFunc(&amp;(*ptr)); 

And most strangely of all, why is this an OK way of passing it? It seems horribly inconsistent:

    MyFunc(unique_ptr&lt;A&gt;(new A(1234)));



How can I pass std::unique_ptr into a function

This code is what I want to do: 

    Tony&amp; Movie::addTony()
    {
        Tony *newTony = new Tony;
        std::unique_ptr&lt;Tony&gt; tony(newTony);
        attachActor(std::move(tony));
        return *newTony;
    }

I am wondering if I could do this instead:

    Tony&amp; Movie::addTony()
    {
        std::unique_ptr&lt;Tony&gt; tony(new Tony);
        attachActor(std::move(tony));
        return *tony.get();
    }

But will `*tony.get()` be the same pointer or null? I know I could verify, but what is the standard thing for it to do?

Content Type	Original Author	Original Content on Stackoverflow
Question	lizarisk	View Question on Stackoverflow
Solution 1 - C++	Praetorian	View Answer on Stackoverflow
Solution 2 - C++	Paul Evans	View Answer on Stackoverflow

Is unique_ptr guaranteed to store nullptr after move?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Skip some tests with go test

UICollectionView: must be initialized with a non-nil layout parameter

Attributions