Use the &lt;a href=&quot;http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/shared_ptr.htm#get&quot;&gt;`get()`&lt;/a&gt; method:

    boost::shared_ptr&lt;foo&gt; foo_ptr(new foo());
    foo *raw_foo = foo_ptr.get();
    c_library_function(raw_foo);

Make sure that your `shared_ptr` doesn&#39;t go out of scope before the library function is done with it -- otherwise badness could result, since the library may try to do something with the pointer after it&#39;s been deleted.  Be especially careful if the library function maintains a copy of the raw pointer after it returns.

Another way to do it would be to use a combination of the `&amp;` and `*` operators:

    boost::shared_ptr&lt;foo&gt; foo_ptr(new foo());
    c_library_function( &amp;*foo_ptr);

While personally I&#39;d prefer to use the `get()` method (it&#39;s really the right answer), one advantage that this has is that it can be used with other classes that overload `operator*` (pointer dereference), but do not provide a `get()` method.  Might be useful in generic class template, for example.


    


For std::shared_ptr (C++11 onwards) also, there is a get method to obtain the raw pointer. [link](https://www.cplusplus.com/reference/memory/shared_ptr/get)

i&#39;d like to use a view i&#39;ve created in my database as the source for my django-view.

Is this possible, without using custom sql?


***\*\*\*13/02/09 UPDATE***********

Like many of the answers suggest, you can just make your own view in the database and then use it within the API by defining it in models.py.

some warning though:

 - manage.py syncdb will not work anymore
 - the view need the same thing at the start of its name as all the other models(tables) e.g if your app is called &quot;thing&quot; then your view will need to be called thing_$viewname

Can I use a database view as a model in Django?

Using a Python script, I need to read a CVS file where dates are formated as DD/MM/YYYY, and convert them to YYYY-MM-DD before saving this into a SQLite database.

This almost works, but fails because I don&#39;t provide time:

    from datetime import datetime
    
    lastconnection = datetime.strptime(&quot;21/12/2008&quot;, &quot;%Y-%m-%d&quot;)

    #ValueError: time data did not match format:  data=21/12/2008  fmt=%Y-%m-%d
    print lastconnection

I assume there&#39;s a method in the datetime object to perform this conversion very easily, but I can&#39;t find an example of how to do it. Thank you.

Converting date between DD/MM/YYYY and YYYY-MM-DD?

I have something like `shared_ptr&lt;Type&gt; t(makeSomething(), mem_fun(&amp;Type::deleteMe))`
I now need to call C styled function that requires a pointer to `Type`. How do I get it from `shared_ptr`?

getting a normal ptr from shared_ptr?

<p>I have something like <code>shared_ptr&#x3C;Type> t(makeSomething(), mem_fun(&#x26;Type::deleteMe))</code>
I now need to call C styled function that requires a pointer to <code>Type</code>. How do I get it from <code>shared_ptr</code>?</p>


I am using fully qualified name of the enum inside a method in one of my class. But I am getting compiler warning which says *&quot;warning C4482: nonstandard extension used: enum &#39;Foo&#39; used in qualified name&quot;*. In C++, do we need to use enums without the qualified name? But IMO, that looks ugly. 

Any thoughts?

Using enum inside types - Compiler warning C4482 C++

In my years of C++ (MFC) programming in I never felt the need to use `typedef`, so I don&#39;t really know what is it used for. Where should I use it? Are there any real situations where the use of `typedef` is preferred? Or is this really more a C-specific keyword?

When should I use typedef in C++?

It would be very useful to be able to overload the . operator in C++ and return a reference to an object.

You can overload `operator-&gt;` and `operator*` but not `operator.`

Is there a technical reason for this?

Why can&#39;t you overload the &#39;.&#39; operator in C++?

    int temp = 0x5E; // in binary 0b1011110.

Is there such a way to check if bit 3 in temp is 1 or 0 without bit shifting and masking.

Just want to know if there is some built in function for this, or am I forced to write one myself.

     

C/C++ check if one bit is set in, i.e. int variable

I have a small hierarchy of objects that I need to serialize and transmit via a socket connection.  I need to both serialize the object, then deserialize it based on what type it is.  Is there an easy way to do this in C++ (as there is in Java)?

Are there any C++ serialization online code samples or tutorials?

**EDIT:** Just to be clear, I&#39;m looking for methods on converting an object into an array of bytes, then back into an object.  I can handle the socket transmission.


How do you serialize an object in C++?

I dislike having magic boxes scattered all over my code...how exactly do these two classes work to allow basically any function to be mapped to a function object even if the function&lt;&gt; has a completely different parameter set to the one im passing to `boost::bind`

It even works with different calling conventions (i.e. member methods are `__thiscall` under VC, but &quot;normal&quot; functions are generally `__cdecl` or `__stdcall` for those that need to be compatible with C.

how boost::function and boost::bind work

Lots of the answers to C++ questions here contain the response:

&gt; &quot;You should be using boost::(insert
&gt; your favourite smart pointer here) or
&gt; even better boost::(insert your
&gt; favourite mega complex boost type
&gt; here)&quot;

I&#39;m not at all convinced that this is doing any favours to the questioners who, by and large, are obvious C++ novices. My reasons are as follows:

 - Using smart pointers without
   understanding what is going on under
   the hood is going to lead to a
   generation of C++ programmers who
   lack some of the basic skills of a
   programmer. Pretty much this seems to
   have happened in the Java field
   already.

 - Deciding which type of smart pointer
   to use depends very much on the
   problem domain being addressed. This
   is almost always missing from the
   questions posted here, so simply
   saying &quot;use a shared pointer&quot; is
   likely to be at the least unhelpful
   and possibly totally wrong.

 - Boost is not yet part of the C++
   standard and may not be available on
   the specific platform the questioner
   is using. Installing it is a bit
   painful (I just did it using [Jam][1]) and
   is way overkill if all you want are a
   few smart pointers.

 - If you are writing [FOSS][2] code, you
   don&#39;t want the code to be heavily
   dependent on external libraries that,
   once again, your users may not have.
   I&#39;ve been put off using FOSS code on
   a number of occasions simply because
   of the Byzantine complexity of the
   dependencies between libraries.

To conclude, I&#39;m not saying don&#39;t recommend Boost, but that we should be more careful when doing so.

  [1]: http://en.wikipedia.org/wiki/Perforce_Jam#Boost.jam
  [2]: http://en.wikipedia.org/wiki/Free_and_open_source_software


Boost considered harmful?

What is the difference between the following set of pointers? When do you use each pointer in production code, if at all?

Examples would be appreciated!

 1. `scoped_ptr`

 2. `shared_ptr`

 3. `weak_ptr`

 4. `intrusive_ptr`

Do you use boost in production code?

smart pointers (boost) explained

I&#39;m writing a server in C++ using Boost ASIO library. I&#39;d like to get the string representation of client IP to be shown in my server&#39;s logs. Does anyone know how to do it?

How to get IP address of boost::asio::ip::tcp::socket?

What&#39;s the equivalent to the following:

    std::vector&lt;Foo*&gt; vec;
    vec.push_back(NULL);

when dealing with `boost::shared_ptr`? Is it the following code?

    std::vector&lt; boost::shared_ptr&lt;Foo&gt; &gt; vec;
    vec.push_back(boost::shared_ptr&lt;Foo&gt;());

Note: I may push back a lot of such objects. Should I declare a global static `nullPtr` object somewhere? That way only one of them would have to be constructed:

    boost::shared_ptr&lt;Foo&gt; nullPtr;

NULL pointer with boost::shared_ptr?

I, and I think many others, have had great success using smart pointers to wrap up unsafe memory operations in C++, using things like RAII, et cetera. However, wrapping memory management is easier to implement when you have destructors, classes, operator overloading, et cetera.

For someone writing in raw C99, where could you point (no pun intended) to help with safe memory management?

Thanks.

Smart pointers/safe memory management for C?

 1. Will auto_ptr be deprecated in incoming C++ standard?
 2. Should unique_ptr be used for ownership transfer instead of shared_ptr?
 3. If unique_ptr is not in the standard, then do I need to use shared_ptr instead?

 

Is auto_ptr deprecated?

I am so frustrated right now after several hours trying to find where shared_ptr is located. None of the examples I see show complete code to include the headers for `shared_ptr` (and working). Simply stating `std`, `tr1` and `&lt;memory&gt;` is not helping at all! I have downloaded boosts and all but still it doesn&#39;t show up!  Can someone help me by telling exactly where to find it?

Thanks for letting me vent my frustrations!

EDIT:
I see my title has been changed. Sorry about that.
So... it was also because it was not clear to me that shared_ptr is &quot;C++ version dependant&quot; --&gt; that&#39;s why I did not state my environment --&gt; therefore probably why it was so difficult for me to find it.

I am working on MSVS2008.

EDIT 2:
I don&#39;t know why,  but I was including [memory] and [boost/tr1/memory.hpp] and [boost/tr1/tr1/memory] while looking everywhere for the shared_ptr.. of course, i couldn&#39;t.

Thanks for all the responses.

Where is shared_ptr?

What is wrong with this program?

    #include &lt;memory&gt;
    #include &lt;vector&gt;
    
    int main()
    {
    	std::vector&lt;std::unique_ptr&lt;int&gt;&gt; vec;
    
    	int x(1);
    	std::unique_ptr&lt;int&gt; ptr2x(&amp;x);
    	vec.push_back(ptr2x); //This tiny command has a vicious error.
    
    	return 0;
    }

The error:

    In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/mingw32/bits/c++allocator.h:34:0,
                     from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/allocator.h:48,
                     from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/memory:64,
                     from main.cpp:6:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function &#39;void __gnu_cxx::new_allocator&lt;_Tp&gt;::construct(_Tp*, const _Tp&amp;) [with _Tp = std::unique_ptr&lt;int&gt;, _Tp* = std::unique_ptr&lt;int&gt;*]&#39;:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_vector.h:745:6:   instantiated from &#39;void std::vector&lt;_Tp, _Alloc&gt;::push_back(const value_type&amp;) [with _Tp = std::unique_ptr&lt;int&gt;, _Alloc = std::allocator&lt;std::unique_ptr&lt;int&gt; &gt;, value_type = std::unique_ptr&lt;int&gt;]&#39;
    main.cpp:16:21:   instantiated from here
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h:207:7: error: deleted function &#39;std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;::unique_ptr(const std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;&amp;) [with _Tp = int, _Tp_Deleter = std::default_delete&lt;int&gt;, std::unique_ptr&lt;_Tp, _Tp_Deleter&gt; = std::unique_ptr&lt;int&gt;]&#39;
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/ext/new_allocator.h:105:9: error: used here
    In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/vector:69:0,
                     from main.cpp:7:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function &#39;void std::vector&lt;_Tp, _Alloc&gt;::_M_insert_aux(std::vector&lt;_Tp, _Alloc&gt;::iterator, _Args&amp;&amp; ...) [with _Args = {const std::unique_ptr&lt;int&gt;&amp;}, _Tp = std::unique_ptr&lt;int&gt;, _Alloc = std::allocator&lt;std::unique_ptr&lt;int&gt; &gt;, std::vector&lt;_Tp, _Alloc&gt;::iterator = __gnu_cxx::__normal_iterator&lt;std::unique_ptr&lt;int&gt;*, std::vector&lt;std::unique_ptr&lt;int&gt; &gt; &gt;, typename std::vector&lt;_Tp, _Alloc&gt;::_Base::_Tp_alloc_type::pointer = std::unique_ptr&lt;int&gt;*]&#39;:
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_vector.h:749:4:   instantiated from &#39;void std::vector&lt;_Tp, _Alloc&gt;::push_back(const value_type&amp;) [with _Tp = std::unique_ptr&lt;int&gt;, _Alloc = std::allocator&lt;std::unique_ptr&lt;int&gt; &gt;, value_type = std::unique_ptr&lt;int&gt;]&#39;
    main.cpp:16:21:   instantiated from here
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h:207:7: error: deleted function &#39;std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;::unique_ptr(const std::unique_ptr&lt;_Tp, _Tp_Deleter&gt;&amp;) [with _Tp = int, _Tp_Deleter = std::default_delete&lt;int&gt;, std::unique_ptr&lt;_Tp, _Tp_Deleter&gt; = std::unique_ptr&lt;int&gt;]&#39;
    c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/vector.tcc:314:4: error: used here

Why can I not push_back a unique_ptr into a vector?

What is the equivalent of a `static_cast` with `boost::shared_ptr`?

In other words, how do I have to rewrite the following 

    Base* b = new Derived();
    Derived* d = static_cast&lt;Derived*&gt;(b);

when using `shared_ptr`?

    boost::shared_ptr&lt;Base&gt; b(new Derived());
    boost::shared_ptr&lt;Derived&gt; d = ???




static_cast with boost::shared_ptr?

Are there any downsides with using `make_shared&lt;T&gt;()` instead of using `shared_ptr&lt;T&gt;(new T)`.

[Boost documentation][1] states 

&gt; There have been repeated requests from
&gt; users for a factory function that
&gt; creates an object of a given type and
&gt; returns a shared_ptr to it. Besides
&gt; convenience and style, such a function
&gt; is also exception safe and
&gt; considerably faster because it can use
&gt; a single allocation for both the
&gt; object and its corresponding control
&gt; block, eliminating a significant
&gt; portion of shared_ptr&#39;s construction
&gt; overhead. This eliminates one of the
&gt; major efficiency complaints about
&gt; shared_ptr.

  [1]: http://www.boost.org/doc/libs/1_41_0/libs/smart_ptr/make_shared.html

Are there any downsides with using make_shared to create a shared_ptr

I use std::tr1::shared_ptr extensively throughout my application. This includes passing objects in as function arguments. Consider the following:

    class Dataset {...}

    void f( shared_ptr&lt; Dataset const &gt; pds ) {...}
    void g( shared_ptr&lt; Dataset const &gt; pds ) {...}
    ...

While passing a dataset object around via shared_ptr guarantees its existence inside f and g, the functions may be called millions of times, which causes a lot of shared_ptr objects being created and destroyed. Here&#39;s a snippet of the flat gprof profile from a recent run:

&lt;pre&gt;
Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total
 time   seconds   seconds    calls   s/call   s/call  name
  9.74    295.39    35.12 2451177304     0.00     0.00  std::tr1::__shared_count&lt;(__gnu_cxx::_Lock_policy)2&gt;::__shared_count(std::tr1::__shared_count&lt;(__gnu_cxx::_Lock_policy)2&gt; const&amp;)
  8.03    324.34    28.95 2451252116     0.00     0.00  std::tr1::__shared_count&lt;(__gnu_cxx::_Lock_policy)2&gt;::~__shared_count()
&lt;/pre&gt;

So, ~17% of the runtime was spent on reference counting with shared_ptr objects. Is this normal?

A large portion of my application is single-threaded and I was thinking about re-writing some of the functions as
    
    void f( const Dataset&amp; ds ) {...}

and replacing the calls

    shared_ptr&lt; Dataset &gt; pds( new Dataset(...) );
    f( pds );

with

    f( *pds );

in places where I know for sure the object will not get destroyed while the flow of the program is inside f(). But before I run off to change a bunch of function signatures / calls, I wanted to know what the typical performance hit of passing by shared_ptr was. Seems like shared_ptr should not be used for functions that get called very often.

Any input would be appreciated. Thanks for reading.

-Artem

**Update:** After changing a handful of functions to accept `const Dataset&amp;`, the new profile looks like this:
&lt;pre&gt;
Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total
 time   seconds   seconds    calls   s/call   s/call  name
  0.15    241.62     0.37 24981902     0.00     0.00  std::tr1::__shared_count&lt;(__gnu_cxx::_Lock_policy)2&gt;::~__shared_count()
  0.12    241.91     0.30 28342376     0.00     0.00  std::tr1::__shared_count&lt;(__gnu_cxx::_Lock_policy)2&gt;::__shared_count(std::tr1::__shared_count&lt;(__gnu_cxx::_Lock_p\
olicy)2&gt; const&amp;)
&lt;/pre&gt;

I&#39;m a little puzzled by the number of destructor calls being smaller than the number of copy constructor calls, but overall I&#39;m very pleased with the decrease in the associated run-time. Thanks to all for their advice.


Content Type	Original Author	Original Content on Stackoverflow
Question	user34537	View Question on Stackoverflow
Solution 1 - C++	Adam Rosenfield	View Answer on Stackoverflow
Solution 2 - C++	Michael Burr	View Answer on Stackoverflow
Solution 3 - C++	cmp	View Answer on Stackoverflow

getting a normal ptr from shared_ptr?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Converting date between DD/MM/YYYY and YYYY-MM-DD?

Can I use a database view as a model in Django?

Attributions