#include<iostream>
#include<iomanip>

using namespace std;

class R{
public:
    R(int r1, int r2):r1(r1),r2(r2){

    }
    void print();
    void print() const; //常成员函数 

private:
    int r1,r2;
};

void R::print()
{
cout << r1 << ","<< r2<<endl;
}
void R::print() const //常成员函数的实现 
{
cout << r1<<"," <<  r2<<endl;
}
int main(){
R a(5,4);
a.print();
R const b(3,4); // 是常对象，不能被更新 
b.print();//调用常成员函数 
return 0;
} 

常对象
常对象必须在定义对象时就指定对象为常对象。
常对象中的数据成员为常变量且必须要有初始值，如
Time const t1(12,34,36); //定义t1为常对象
这样的话，在所有的场合中，对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象，可以声明为常对象。
定义常对象的一般形式为
类名    const    对象名(实参列表);
也可以把const写在最左面
const    类名    对象名(实参列表);
二者等价
如果一个对象被声明为常对象，则不能调用该对象的非const型的成员函数(除了由系统自动调用的隐式构造函数和析构函数)。
否则就会报错
这样做是为了方式非const型的成员函数修改常对象中的数据成员的值，因为const型的成员函数是不可以修改对象中的数据成员的值的(这个后面还会说到)。
那么，怎样才能引用常变量中的数据成员呢？很简单，我们只需要将该成员函数声明称const型的成员函数(常成员函数)即可。
void Print() const;
常成员函数可以访问常对象中的数据成员，但仍然不允许修改常对象中数据成员的值。
有时在编程时有要求，一定要修改常对象成员中的某个数据成员的值(例如类中有一个用于计数的变量count，其值应当不能变化)，
对该数据成员声明为mutable，如
mutable int count;//定义一个在常对象中可以被改变的数据成员
把count声明为可变的数据成员，这样就可以用声明为const的成员函数来修改它的值。
=========================一个简单的示例程序1.1====================================
#include
using namespace std;
class Student
{
 public:
  Student(int n,float s):num(n),score(s){}
  void change(int n,float s) const{num=n;score=s;}
  void display() const{cout<
 private:
  mutable int num;
  mutable float score;
} ;
int main()
{
 Student const stud(101,78.5);
 stud.display();
 stud.change(101,80.5);
 stud.display();
 return 0;
};
我们定义了常对象stud，然后分别调用了两个常函数display()和change()，但是在change函数中要修改常对象中的num和score的值，所以我们将num和score定义为mutable.
常对象成员
1.常数据成员其作用和用法与一般常变量相似，用关键字const来声明常数据成员。常数据成员的值是不能改变的。
只能通过构造函数的参数初始化表对常数据成员进行初始化。
在类体中声明常数据成员
const int num;//声明hour为常数据成员
在类外定义构造函数
Student::Student(int n,float s):num(n),score(s){} //通过参数初始化表对常数据成员num和score初始化
在类体中声明了某一个数据成员为常数据成员后，该类所有对象中的该数据成员的值都是不能改变的，但不同对象中该变量成员的值可以是不同的(分别在初始化时指定)。
2.常成员函数
如果将成员函数声明为常成员函数，则只能引用本类中的数据成员，而不能修改它们。
注意：常对象只能引用常成员函数
常成员函数的定义形式：
void Print() const;//注意const的位置在函数名和括号之后
const是函数类型的一部分，在声明函数和定义函数都要有const关键字，在调用时不必加const。
常成员函数可以const数据成员，也可以引用非const数据成员，但是都不能修改他们；
不是常成员函数的函数可以调用const数据成员，但是不能修改它们，也可以调用非const数据成员，并且可以修改它们。
具体情况，如图1：
还要注意一下三点：1.不要误认为常对象中的成员函数都是常成员函数，常对象只保证其所有数据成员的值不被修改。
2.如果在常对象中的成员函数未加const声明，则编译系统会把它当最非const成员函数处理。
3.还要注意，常成员函数不能调用另外一个非cosnt成员函数。

**



1，常对象

** 

在定义对象时加关键字const，指定对象为常对象，常对象必须要有初值，定义后就不可修改。



Time const t1(10, 20, 30);//定义t1是常对象
const Time t1(10, 20, 30);//等价

说明：（1）如果一个对象被声明为常对象，则通过该对象只能调用它的常成员函数，而不能调用该对象的普通成员函数（出了由系统自动调用的隐式的构造函数和析构函数）。常成员呢函数是常对象唯一的对外接口。 

（2）常成员函数可以访问常对象中的数据成员，但仍然不允许修改对象中数据成员的值。 

  （关于常成员函数会在下文中介绍）



2，常对象成员

可以将类的对象的成员声明为const,包括常数据成员和常成员函数 

1，常数据成员 

常数据成员的值不能改变，只能通过构造函数的参数初始化列表对常数据成员进行初始化，任何其他函数都不能对常数据成员赋值。



class Time
{
public:
    Time(int h)
        :hour(h)//通过构造函数初始化列表初始化常数据成员
    {
        //hour = h;//非法，不能对其赋值
    }
private:
    const int hour;//定义常数据成员
};

2，常成员函数 

如果将成员函数声明为常成员函数，则只能引用本类中的数据成员，而不能修改它们



void get_time()const;//注意const的位置在函数名和括号之后



class Time
{
public:
    void gettime()const
    {
        _year = 2016;//报错
    }
private:
    int _year;
};

class Time
{
public:
    void Funtest()
    {
        gettime();//通过
    }

