class Sample
{
    Sample& m_self;
public:
    Sample() : m_self(*this)
    {}

    static void Test(Sample& sample)
    {}

    void Func1() const
    {
        Test(m_self);/////////////////////////////////////////////////////No error!
    }
    void Func2() const
    {
        Test(*this);//error C2664
    }
} sample;

А>    void Func1() const
А>    {
А>        Test(m_self);/////////////////////////////////////////////////////No error!
А>    }
А>

3.9.3/3 Each non-static, non-mutable, non-reference data member of a const-qualified class object is const-qualified.

struct A
{
    void func() { };
};

struct B
{
    A& a;
    B(A& a) : a(a) { }
    void func() const
    {
        a.func();
    }
};

int main()
{
    A a;
    B b(a);
    b.func();
}

struct IsAllOk {
    IsAllOk() : pReadCount( new int( 0 ) ) {}
    ~IsAllOk() { delete pReadCount;}

    int Read() const { return ++*pReadCount; }

private:
    IsAllOk( const IsAllOk& );
    void operator = ( const sAllOk& );

    int pReadCount;

};

int *pReadCount;

А>class Sample
А>{
А>    Sample& m_self;
А>public:
А>
А>  Sample() : m_self(*this) { }
А>    
А>  static void Test(Sample& sample) { }
А>
А>  void Func1() const { Test(m_self); } // No error!
А>
А>} sample;
А>

Sample s1;
Sample s2 = s1;

struct IsAllOk {
E>    IsAllOk() : pReadCount( new int( 0 ) ) {}
E>    ~IsAllOk() { delete pReadCount;}

E>    int Read() const { return ++*pReadCount; }

E>private:
E>    IsAllOk( const IsAllOk& );
E>    void operator = ( const sAllOk& );

E>    int pReadCount;

E>};

return *pReadCount++;

Sample() : m_self(*this)

const Sample foo;
const Sample& bar = foo;

const Sample foo;
Sample& bar = foo;

#include <iostream>
using namespace std;

class Foo
{
 Foo& _self;
 int _n; // Можно было объявить как mutable и не париться, но мы комсомольцы, мы учимся трудности преодолевать

public:
 Foo(): _self(*this), _n(0) {};
 int bar() const {return _self._n++;}
};

int main()
{
 {
  Foo foo;
  cout << foo.bar() << endl;
  cout << foo.bar() << endl;
  cout << foo.bar() << endl;
  }
{
  const Foo foo;
  cout << foo.bar() << endl;
  cout << foo.bar() << endl;
  cout << foo.bar() << endl;
  }
}