C++中函数重载,重写,隐藏的区别

 

函数重载：

• 函数重载的条件：
  1. 函数在同一个作用域内。同一个类内的同名函数，或者同一个块区域内的同名函数。
  2. 函数名相同
  3. 函数的参数列表不同
• 注意点：
  1. ​​​​​​​const参数和非const参数不算参数列表不同（会产生二义性）
  2. 但是&和非&是属于重载。
  3. 类成员函数和普通函数一样
• 代码事例：

#include <iostream>

void testPrint(int& a)
{
	std::cout << "int&" << std::endl;
	return;
}

void testPrint(int a)
{
	std::cout << "int" << std::endl;
	return;
}

int main()
{
	
	int a = 10;
	testPrint(std::move(a)); //调用的是值拷贝的testPrint版本

	system("pause");
}

函数重写：

• 函数重写的条件：
  1. ​​​​​​​​​​​​​​发生在父类和子类之间
  2. 子类将父类同名且参数类型相同的虚函数实现
• 注意事项：
  1. ​​​​​​​子类重写的父类虚函数必须和父类有相同的函数名和参数列表
  2. 父类函数必须是虚函数
  3. 重写是实现多态的必要条件
• 代码示例：

 

class tc1
{
public:
	tc1(int& a) :m_a(a) 
	{
		std::cout << "tc1" << std::endl;
	};

	virtual void print()
	{
		std::cout << m_a << std::endl;
	}

    void print2()
    {
       std::cout << m_a << std::endl;
    }
public:
	int& m_a;
};


class tc2 :public tc1
{
public:
	tc2(int&a, int&b) :m_b(b), tc1(a)
	{
		std::cout << "tc2" << std::endl;
	}
	~tc2() {};
	void print(int&c) //这不是重写，父类指针指向子类对象后访问不了该函数，该函数属于子类自有的        函数
	{
		std::cout << c << std::endl;
	}
    void print() //函数重写
	{
		std::cout << m_b << std::endl;
	}

    void print2()
    {
       std::cout << m_b << std::endl;
    }

	int m_b;
};

void test13()
{
	int a = 10,b =20,c=30;
	std::cout << sizeof tc2 << std::endl;
	tc1* t1 = new tc2(a, b);
	//t1->print(c); //编译器报错
    t1->print();    //输出20，多态
    t1->print2();   //输出10，父类指针不能访问到子类的特有函数
}

函数隐藏：

• 函数隐藏的条件：
  1. 必须是子类和父类之间
  2. 子类和父类有同名函数
  3. 父类和子类的同名函数没有virtual关键字
• 现象：隐藏有两种现象，父类函数被隐藏和子类函数被隐藏
  1. 通过子类访问不到父类的公有同名函数，只能访问到子类的同名函数，父类函数被隐藏
  2. 父类指针指向子类后访问不到子类的同名函数，子类函数被隐藏
• 注意事项：
  1. ​​​​​​​子类和父类函数参数列表无需相同，只要是同名就会被隐藏
• 代码：

class tc1
{
public:
	tc1(int& a) :m_a(a) 
	{
		std::cout << "tc1" << std::endl;
	};

	void print()
	{
		std::cout << m_a << std::endl;
	}

public:
	int& m_a;
};


class tc2 :public tc1
{
public:
	tc2(int&a, int&b) :m_b(b), tc1(a)
	{
		std::cout << "tc2" << std::endl;
	}
	~tc2() {};
	void print(int&c)
	{
		std::cout << c << std::endl;
	}

	int m_b;
};

void test13()
{
	int a = 10,b =20,c=30;
	std::cout << sizeof tc2 << std::endl;
	tc2* t1 = new tc2(a, b);
	//t1->print(); //父类函数被隐藏，编译器报错
    tc1* t2 = t1;
    //t2->print(c);//子类函数被隐藏，编译器报错
}