前天同学实现了《C++ Primer》中关于虚函数的一个例子，拿过来问我，代码如下：
#include<iostream> #include<string> using namespace std; class Item{ public: Item(const string x,const double y){isbn=x;price=y;}; virtual double net_price(size_t n) const{return n*price;};//可以去掉virtual体验到第3、4行打印出来的区别 virtual ~Item(){}; string isbn; protected: double price; }; class Bulk_Item:public Item{ public: Bulk_Item(const string x,const double y,const size_t z,const double w):Item(x,y),min_qty(z),discount(w){}; double net_price(size_t n) const; //double get() const; //double get(); private: size_t min_qty; double discount; }; double Bulk_Item::net_price(size_t n) const{ if(n>=min_qty) return n*(1-discount)*price; else return n*price; } void print_total(const Item &it,size_t n){ cout<<it.isbn<<" number sold: "<<n<<" total price: "<<it.net_price(n)<<endl; } int main(){ Item it1("201307291540",16.5); cout<<it1.net_price(2)<<endl; Bulk_Item it2("201307291545",22.5,10,0.2); cout<<it2.net_price(20)<<endl; print_total(it1,4); print_total(it2,20); return 0; }
同学的疑问是，如果去掉 Item 类定义中
virtual double net_price(size_t n) const{return n*price;};
一句中的 const 限定，则会在print_total 的定义行出现编译错误
“Item::net_price”: 不能将“this”指针从“const Item”转换为“Item &”
他觉得定义的 net_price 方法并没有修改 Item 内的属性，有没有const限定词应该是一样的。
但实际上，在print_total 的定义中，限定了引用 it 为 const， 这意味着该引用只能调用 Item 类内的 const方法，即：const限定的对象引用不能调用此对象中的非const方法。
进而，可以知道，C++中判断一个方法是不是const，并不是检测你在该方法中有没有改变类的属性，而只是简单的看你有没有const限定词，有就是const方法，没有就不是const方法。若有const限定词，而在方法内你又试图改变类的属性，则编译器会报错。
那么，同名函数（包括参数相同），一个有const限定，一个没有，是两个函数还是一个函数？为了探究，在 Bulk_Item 的定义中增加两个 get_price 函数，一个为const，一个为普通函数，然后在主函数里调用：
#include<iostream> #include<string> using namespace std; class Item{ public: Item(const string x,const double y){isbn=x;price=y;}; virtual double net_price(size_t n) const{return n*price;};//可以去掉virtual体验到第3、4行打印出来的区别 virtual ~Item(){}; string isbn; protected: double price; }; class Bulk_Item:public Item{ public: Bulk_Item(const string x,const double y,const size_t z,const double w):Item(x,y),min_qty(z),discount(w){}; double net_price(size_t n) const; double get_price() const{ cout<<"get const"<<endl; return price; }; double get_price(){ cout<<"get Non const"<<endl; return price; }; private: size_t min_qty; double discount; }; double Bulk_Item::net_price(size_t n) const{ if(n>=min_qty) return n*(1-discount)*price; else return n*price; } void print_total(const Item &it,size_t n){ cout<<it.isbn<<" number sold: "<<n<<" total price: "<<it.net_price(n)<<endl; } int main(){ Item it1("201307291540",16.5); cout<<it1.net_price(2)<<endl; Bulk_Item it2("201307291545",22.5,10,0.2); cout<<it2.net_price(20)<<endl; print_total(it1,4); print_total(it2,20); cout<<it2.get_price()<<endl; return 0; }
输出结果为：
get Non const 22.5
可见，并没有产生编译错误，自动调用的是非const方法。故有无const会造成有两个重载的函数，编译后的函数名，除了函数名和参数，还加入了const限定词。但调用时会优先选非const的函数（这是因为我们传入的是非const对象it2，下面会看到，若传入const对象，则自动调用const版本）。
接着，我们构造打印函数，如下：
#include<iostream> #include<string> using namespace std; class Item{ public: Item(const string x,const double y){isbn=x;price=y;}; virtual double net_price(size_t n) const{return n*price;};//可以去掉virtual体验到第3、4行打印出来的区别 virtual ~Item(){}; string isbn; protected: double price; }; class Bulk_Item:public Item{ public: Bulk_Item(const string x,const double y,const size_t z,const double w):Item(x,y),min_qty(z),discount(w){}; double net_price(size_t n) const; double get_price() const{ cout<<"get const"<<endl; return price; }; double get_price(){ cout<<"get Non const"<<endl; return price; }; private: size_t min_qty; double discount; }; double Bulk_Item::net_price(size_t n) const{ if(n>=min_qty) return n*(1-discount)*price; else return n*price; } void print_total(const Item &it,size_t n){ cout<<it.isbn<<" number sold: "<<n<<" total price: "<<it.net_price(n)<<endl; } void print_price(const Bulk_Item &it){ cout<<"print_price const"<<endl; cout<<it.get_price()<<endl; } void print_price(Bulk_Item &it){ cout<<"print_price Non const"<<endl; cout<<it.get_price()<<endl; } int main(){ Item it1("201307291540",16.5); cout<<it1.net_price(2)<<endl; Bulk_Item it2("201307291545",22.5,10,0.2); cout<<it2.net_price(20)<<endl; print_total(it1,4); print_total(it2,20); cout<<it2.get_price()<<endl; print_price(it2); return 0; }
输出结果为：
print_price Non const get Non const 22.5
可见，（1）调用时，优先调用参数为非const的函数（因为传入的it2是非const参数），编译器不会在你传入非const参数时调用const参数的函数（除非没有非const版本），这是合理的，否则你不能改变你想改变的；（2）函数内，自动调用非const版本get_price（因为传入的是非const引用，故优先调用get_price方法的非const版本）。
同理，如果传入const 参数，如下：
#include<iostream> #include<string> using namespace std; class Item{ public: Item(const string x,const double y){isbn=x;price=y;}; virtual double net_price(size_t n) const{return n*price;};//可以去掉virtual体验到第3、4行打印出来的区别 virtual ~Item(){}; string isbn; protected: double price; }; class Bulk_Item:public Item{ public: Bulk_Item(const string x,const double y,const size_t z,const double w):Item(x,y),min_qty(z),discount(w){}; double net_price(size_t n) const; double get_price() const{ cout<<"get const"<<endl; return price; }; double get_price(){ cout<<"get Non const"<<endl; return price; }; private: size_t min_qty; double discount; }; double Bulk_Item::net_price(size_t n) const{ if(n>=min_qty) return n*(1-discount)*price; else return n*price; } void print_total(const Item &it,size_t n){ cout<<it.isbn<<" number sold: "<<n<<" total price: "<<it.net_price(n)<<endl; } void print_price(const Bulk_Item &it){ cout<<"print_price const"<<endl; cout<<it.get_price()<<endl; } void print_price(Bulk_Item &it){ cout<<"print_price Non const"<<endl; cout<<it.get_price()<<endl; } int main(){ Item it1("201307291540",16.5); cout<<it1.net_price(2)<<endl; Bulk_Item it2("201307291545",22.5,10,0.2); cout<<it2.net_price(20)<<endl; print_total(it1,4); print_total(it2,20); cout<<it2.get_price()<<endl; print_price(it2); const Bulk_Item it3("201307291546",44,10,0.2); print_price(it3); return 0; }
则会打印：
print_price const get const 44
说明，（1）传入const参数会调用参数为const的函数，这是理所应当的；（2）在print_price里会调用const版本的get_price，这说明，如果我们对一个类，有同名的两个函数，一个为const，一个非const，若用一个const对象引用来调用这个同名函数，则自动调用那个const函数。如下所示：
#include<iostream> #include<string> using namespace std; class Item{ public: Item(const string x,const double y){isbn=x;price=y;}; virtual double net_price(size_t n) const{return n*price;};//可以去掉virtual体验到第3、4行打印出来的区别 virtual ~Item(){}; string isbn; protected: double price; }; class Bulk_Item:public Item{ public: Bulk_Item(const string x,const double y,const size_t z,const double w):Item(x,y),min_qty(z),discount(w){}; double net_price(size_t n) const; double get_price() const{ cout<<"get const"<<endl; return price; }; double get_price(){ cout<<"get Non const"<<endl; return price; }; private: size_t min_qty; double discount; }; double Bulk_Item::net_price(size_t n) const{ if(n>=min_qty) return n*(1-discount)*price; else return n*price; } void print_total(const Item &it,size_t n){ cout<<it.isbn<<" number sold: "<<n<<" total price: "<<it.net_price(n)<<endl; } void print_price(const Bulk_Item &it){ cout<<"print_price const"<<endl; cout<<it.get_price()<<endl; } void print_price(Bulk_Item &it){ cout<<"print_price Non const"<<endl; cout<<it.get_price()<<endl; } int main(){ Item it1("201307291540",16.5); cout<<it1.net_price(2)<<endl; Bulk_Item it2("201307291545",22.5,10,0.2); cout<<it2.net_price(20)<<endl; print_total(it1,4); print_total(it2,20); cout<<it2.get_price()<<endl; print_price(it2); const Bulk_Item it3("201307291546",44,10,0.2); cout<<it3.get_price()<<endl; print_price(it3); return 0; }
则会打印：
get const 44
故而，鉴于有无const限定词会造就两个不同的函数，所以如果基类中有const，而继承类中同名方法没有const，则其实继承类实现的是一个完全新的函数，而不是在覆盖基类的方法。向上类型转换时，会调用基类的方法，而不是继承类中同名的非const方法，如下：
#include<iostream> #include<string> using namespace std; class Item{ public: Item(const string x,const double y){isbn=x;price=y;}; virtual double net_price(size_t n) const{return n*price;};//可以去掉virtual体验到第3、4行打印出来的区别 virtual ~Item(){}; string isbn; protected: double price; }; class Bulk_Item:public Item{ public: Bulk_Item(const string x,const double y,const size_t z,const double w):Item(x,y),min_qty(z),discount(w){}; double net_price(size_t n) ; private: size_t min_qty; double discount; }; double Bulk_Item::net_price(size_t n) { if(n>=min_qty) return n*(1-discount)*price; else return n*price; } void print_total(const Item &it,size_t n){ cout<<it.isbn<<" number sold: "<<n<<" total price: "<<it.net_price(n)<<endl; } int main(){ Item it1("201307291540",16.5); cout<<it1.net_price(2)<<endl; Bulk_Item it2("201307291545",22.5,10,0.2); cout<<it2.net_price(20)<<endl; print_total(it1,4); print_total(it2,20); return 0; }
最后一行输出为450而不是360。
同理，若基类方法无const，而继承类中有，则向上类型转换还是会调用基类的方法。
总结一下，主要有这么几点：
1、const限定的对象引用不能调用此对象中的非const方法。
2、const关键词限定的方法，则编译器就认为它是const型的，即使它并没有改变对象的任何属性。若限定了const，又在方法内改变了属性，则编译器会报错。
3、同名函数（参数也相同），一个有const限定，一个没有，编译器认为是两个重载函数，不会报错。这就意味着C++中编译器生成函数名时，除了函数名、参数外还有const，由三者共同组成编译后的函数名。
4、如上，两个方法的方法名和参数完全相同，一个有const限定，一个没有，则若你用const对象引用调用，会自动调用const版本的方法；若用非const对象引用调用，则会自动调用非const的版本。
5、同样的函数，只是参数一个是const，一个非const，则你用const参数调用，会自动调用参数为const的版本；你用普通参数调用，会自动调用参数为普通参数的版本，若此时没有非const的版本，它才会转而调用const版本的。
6、如果基类中有const，而继承类中同名方法没有const，则其实继承类实现的是一个完全新的函数，而不是在覆盖基类的方法，向上类型转换时，会调用基类的方法，而不是继承类中同名的非const方法。
突然想到，学习一门语言的最好方式也就就是：写一个这个语言的编译器。这样你就能对它的限制，它能做什么和不能做什么，你能用它做什么和不能做什么，有比较深刻的理解和记忆。推而广之，人类语言有很多冗余性，语法限制也相对比较宽松，故人类语言的编译器应该很难写。若能写一个人类语言的编译器，那就是真正的自然语言理解。