const키워드를 메소드에 추가하면 this포인터는 기본적으로 const객체에 대한 포인터가 되므로 멤버 데이터를 변경할 수 없습니다. (를 사용하지 않으면 mutable나중에 자세히 설명).

const키워드는 두 개의 유사한 방법, 객체 인 경우라고 하나 구현할 수 있다는 것을 의미 기능 서명의 일부 const, 그리고 하나를.

#include <iostream>

class MyClass
{
private:
    int counter;
public:
    void Foo()
    { 
        std::cout << "Foo" << std::endl;    
    }

    void Foo() const
    {
        std::cout << "Foo const" << std::endl;
    }

};

int main()
{
    MyClass cc;
    const MyClass& ccc = cc;
    cc.Foo();
    ccc.Foo();
}

출력됩니다

Foo
Foo const

비 const 메소드에서는 const버전 에서 할 수없는 인스턴스 멤버를 변경할 수 있습니다 . 위의 예제에서 메소드 선언을 아래 코드로 변경하면 약간의 오류가 발생합니다.

    void Foo()
    {
        counter++; //this works
        std::cout << "Foo" << std::endl;    
    }

    void Foo() const
    {
        counter++; //this will not compile
        std::cout << "Foo const" << std::endl;
    }

멤버를 표시 할 수 mutable있고 const메서드를 변경할 수 있기 때문에 이는 사실이 아닙니다 . 내부 카운터 및 물건에 주로 사용됩니다. 그 해결책은 아래 코드입니다.

#include <iostream>

class MyClass
{
private:
    mutable int counter;
public:

    MyClass() : counter(0) {}

    void Foo()
    {
        counter++;
        std::cout << "Foo" << std::endl;    
    }

    void Foo() const
    {
        counter++;    // This works because counter is `mutable`
        std::cout << "Foo const" << std::endl;
    }

    int GetInvocations() const
    {
        return counter;
    }
};

int main(void)
{
    MyClass cc;
    const MyClass& ccc = cc;
    cc.Foo();
    ccc.Foo();
    std::cout << "Foo has been invoked " << ccc.GetInvocations() << " times" << std::endl;
}

어떤 출력

Foo
Foo const
Foo has been invoked 2 times

답변

const foobar fb;
fb.foo();

class foobar {
  ...
  const char* bar();
}

void func1(const foobar& fb1, foobar& fb2) {
  const char* v1 = fb1.bar();  // won't compile
  const char* v2 = fb2.bar();  // works
}

foobar& fbNonConst = const_cast<foobar&>(fb1);

class A
{
public:
    A():member_()
    {
    }

    int hashGetter() const
    {
        state_ = 1;
        return member_;
    }
    int goodGetter() const
    {
        return member_;
    }
    int getter() const
    {
        //member_ = 2; // error
        return member_;
    }
    int badGetter()
    {
        return member_;
    }
private:
    mutable int state_;
    int member_;
};

int main()
{
    const A a1;
    a1.badGetter(); // doesn't work
    a1.goodGetter(); // works
    a1.hashGetter(); // works

    A a2;
    a2.badGetter(); // works
    a2.goodGetter(); // works
    a2.hashGetter(); // works
}

class foobar
{
  public:
     operator int () const;
     const char* foo() const;
};

class foobar
{
  public:
     operator int (const foobar * const this) const;
     const char* foo(const foobar * const this) const;
};