S>public static void EpicFail(HugeBitmap bmp)
S>{
S>  RefCounter<HugeBitmap> c;
S>  using(var a = new RefCounter<HugeBitmap>(bmp)); // bmp.refCount++;
S>    {
S>      var b = new RefCounter(a); // bmp.refCount++
S>      c = a; // oops... вот в этот момент С++ инкрементирует указатель. С# - нет.
S>    b.Dispose(); //bmp.refCount-- 
S>    } // bmp.refCount-- => bmp.Release()
S>    c.Reference.Draw(); // InvalidOperationException!
S>}
S>

S>c = a; // oops... вот в этот момент С++ инкрементирует указатель. С# - нет.

int* q = new int(3);
int* p = q;
*q = 42;
cout << *p << endl;  // «oops...» © Как же так, а куда делась старая тройка? Я ж её сохранил посредством p?

c = a;

c.Assign(a);

std::tr1::shared_ptr<int const> const q(p.get());

std::tr1::shared_ptr<int const> const q(p);

using (StreamReader s = ...)
{

} // Dispose здесь «решает ту же проблему: забыли освободить ресурс нормальным образом.» ©

void foo(RefCounter<HugeBitmap> hugeBitmap);

using (RefCounter<HugeBitmap> hugeBitmap = new RefCounter<HugeBitmap>(new HugeBitmap()))
{
   foo(hugeBitmap.Clone()); // правильно
   //foo(hugeBitmap); // ошибка
}

D>Это всё, конечно, очень интересно, но только причём здесь свойства-то ?

D>Ну наваяли Вы какую-то инфраструктуру, и что ? Частью языка она ведь от этого не стала. Обычные классы. На .NET/C# всё можно сделать аналогично, но только чуть лучше Бо есть свойства, и можно связать их с полученным framework'ом. Более того, такие вещи уже давно входят в комплект — в WPF и WF есть могучая конструкция DependencyProperty, например.

public class MyStateControl : ButtonBase
{
  public MyStateControl() : base() { }
  public Boolean State
  {
    get { return (Boolean)this.GetValue(StateProperty); }
    set { this.SetValue(StateProperty, value); } 
  }
  public static readonly DependencyProperty StateProperty = DependencyProperty.Register(
    "State", typeof(Boolean), typeof(MyStateControl),new PropertyMetadata(false));
}

Dependency properties and the WPF property system extend property functionality by providing a type that backs a property, as an alternative implementation to the standard pattern of backing the property with a private field. The name of this type is DependencyProperty. The other important type that defines the WPF property system is DependencyObject. DependencyObject defines the base class that can register and own a dependency property.

Following is a summation of the terminology that is used in this software development kit (SDK) documentation when discussing dependency properties:

*Dependency property: A property that is backed by a DependencyProperty.
*Dependency property identifier: A DependencyProperty instance, which is obtained as a return value when registering a dependency property, and then stored as a member of a class. This identifier is used as a parameter in many of the APIs that interact with the WPF property system.
*CLR "wrapper": The actual get and set implementations for the property. These implementations incorporate the dependency property identifier by using it in the GetValue and SetValue calls, thus providing the backing for the property using the WPF property system.

using (StreamReader s = ...)
{

} // Dispose здесь «решает ту же проблему: забыли освободить ресурс нормальным образом.» ©

obj.prop = 42;
int n = obj.prop;

obj.prop.set(42);
int n = obj.prop.get();

void foo(bitmap const& b);

void foo(shared_ptr<bitmap> b);

void foo(shared_ptr<bitmap> const& b);