    void gettime()const
    {
        Funtest();//报错，常成员函数不能调用非常成员函数
    }
};


下面用一张表来说明常成员函数的用法 


注意：常对象只保证其数据成员是常数据成员，其值不被修改，如果在常对象中的成员函数未加const声明，编译系统把它作为非const成员函数处理。 

有时在编程时有要求，一定要修改常对象中某个数据成员的值，则可将该数据成员声明为mutable,如：



mutable int count；

**



3，指向对象的常指针

** 

将指针变量声明为const型，这样指针变量始终保持为初值，不能改变，即其指向不变，如：



class Date
{
public:
    Date();
    Date(int y, int m, int d)
    :_year(y), _month(m), _day(d){}
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1(2017, 3, 20), d2;
    Date *const ptr = &d1;//ptr指向对象d1,伺候不能再改变指向
    ptr = &d2;//错误
}

往往用常指针作为函数的形参，目的是不允许函数在执行过程中改变指针变量的值，使其始终指向原来的对象 

（1），如果一个对象已被声明为常对象，只能用指向常对象的指针变量指向它，而不能用非const的指针变量指向它。 

（2），如果定义了一个指向常对象的指针变量，并使它指向一个非const的对象，则其指向的对象时不能通过该指针变量来改变的。如：



int main()
{
    Date d(2017, 3, 25);
    const Date *p = &d;
    d._year = 2016;//合法
    //(*p)._year = 2016;//非法
}

int main()
{
    void fun(const Date *);
    Date d(2016, 2, 22);
    fun(&d);
    return 0;
}

（3），指向常对象的指针最常用于函数的形参，目的是在保护形参指针所指向的对象，使它在函数执行过程中不被修改



void fun(const Date *p)//形参的性质不允许改变p所指向的对象的值
{
    //p->_year = 2015;//错误
    cout << p->_year << endl;
}

下面用一张表说明指针变量做形参使形参和实参的对应关系 


**



4，对象的常引用

**

class Time
{
public:
    Time(int h, int m, int s)
        :hour(h), minute(m), sec(s){}
    int hour;
    int minute;
    int sec;
};

void Fun(const Time &t)//形参为const则不能修改
{
    t.hour = 18;//报错
}

int main()
{
    Time t1(10, 13, 56);
    Fun(t1);
    cout << t1.hour << endl;
    system("pause\n");
    return 0;
}



下面用表格来小结有关const的知识 

常对象

常对象必须在定义对象时就指定对象为常对象。
常对象中的数据成员为常变量且必须要有初始值，如
Time const t1(12,34,36); //定义t1为常对象
这样的话，在所有的场合中，对象t1中的所有数据成员的值都不能被修改。凡希望保证数据成员不被改变的对象，可以声明为常对象。
定义常对象的一般形式为
类名    const    对象名(实参列表);
也可以把const写在最左面
const    类名    对象名(实参列表);
二者等价
如果一个对象被声明为常对象，则不能调用该对象的非const型的成员函数（除了由系统自动调用的隐式构造函数和析构函数）。
否则就会报错
这样做是为了方式非const型的成员函数修改常对象中的数据成员的值，因为const型的成员函数是不可以修改对象中的数据成员的值的（这个后面还会说到）。
那么，怎样才能引用常变量中的数据成员呢？很简单，我们只需要将该成员函数声明称const型的成员函数（常成员函数）即可。
void Print() const;
常成员函数可以访问常对象中的数据成员，但仍然不允许修改常对象中数据成员的值。

有时在编程时有要求，一定要修改常对象成员中的某个数据成员的值（例如类中有一个用于计数的变量count，其值应当不能变化），
对该数据成员声明为mutable，如
mutable int count;//定义一个在常对象中可以被改变的数据成员

把count声明为可变的数据成员，这样就可以用声明为const的成员函数来修改它的值。

=一个简单的示例程序1.1============
#include

using namespace std;

class Student

{

	public:

		Student(int n,float s):num(n),score(s){}

		void change(int n,float s) const{num=n;score=s;}

		void display() const{cout<<num<<"\t"<<score<<endl;}

	private:

		mutable int num;

		mutable float score;

} ;

int main()

{

	Student const stud(101,78.5);

	stud.display();

	stud.change(101,80.5);

	stud.display();

	return 0;

}
我们定义了常对象stud，然后分别调用了两个常函数display()和change()，但是在change函数中要修改常对象中的num和score的值，所以我们将num和score定义为mutable.
常对象成员
1.常数据成员

其作用和用法与一般常变量相似，用关键字const来声明常数据成员。常数据成员的值是不能改变的。

只能通过构造函数的参数初始化表对常数据成员进行初始化。
在类体中声明常数据成员

const int num;//声明hour为常数据成员
在类外定义构造函数

Student::Student(int n,float s):num(n),score(s){} //通过参数初始化表对常数据成员num和score初始化
在类体中声明了某一个数据成员为常数据成员后，该类所有对象中的该数据成员的值都是不能改变的，但不同对象中该变量成员的值可以是不同的（分别在初始化时指定）。
2.常成员函数
如果将成员函数声明为常成员函数，则只能引用本类中的数据成员，而不能修改它们。

注意：常对象只能引用常成员函数
常成员函数的定义形式：

void Print() const;//注意const的位置在函数名和括号之后

const是函数类型的一部分，在声明函数和定义函数都要有const关键字，在调用时不必加const。

常成员函数可以const数据成员，也可以引用非const数据成员，但是都不能修改他们；

不是常成员函数的函数可以调用const数据成员，但是不能修改它们，也可以调用非const数据成员，并且可以修改它们。

具体情况，如图1：
还要注意一下三点：

1.不要误认为常对象中的成员函数都是常成员函数，常对象只保证其所有数据成员的值不被修改。

2.如果在常对象中的成员函数未加const声明，则编译系统会把它当作非const成员函数处理。

3.还要注意，常成员函数不能调用另外一个非cosnt成员函数。