函数重载之const

我们知道，如果函数名相同，在相同的作用域内，其参数类型、参数个数，参数顺序不同等能构成函数重载。有趣的是如果同时在类中，对于函数名相同的const函数和非const函数能够构成重载，同时它们被调用的时机为：如果定义的对象是常对象，则调用的是const成员函数，如果定义的对象是非常对象，则调用重载的非const成员函数。例如：
#include <iostream>
using namespace std;
class A
{
public:
       A( int x )
       {
              m = x;
       }
       
       int func( void )
       {
            cout << "non-const" << endl;
            m = 1700; //本函数体没有声明为const,允许修改成员数据 
            return m;
       }
       
       //函数体限制为const， 
       int func( void )const
       {
             cout << "const" << endl;             
             return m;
       }
private:
        int m;
};

int main( void )
{
    A b( 2002 );
    b.func( ); //调用 非const版本的func() 
    
    const A c( 2002 );
    c.func( ); //调用 const版本的func() 

   system( "PAUSE" );
   return 0;

}

另外，应该把不修改相应实参的形参定义为const引用，否则将限制该函数的使用，下面代码将产生编译错误：
 string::size_type find_char(string &s, char c)
 {
  while(i!=s.size()&&s[i]!=c) ++i;
  return i;
 }
 int main()
 {
  find_char("Hello World", 'o') //error
  return 0;
 }

        错误的原因：虽然字符串字面值传递给函数可以产生局部对象，但是这里形参被声明为引用，必须引用一个已存在的对象，所以上述代码才会导致编译错误。
        仅当形参是引用或指针时，形参是否为const才有重载现象。
class Account 
{  }; 
void lookup(Account &)
{ }
void lookup(const Account &)
{ }       

void lookup3(Account *)
{ }
void lookup3( Account const*)
{ }
void lookup4(Account *) //错误，不能重载
{ }
void lookup4( Account *const)//错误，不能重载
{ } 

const Account a(0);
Account b;
lookup(a);  //call lookup(const Account &)
lookup(b);  //call lookup(Account &)

注意：不能基于指针本身是否为const来实现函数的重载。例如，
 f(int *);
 f(int *const);
 以上两个函数无法构成重载。

通常地，不同的重载函数不能具有相同数目的参数和参数类型。函数的返回值类型，虽然属于成员函数的signature的组成部分，但仅仅返回值类型不同，是不能构成函数重载的，因为这会造成redefinition的错误。

 

但有一个例外，就是使用const关键字进行函数重载，是成员函数成为const函数。见下面的代码：

// Overloading Based on const

#include <iostream>

#include <string>

using namespace std;

 

class AClass

{

public:

         AClass():greetingwords("Hello, world!")

         {

         }

 

         string greeting()                                 // (1)

         {

                   return greetingwords + " - from nonconst version.";

         }

 

         //const string greeting()                       // (2)

         //{

         //       return greetingwords + " - from right const version.";

         //}

 

         //string greeting() const                       // (3)

         //{

         //       return greetingwords + " - from right const version.";

         //}

 

         const string greeting() const             // (4)

         {

                   return greetingwords + " - from const - const version.";

         }

 

private:

         const string greetingwords;

};

 

int main(void)

{

         AClass a_class;

         const AClass b_class;

         cout << a_class.greeting() << endl;

         cout << b_class.greeting() << endl;

 

         return 0;

}

 

说明：

a.       (1)和(4)中的greeting的参数数目和类型都是完全一致的(两个函数都没有参数)，按照通常的说法，这会出现编译错误，但事实上，上面的程序可以正常运行。因此，(1)和(4)中的两个greeting函数，并无redefinition的问题，这是因为(4)中的greeting函数名称后有一个const关键字的缘故；

b.      同样道理，如果将这个(4)定义的greeting注释掉，使用(3)中的greeting函数的定义，结果也是正确的，因为(3)中的greeting函数名称后也有一个const关键字；

c.      (3)和(4)不能同时出现，否则会出现redefinition的编译错误。因为它们之间的不同仅是返回值类型不同，一个是string，另一个是const string，而仅仅是返回值类型的不同，编译器是无法区分两个重载函数的不同；

d.      基于上面的道理，(1)和(2)也不能同时出现；

e.      结论。如果两个函数的参数数目和数据类型都是一样的，只要将其中一个改为const成员函数(即，函数名称和参数后又const关键字)，则仍然可以构成有效的函数重载；

f.       输出。上面的代码输出：

Hello, world! – from nonconst version.

Hello, world! – from const – const version.

       a_class是一个nonconst对象，因此选择了(1)中的greeting定义；b_class是一个const对象，因此选择了(4)中的greeting定义。