Use `boost::static_pointer_cast`:

    boost::shared_ptr&lt;Base&gt; b(new Derived());
    boost::shared_ptr&lt;Derived&gt; d = boost::static_pointer_cast&lt;Derived&gt;(b);



There are three cast operators for smart pointers: `static_pointer_cast`, `dynamic_pointer_cast`, and `const_pointer_cast`.  They are either in namespace `boost` (provided by `&lt;boost/shared_ptr.hpp&gt;`) or namespace `std::tr1` (provided either by Boost or by your compiler&#39;s TR1 implementation).

As a comment: if Derived does in fact derive from Base, then you should use a dynamic_pointer_cast rather than static casts. The system will have a chance of detecting when/if your cast is not correct.


It is worth to mention that the there is difference in the number of casting operators provided by Boost and implementations of TR1. 

The TR1 does not define the third operator const_pointer_cast()

Is there a Maven alternative or port for the .NET world? 

I would love to use a good dependency management system that the Java world has, but I don&#39;t find anything comparable for .NET projects...


Is there a Maven alternative or port for the .NET world?

This might be a really trivial question, but I&#39;ve been writing Java programs at my school and I just found out that I can create websites with Java as well. 

 - How can I do that? Any good books/tutorials for that? 
 - Which is better for Web development, Java or PHP? 
 - Also, when using PHP, MySQL comes into picture and while writing Java programs for desktop, we just use File I/O, so what is better for web dev, File I/O or MySQL?

How do you make websites with Java?

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?

What is the equivalent of a <code>static_cast</code> with <code>boost::shared_ptr</code>?
In other words, how do I have to rewrite the following
<pre><code class="hljs language-ini">Base* b = new Derived();
Derived* d = static_cast&#x3C;Derived*>(b);
</code></pre>
when using <code>shared_ptr</code>?
<pre><code class="hljs language-arduino">boost::shared_ptr&#x3C;Base> b(new Derived());
boost::shared_ptr&#x3C;Derived> d = ???
</code></pre>

I often find myself in a situation where I am facing multiple compilation/linker errors in a C++ project due to some bad design decisions (made by someone else :) ) which lead to circular dependencies between C++ classes in different header files *(can happen also in the same file)*. But fortunately(?) this doesn&#39;t happen often enough for me to remember the solution to this problem for the next time it happens again.

So for the purposes of easy recall in the future I am going to post a representative problem and a solution along with it. Better solutions are of-course welcome.

----
 * `A.h`

        class B;
        class A
        {
            int _val;
            B *_b;
        public:

            A(int val)
                :_val(val)
            {
            }

            void SetB(B *b)
            {
                _b = b;
                _b-&gt;Print(); // COMPILER ERROR: C2027: use of undefined type &#39;B&#39;
            }

            void Print()
            {
                cout&lt;&lt;&quot;Type:A val=&quot;&lt;&lt;_val&lt;&lt;endl;
            }
        };

----
 * `B.h`

        #include &quot;A.h&quot;
        class B
        {
            double _val;
            A* _a;
        public:

            B(double val)
                :_val(val)
            {
            }

            void SetA(A *a)
            {
                _a = a;
                _a-&gt;Print();
            }

            void Print()
            {
                cout&lt;&lt;&quot;Type:B val=&quot;&lt;&lt;_val&lt;&lt;endl;
            }
        };

----
 * `main.cpp`

        #include &quot;B.h&quot;
        #include &lt;iostream&gt;
       
        int main(int argc, char* argv[])
        {
            A a(10);
            B b(3.14);
            a.Print();
            a.SetB(&amp;b);
            b.Print();
            b.SetA(&amp;a);
            return 0;
        }



Resolve build errors due to circular dependency amongst classes

Does the ANSI standard *mandate* the logical operators to be short-circuited, in either C or C++?

I&#39;m confused for I recall the K&amp;R book saying your code shouldn&#39;t depend on these operations being short circuited, for they may not. Could someone please point out where in the standard it&#39;s said logic ops are always short-circuited? I&#39;m mostly interested on C++, an answer also for C would be great.

