C++ – 重载、重定义、重写的区别

一.重载

• 1.在同一作用域下，函数名相同，参数不同（参数的类型或参数的个数）
• 2.不能根据返回值判断两个函数是否构成重载。
• 3.当函数构成重载后，调用该函数时，编译器会根据函数的参数选择合适的函数进行调用。
• 4.构成重载的例子：

#include<iostream>
using namespace std;
int Add(int a, int b)
{
      return a + b;
}
double Add(double a, double b)
{
      return a + b;
}
int main()
{
      cout << Add(3, 4) << endl;   
      cout << Add(3.1, 4.1) << endl;
      system("pause");
      return 0;
}

二.重定义（隐藏）

• 1.不同作用域下（指一个在子类，一个在父类 ），函数名相同的两个函数构成重定义。

• 2.当两个函数构成重定义时，父类的同名函数被隐藏，

  • 用子类的对象调用同名的函数时，如果不指定类作用符，就只会调用子类的同名函数。

• 3.如果想调用父类同名函数，须指定父类的域作用符。

  • 当父类和子类的成员变量名相同时，也会构成隐藏。

• 4.例子：

• （1）定义一个B的对象b，

• 当访问同名的函数fun1时，不指定域，会默认访问子类的fun1。

• （2）定义B的对象b，
• 当访问同名的函数fun1时，
• 指定域为A，则会访问父类的fun1。

• 3）将父类与子类的同名函数fun1进行如下改写，使这两个函数的参数不同

class A
{
public:
      void fun1(char c)
      {
           cout << "A::fun1()" << endl;
      }
      int _a;
};
class B : public A
{
public:
      void fun1(int a,int b)
      {
           cout << "B::fun1()" << endl;
      }
      int _b;
};
int main()
{
      B b;
      b.fun1('a');
      system("pause");
      return 0;
}

• 子类隐藏了父类的同名成员函数，
• 不指定域，
• 只调用子类的同名成员函数，
• 而传的参数与子类同名成员函数的参数不同，
• 所以编译失败

三.重写（覆盖）

• 1.在不同作用域下（父子），
• 函数名、参数、返回值完全相同，
• 父类必须含有virtual关键字（协变除外）。

• 2.什么是协变？
• （1）函数名相同，参数也相同，但函数的返回值可以不同（但必须只能是一个返回父类的指针（或引用）一个返回子类的指针（或引用），父类必须含有virtual关键字。
• （2）构成协变的一种方式，返回指针；

class A
{
public:
      virtual A* func1()
      {
           cout << "A::func1()" << endl;
           return this;
      }
private:
      int _a;
};
class B :public A
{
public:
      virtual A* func1()
      {
           cout << "B::func1()" << endl;
           return this;
      }
private:
      int _b;
};
int main()
{
      A a;
      B b;
      A* p = &a;   //多态的场景
      p->func1();
      p = &b;
      p->func1();
      system("pause");
      return 0;
}

canci

• 添加链接描述

两个数组中是否存在相同的数字

• 给两个排好序的数组，
• 判断这两个数组中存在相同的数字？

• 首先想到O(nlogn)
• 任挑一个数组，遍历这个数组的所有元素，
• 遍历过程中，在另一个数组中对第一个数组中的每个元素binary search。用C++实现代码如下：

bool findcommon(int a[],int size1,int b[],int size2)
{
     int i;
     for(i=0;i<size1;i++)
     {
          int start=0,end=size2-1,mid;
          while(start<=end)
          {
               mid=(start+end)/2;
               if(a[i]==b[mid])
                    return true;
               else if (a[i]<b[mid])
                    end=mid-1;
               else
                    start=mid+1;
          }
     }
     return false;
}

• O(n)算法。
• 两个数组都是排好序的。
• 只要一次遍历。
• 设两下标，分别初始化为两个数组的起始地址，依次向前推进 。
• 推进的规则是比较两个 数组中的数字，小的那个数组的下标向前推进一步，直到任何一个数组的下标到达数组末尾时，如果这时还没碰到相同的数字，说明数组中没有相同的数字。

bool findcommon2(int a[], int size1, int b[], int size2)
{
     int i=0,j=0;
     while(i<size1 && j<size2)
     {
          if(a[i]==b[j])
               return true;
          if(a[i]>b[j])
               j++;
          if(a[i]<b[j])
               i++;
     }
     return false;
}

canci

• 添加链接描述