No, but that is the most important difference.

The other major difference is that `unique_ptr` can have a destructor object with it, similarly to how `shared_ptr` can. Unlike `shared_ptr`, the destructor type is part of the `unique_ptr`&#39;s type (the way allocators are part of STL container types).

A `const unique_ptr` can effectively do most of what a `scoped_ptr` can do; indeed, unlike `scoped_ptr`, a `const unique_ptr` cannot be rebound with a `reset` call.

Also, `unique_ptr&lt;T&gt;` can work on a `T` which is an incomplete type. The default deleter type requires that `T` be complete when you do anything to the `unique_ptr` that potentially invokes the deleter. You therefore have some freedom to play games about where that happens, depending on the situation.

`unique_ptr` owns an object exclusively.It is **non-copyable** but supports **transfer-of-ownership**. It was introduced as replacement for the now deprecated `auto_ptr`.

`scoped_ptr` is **neither copyable nor movable**. It is the preferred choice when you want to make sure pointers are deleted when going out of scope.

I&#39;m trying to make a js code that works with multiple pages.
I&#39;m trying to use querySelectorAll() to obtain the elements form the DOM.

I need the elements to be ordered. In order to do that I may use xPath or selectors (I&#39;d prefer to use selectors but xPath is also ok). The problem is:  
Are the elements in the NodeList returned by querySelectorAll() ordered against the order that the tags appear in the HTML?




Note: I&#39;d like to add the tag: querySelectorAll

Using querySelectorAll(). Is the result returned by the method ordered?

I&#39;m trying to create a link in my textbox&#39;s adjacent text. This link however is not a URL, but should act as a button so that I can perform a few tasks in the onItemClick event. I&#39;m basically connecting this to a view that shows our End User License Agreement (hard coded).

How can I accomplish this? 

Thanks in advance.

How do I make a portion of a Checkbox&#39;s text clickable?

Is the sole difference between `boost::scoped_ptr&lt;T&gt;` and `std::unique_ptr&lt;T&gt;` the fact that `std::unique_ptr&lt;T&gt;` has move semantics whereas `boost::scoped_ptr&lt;T&gt;` is just a get/reset smart pointer?

Difference between boost::scoped_ptr&lt;T&gt; and std::unique_ptr&lt;T&gt;

<p>Is the sole difference between <code>boost::scoped_ptr&#x3C;T></code> and <code>std::unique_ptr&#x3C;T></code> the fact that <code>std::unique_ptr&#x3C;T></code> has move semantics whereas <code>boost::scoped_ptr&#x3C;T></code> is just a get/reset smart pointer?</p>


I&#39;m in college, and for a project we&#39;re using C. We&#39;ve explored GCC and Clang, and Clang appears to be much more user friendly than GCC.  As a result, I&#39;m wondering what the advantages or disadvantages are to using clang, as opposed to GCC, for developing in C and C++ on Linux? 

In my case this would be used for student level programs, not production. 

If I use Clang, should I debug with GDB and use GNU Make, or use another debugger and make utility?

Clang vs GCC for my Linux Development project

Is there any difference between wrapping both header and cpp file contents in a namespace or wrapping just the header contents and then doing **using namespace** in the cpp file?

By difference I mean any sort performance penalty or slightly different semantics that can cause problems or anything I need to be aware of.

Example:

    // header
    namespace X
    {
      class Foo
      {
      public:
        void TheFunc();
      };
    }

    // cpp
    namespace X
    {
      void Foo::TheFunc()
      {
        return;
      }
    }

VS

    // header
    namespace X
    {
      class Foo
      {
      public:
        void TheFunc();
      };
    }
    
    // cpp
    using namespace X;
    {
      void Foo::TheFunc()
      {
        return;
      }
    } 

If there is no difference what is the preferred form and why?

Creating a C++ namespace in header and source (cpp)

I use a QLabel to display the content of a bigger, dynamically changing QPixmap to the user. It would be nice to make this label smaller/larger depending on the space available. The screen size is not always as big as the QPixmap.

How can I modify the `QSizePolicy` and `sizeHint()` of the QLabel to resize the QPixmap while keeping the aspect ratio of the original QPixmap?

I can&#39;t modify `sizeHint()` of the QLabel, setting the `minimumSize()` to zero does not help. Setting `hasScaledContents()` on the QLabel allows growing, but breaks the aspect ratio thingy...

Subclassing QLabel did help, but this solution adds too much code for just a simple problem...

Any smart hints how to accomplish this _without_ subclassing?

Qt: resizing a QLabel containing a QPixmap while keeping its aspect ratio

I&#39;d like to create a JSON string containing the instance variables of my class.

For example,

    class Example {  
        std::string string;  
        std::map&lt;std::string, std:string&gt; map;  
        std::vector&lt;int&gt; vector;  
    };

would become:

    {
        &quot;string&quot;:&quot;the-string-value&quot;,
        &quot;map&quot;: {
            &quot;key1&quot;:&quot;val1&quot;,
            &quot;key2&quot;:&quot;val2&quot;
        },
        &quot;vector&quot;:[1,2,3,4]
    }

I&#39;ve looked into several C++ libraries for creating JSON and they all seem incredibly complex. I&#39;d like something similar to Javascript&#39;s `JSON.stringify(object)`. In other words just pass a std::map to it and receive a string. The map could contain other maps, vectors, lists, strings, numbers and bools.

What&#39;s the nicest way to do this?

Thanks for your help.

**Edit**

I&#39;ve looked into the following:

json spirit, jsoncpp, zoolib, JOST, CAJUN, libjson, nosjob, JsonBox, jsonme--

Which I understand I can construct a separate JSON object as in an answer below and convert to JSON I&#39;d like to be able to store my stuff in standard collections and convert.

**Edit 2**

Okay, scrap the idea of serializing a class since it appears that&#39;s impossible with C++&#39;s lack of reflection.

Is there a nice way to convert a std::map containing std:maps, std::vectors, std::lists, numbers, strings, and bools to JSON without having to change datatypes or copying data to a new datatype?

Thanks.

Converting C++ class to JSON

What is the difference between malloc() and HeapAlloc()? As far as I understand malloc allocates memory from the heap, just as HeapAlloc, right?

So what is the difference?


Thanks!

malloc() vs. HeapAlloc()

I have tried the following:

    std::function&lt;void ()&gt; getAction(std::unique_ptr&lt;MyClass&gt; &amp;&amp;psomething){
        //The caller given ownership of psomething
        return [psomething](){ 
            psomething-&gt;do_some_thing();
            //psomething is expected to be released after this point
        };
    }

But it does not compile. Any ideas?

UPDATE:

AS suggested, some new syntax is required to explicitly specify we need to transfer the ownership to the lambda, I am now thinking about the following syntax:

    std::function&lt;void ()&gt; getAction(std::unique_ptr&lt;MyClass&gt; psomething){
        //The caller given ownership of psomething
        return [auto psomething=move(psomething)](){ 
            psomething-&gt;do_some_thing();
            //psomething is expected to be released after this point
        };
    }

Would it be a good candidate?

UPDATE 1:

I will show my implementation of `move` and `copy` as following:

    template&lt;typename T&gt;
    T copy(const T &amp;t) {
        return t;
    }

    //process lvalue references
    template&lt;typename T&gt;
    T move(T &amp;t) {
        return std::move(t);
    }

    class A{/*...*/};

    void test(A &amp;&amp;a);

    int main(int, char **){
        A a;
        test(copy(a));    //OK, copied
        test(move(a));    //OK, moved
        test(A());        //OK, temporary object
        test(copy(A()));  //OK, copying temporary object
        //You can disable this behavior by letting copy accepts T &amp;  
        //test(move(A())); You should never move a temporary object
        //It is not good to have a rvalue version of move.
        //test(a); forbidden, you have to say weather you want to copy or move
        //from a lvalue reference.
    }

How to capture a unique_ptr into a lambda expression?

According to N3290, `std::unique_ptr` accepts a deleter argument in its constructor.

However, I can&#39;t get that to work with Visual C++ 10.0 or MinGW g++ 4.4.1 in Windows, nor with g++ 4.6.1 in Ubuntu.

I therefore fear that my understanding of it is incomplete or wrong. I can&#39;t see the point of a deleter argument that&#39;s apparently ignored, so can anyone provide a working example?

Preferably I&#39;d like to see also how that works for `unique_ptr&lt;Base&gt; p = unique_ptr&lt;Derived&gt;( new Derived )`.

Possibly with some wording from the standard to back up the example, i.e. that with whatever compiler you&#39;re using, it actually does what it&#39;s supposed to do?

How does the custom deleter of std::unique_ptr work?

Here is a simplification of what I&#39;m seeing when I try to use unique_ptr for pimpl.  I chose unique_ptr because I really want the class to own the pointer - I want the lifetimes of the pimpl pointer and the class to be the same.

Anyway, here is the header:

    #ifndef HELP
    #define HELP 1
    
    #include &lt;memory&gt;
    
    class Help
    {
    
    public:
    
      Help(int ii);
      ~Help() = default;
    
    private:
    
      class Impl;
      std::unique_ptr&lt;Impl&gt; _M_impl;
    };
    
    #endif // HELP

Here is the source:

    #include &quot;Help.h&quot;
    
    class Help::Impl
    {
    public:
      Impl(int ii)
      : _M_i{ii}
      { }
    
    private:
    
      int _M_i;
    };
    
    Help::Help(int ii)
    : _M_impl{new Help::Impl{ii}}
    { }

I could compile these into a library just fine.  But when I try to use it in a test program I get

    ed@bad-horse:~/ext_distribution$ ../bin/bin/g++ -std=c++0x -o test_help test_help.cpp Help.cpp
    In file included from /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/memory:86:0,
                     from Help.h:4,
                     from test_help.cpp:3:
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h: In instantiation of &#39;void std::default_delete&lt;_Tp&gt;::operator()(_Tp*) const [with _Tp = Help::Impl]&#39;:
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h:245:4:   required from &#39;void std::unique_ptr&lt;_Tp, _Dp&gt;::reset(std::unique_ptr&lt;_Tp, _Dp&gt;::pointer) [with _Tp = Help::Impl; _Dp = std::default_delete&lt;Help::Impl&gt;; std::unique_ptr&lt;_Tp, _Dp&gt;::pointer = Help::Impl*]&#39;
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h:169:32:   required from &#39;std::unique_ptr&lt;_Tp, _Dp&gt;::~unique_ptr() [with _Tp = Help::Impl; _Dp = std::default_delete&lt;Help::Impl&gt;]&#39;
    Help.h:6:7:   required from here
    /home/ed/bin/lib/gcc/x86_64-unknown-linux-gnu/4.7.0/../../../../include/c++/4.7.0/bits/unique_ptr.h:63:14: error: invalid application of &#39;sizeof&#39; to incomplete type &#39;Help::Impl&#39;

This is a well known [safety feature][1].  I&#39;ve tried to follow.

My problem is that if I put Help::Impl declaration in a header it would seem to obviate any advantage of pimpl.  The class layout is visible to users.  The definition is hidden but I could have done that with the Help class and private members.  Also, including the declaration of Impl brings in new headers that I would have liked to keep separate.

What am I missing?  What do folks put in an Impl declaration and where?  Am I doing the Help dtor wrong?  Argh!

  [1]: https://stackoverflow.com/questions/6012157/does-stdunique-ptrt-requires-to-know-the-full-t-definition


How do I use unique_ptr for pimpl?

I&#39;m using the pimpl-idiom with `std::unique_ptr`:

    class window {
      window(const rectangle&amp; rect);
      
    private:
      class window_impl; // defined elsewhere
      std::unique_ptr&lt;window_impl&gt; impl_; // won&#39;t compile
    };

However, I get a compile error regarding the use of an incomplete type, on line 304 in `&lt;memory&gt;`:

&gt; Invalid application of &#39;`sizeof`&#39; to an incomplete type &#39;`uixx::window::window_impl`&#39;

For as far as I know, `std::unique_ptr` should be able to be used with an incomplete type. Is this a bug in libc++ or am I doing something wrong here?

std::unique_ptr with an incomplete type won&#39;t compile

Doesn&#39;t `std::unique_ptr::get` defeat the purpose of having a unique_ptr in the first place?
I would have expected this function to change its state so it holds no more pointer.
Is there an actual useful use of std::unique_ptr::get?

Content Type	Original Author	Original Content on Stackoverflow
Question	moshbear	View Question on Stackoverflow
Solution 1 - C++	Nicol Bolas	View Answer on Stackoverflow
Solution 2 - C++	Alok Save	View Answer on Stackoverflow

Difference between boost::scoped_ptr<T> and std::unique_ptr<T>

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

How do I make a portion of a Checkbox's text clickable?

Using querySelectorAll(). Is the result returned by the method ordered?

Attributions