I also remember reading (can&#39;t remember where) that evaluation order isn&#39;t strictly defined, so your code shouldn&#39;t depend or assume functions within an expression would be executed in a specific order: by the end of a statement all referenced functions will have been called, but the compiler has freedom in selecting the most efficient order.

Does the standard indicate the evaluation order of this expression?

    if( functionA() &amp;&amp; functionB() &amp;&amp; functionC() ) cout&lt;&lt;&quot;Hello world&quot;;

Is short-circuiting logical operators mandated? And evaluation order?

How does the compiler fill values in `char array[100] = {0};`? What&#39;s the magic behind it?

I wanted to know how internally compiler initializes.

how does array[100] = {0} set the entire array to 0?

Is it wrong to write:

    class A {
    public:
        virtual ~A() = 0;
    };

for an abstract base class?

At least that compiles in MSVC... Will it crash at run time?



Pure virtual destructor in C++

I&#39;d like to have access to the `$HOME` environment variable in a C++ program that I&#39;m writing. If I were writing code in C, I&#39;d just use the `getenv()` function, but I was wondering if there was a better way to do it. Here&#39;s the code that I have so far:


    std::string get_env_var( std::string const &amp; key ) {                                 
        char * val;                                                                        
        val = getenv( key.c_str() );                                                       
        std::string retval = &quot;&quot;;                                                           
        if (val != NULL) {                                                                 
            retval = val;                                                                    
        }                                                                                  
        return retval;                                                                        
    }           

Should I use `getenv()` to access environment variables in C++? Are there any problems that I&#39;m likely to run into that I can avoid with a little bit of knowledge?

Accessing Environment Variables In C++

I ran across `enable_shared_from_this` while reading the Boost.Asio examples and after reading the documentation I am still lost for how this should correctly be used.  Can someone please give me an example and explanation of when using this class makes sense.

What is the usefulness of `enable_shared_from_this`?

The Windows API function `CopyFile` has an argument `BOOL bFailIfExists` that allows you to control whether or not you want to overwrite the target file if it exists. 

The `boost::filesystem` `copy_file` function has no such argument, and will fail if the target file exists. Is there an elegant way to use the boost copy_file function and overwrite the target file? Or is it better to simply use the Windows API? My current target platform is Windows, but I prefer to use STL and boost where possible to keep my code platform independent. 

Thank you.
  

how to perform boost::filesystem copy_file with overwrite

I have a multithreaded app that has to read some data often, and occasionally that data is updated. Right now a mutex keeps access to that data safe, but it&#39;s expensive because I would like multiple threads to be able to read simultaneously, and only lock them out when an update is needed (the updating thread could wait for the other threads to finish).

I think this is what `boost::shared_mutex` is supposed to do, but I&#39;m not clear on how to use it, and haven&#39;t found a clear example.

Does anyone have a simple example I could use to get started?

Example for boost shared_mutex (multiple reads/one write)?

I have been working with the [Boost C++ Libraries][1] for quite some time. I absolutely love the Boost [Asio C++ library][2] for network programming. However I was introduced to two other libraries: [POCO ][3] and [Adaptive Communication Environment (ACE) framework][4]. I would like to know the good and bad of each.

  [1]: http://en.wikipedia.org/wiki/Boost_C++_Libraries
  [2]: http://en.wikipedia.org/wiki/Asio_C++_library
  [3]: http://pocoproject.org
  [4]: http://en.wikipedia.org/wiki/Adaptive_Communication_Environment


ACE vs Boost vs POCO

Is there any good way (and a simple way too) using Boost to read and write XML files?

I can&#39;t seem to find any simple sample to read XML files using Boost. Can you point me a simple sample that uses Boost for reading and writing XML files?

If not Boost, is there any good and simple library to read and write XML files that you can recommend? (it must be a C++ library)

Using Boost to read and write XML files

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.


The cost of passing by shared_ptr

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?

When a function takes a `shared_ptr` (from boost or C++11 STL), are you passing it:

  - by const reference: `void foo(const shared_ptr&lt;T&gt;&amp; p)`

  - or by value: `void foo(shared_ptr&lt;T&gt; p)` ?

I would prefer the first method because I suspect it would be faster. But is this really worth it or are there any additional issues?

Could you please give the reasons for your choice or if the case, why you think it does not matter.


Should we pass a shared_ptr by reference or by value?

Hi I asked a question today about [How to insert different types of objects in the same vector array ][1] and my code in that question was 

     gate* G[1000];
    G[0] = new ANDgate() ;
    G[1] = new ORgate;
    //gate is a class inherited by ANDgate and ORgate classes
    class gate
    {
     .....
     ......
     virtual void Run()
       {   //A virtual function
       }
    };
    class ANDgate :public gate 
      {.....
       .......
       void Run()
       {
        //AND version of Run
       }  

    };
     class ORgate :public gate 
      {.....
       .......
       void Run()
       {
        //OR version of Run
       }  

    };      
    //Running the simulator using overloading concept
     for(...;...;..)
     {
      G[i]-&gt;Run() ;  //will run perfectly the right Run for the right Gate type
     } 
and I wanted to use vectors so someone wrote that I should do that :

    std::vector&lt;gate*&gt; G;
    G.push_back(new ANDgate); 
    G.push_back(new ORgate);
    for(unsigned i=0;i&lt;G.size();++i)
    {
      G[i]-&gt;Run();
    }

but then he and many others suggested that I would better use [Boost pointer containers  
][2] or `shared_ptr`. I have spent the last 3 hours reading about this topic, but the documentation seems pretty advanced to me . ****Can anyone give me a small code example of `shared_ptr` usage and why they suggested using `shared_ptr`. Also are there other types like `ptr_vector`, `ptr_list` and `ptr_deque`**  **

  
Edit1: I have read a code example too that included:

    typedef boost::shared_ptr&lt;Foo&gt; FooPtr;
    .......
    int main()
    {
      std::vector&lt;FooPtr&gt;         foo_vector;
    ........
    FooPtr foo_ptr( new Foo( 2 ) );
      foo_vector.push_back( foo_ptr );
    ...........
    }

And I don&#39;t understand the syntax!





[1]: https://stackoverflow.com/questions/3475030/different-types-of-objects-in-the-same-vector-array
  [2]: http://www.boost.org/doc/libs/1_43_0/libs/ptr_container/doc/guidelines.html

Example to use shared_ptr?

Is there any reason to prefer `static_cast&lt;&gt;` over C style casting? Are they equivalent? Is there any sort of speed difference?

What is the difference between static_cast&lt;&gt; and C style casting?

I have three classes:

    class A {};
    
    class B : virtual public A {};
    class C : virtual public A {};
    
    class D: public B, public C {};

Attempting a static cast from A* to B* I get the below error:

    cannot convert from base A to derived type B via virtual base A

C++ cannot convert from base A to derived type B via virtual base A

Apparently the compiler considers them to be unrelated types and hence `reinterpret_cast` is required. Why is this the rule?

Why can&#39;t I static_cast between char * and unsigned char *?

Considering the [following code][1] (and the fact that [`VirtualAlloc()` returns a `void*`][2]):

    BYTE* pbNext = reinterpret_cast&lt;BYTE*&gt;(
        VirtualAlloc(NULL, cbAlloc, MEM_COMMIT, PAGE_READWRITE));

why is `reinterpret_cast` chosen instead of `static_cast`?

I used to think that `reinterpret_cast` is OK for e.g. casting pointers to and from integer types (like e.g. `DWORD_PTR`), but to cast from a `void*` to a `BYTE*`, isn&#39;t `static_cast` OK?

Are there any (subtle?) differences in this particular case, or are they just both valid pointer casts?

Does the C++ standard have a preference for this case, suggesting a way instead of the other?



  [1]: http://blogs.msdn.com/b/oldnewthing/archive/2005/05/19/420038.aspx
  [2]: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366887%28v=vs.85%29.aspx

Content Type	Original Author	Original Content on Stackoverflow
Question	Frank	View Question on Stackoverflow
Solution 1 - C++	Frank	View Answer on Stackoverflow
Solution 2 - C++	Michael Kristofik	View Answer on Stackoverflow
Solution 3 - C++	David Rodríguez - dribeas	View Answer on Stackoverflow
Solution 4 - C++	mloskot	View Answer on Stackoverflow

static_cast with boost::shared_ptr?

C++ Problem Overview

C++ Solutions

Solution 1 - C++

Solution 2 - C++

Solution 3 - C++

Solution 4 - C++

How do you make websites with Java?

Is there a Maven alternative or port for the .NET world?

Attributions