Question: Could someone explain to a C++ programmer most important differences between Java (and C# as well) references and shared\_ptr (from Boost or from C++0x).

I more or less aware how shared\_ptr is implemented. I am curious about differences in the following ares:

1) Performance.
2) Cycling. shared\_ptr can be cycled (A and B hold pointers to each other). Is cycling possible in Java?
3) Anything else?

Thank you.

Answer: 
**Performance**: `shared_ptr` performs pretty well, but in my experience is slightly less efficient than explicit memory management, mostly because it is reference counted and the reference count has to allocated as well. How well it performs depends on a lot of factors and how well it compares to Java/C# garbage collectors can only be determined on a per use case basis (depends on language implementation among other factors).

**Cycling** is only possible with `weak_ptr`, not with two `shared_ptr`s. Java allows cycling without further ado; its garbage collector will [break the cycles](https://stackoverflow.com/questions/176745/circular-references-in-java). My guess is that C# does the same.

**Anything else**: the object pointed to by a `shared_ptr` is destroyed as soon as the last reference to it goes out of scope. The destructor is called immediately. In Java, the finalizer may not be called immediately. I don't know how C# behaves on this point.
First of all, Java/C# have only pointers, not references, though they call them that way. Reference is a unique C++ feature. Garbage collection in Java/C# basically means infinite life-time. `shared_ptr` on the other hand provides sharing and deterministic destruction, when the count goes to zero. Therefore, `shared_ptr` can be used to automatically manage any resources, not just memory allocation. In a sense (just like any RAII design) it turns pointer semantics into more powerful value semantics.