在C++面向对象编程中，继承与函数重载是实现代码复用、扩展类功能的核心特性，二者结合时需遵循特定规则。其中，公有继承与私有继承的核心区别，直接决定了基类成员（包括重载函数）在派生类中的访问权限和可访问范围，这是面试高频考点，也是避免语法错误、规范类设计的关键。本文将先明确继承中重载的核心规则，再重点剖析公有、私有继承的差异，结合代码示例直观理解。
一、前置基础：函数重载的核心定义
函数重载（Function Overloading）是指在同一个作用域 中，声明多个同名函数，但函数的参数列表（参数个数、参数类型、参数顺序）不同（返回值类型不影响重载判断）。其核心作用是"同名不同用"，简化函数调用逻辑。
示例（普通类中的函数重载）：
cpp
#include <iostream>
using namespace std;
class Base {
public:
// 重载函数：参数个数不同
void show() {
cout << "无参数 show()" << endl;
}
// 重载函数：参数类型不同
void show(int a) {
cout << "int参数 show(): " << a << endl;
}
// 重载函数：参数顺序不同
void show(int a, double b) {
cout << "int+double参数 show(): " << a << ", " << b << endl;
}
};
int main() {
Base b;
b.show(); // 调用无参数版本
b.show(10); // 调用int参数版本
b.show(10, 3.14); // 调用int+double参数版本
return 0;
}
}注意：函数重载必须满足"同一作用域"，若函数处于不同作用域（如基类与派生类），则不属于重载，而是"隐藏"（后文详解）。
二、继承中重载的核心规则（必记）
当派生类继承基类后，基类的重载函数会被"继承"，但派生类中若定义了与基类同名的函数，会触发名字隐藏，而非重载------这是继承中重载与普通类重载的核心区别，也是最易踩坑的点。
1. 核心规则1：名字隐藏优先于重载
派生类中若存在与基类同名 的函数（无论参数列表是否相同），会"隐藏"基类中所有同名的重载函数，派生类对象无法直接访问基类的同名重载函数（需通过基类作用域解析符::访问）。
示例（名字隐藏 vs 重载）：
cpp
#include <iostream>
using namespace std;
// 基类
class Base {
public:
void show() { cout << "Base: 无参数 show()" << endl; }
void show(int a) { cout << "Base: int参数 show(): " << a << endl; }
};
// 派生类（公有继承）
class Derived : public Base {
public:
// 与基类同名，参数列表不同（本应重载，但触发名字隐藏）
void show(double b) {
cout << "Derived: double参数 show(): " << b << endl;
}
};
int main() {
Derived d;
d.show(3.14); // 正确：调用派生类的show(double)
// d.show(); // 错误：基类的show()被隐藏，无法直接访问
// d.show(10); // 错误：基类的show(int)被隐藏，无法直接访问
// 正确访问：通过基类作用域解析符
d.Base::show(); // 调用基类无参数show()
d.Base::show(10); // 调用基类int参数show()
return 0;
}
}结论：继承中，"同名"是触发隐藏的关键，与参数列表无关；重载仅发生在"同一作用域"，基类与派生类属于不同作用域，因此不会形成重载。
2. 核心规则2：派生类可重载自身的同名函数
派生类内部可以定义同名不同参数的函数，形成自身作用域内的重载，与基类的同名函数无关（基类函数已被隐藏）。
cpp
class Derived : public Base {
public:
// 派生类内部的重载函数（同一作用域）
void show(double b) { cout << "Derived: double " << b << endl; }
void show(int a, double b) { cout << "Derived: int+double " << a << "," << b << endl; }
};
// 调用示例
Derived d;
d.show(3.14); // 调用show(double)
d.show(10, 3.14); // 调用show(int, double)
}3. 核心规则3：继承方式不影响"名字隐藏"，只影响访问权限
无论派生类是公有、私有还是保护继承，只要派生类定义了与基类同名的函数，都会隐藏基类的所有同名重载函数。区别仅在于：不同继承方式下，基类的成员（包括被隐藏的重载函数）在派生类内部、派生类外部的访问权限不同。
三、公有继承与私有继承的核心区别（重点）
继承方式（public、private、protected）的核心作用，是控制基类成员在派生类中的访问权限，以及派生类外部能否访问这些继承来的成员。其中，公有继承和私有继承是最常用的两种方式，二者对基类重载函数的影响，本质是"访问权限"的差异。
先明确核心前提：基类中的成员（函数、变量）有三种访问权限：public（公有）、protected（保护）、private（私有）。其中，基类的private成员，无论何种继承方式，派生类都无法直接访问（只能通过基类的公有/保护成员间接访问）。
1. 公有继承（public inheritance）
公有继承的核心特性：基类的public成员 → 派生类的public成员；基类的protected成员 → 派生类的protected成员；基类的private成员 → 派生类不可访问。
对重载函数的影响：
派生类内部：可直接访问基类的public、protected重载函数（若未被派生类同名函数隐藏）；
派生类外部：可通过派生类对象，直接访问基类继承来的public重载函数（若未被隐藏）；
若派生类定义了同名函数，基类的所有同名重载函数被隐藏，外部需通过派生类对象.基类名::函数名()访问（前提是基类函数为public）。
示例（公有继承下的重载与访问）：
cpp
#include <iostream>
using namespace std;
class Base {
public:
void show() { cout << "Base: 无参数 show()" << endl; }
void show(int a) { cout << "Base: int参数 show(): " << a << endl; }
protected:
void display() { cout << "Base: protected display()" << endl; }
};
// 公有继承
class Derived : public Base {
public:
// 不定义同名函数，继承基类所有重载函数
void test() {
show(); // 正确：访问基类public重载函数
show(10); // 正确：访问基类public重载函数
display(); // 正确：访问基类protected成员（派生类内部可访问）
}
};
int main() {
Derived d;
d.test(); // 调用派生类test()，间接访问基类成员
d.show(); // 正确：外部访问基类继承来的public函数
d.show(10); // 正确：外部访问基类继承来的public函数
// d.display(); // 错误：protected成员，外部无法访问
return 0;
}
}2. 私有继承（private inheritance）
私有继承的核心特性：基类的public成员 → 派生类的private成员；基类的protected成员 → 派生类的private成员；基类的private成员 → 派生类不可访问。
对重载函数的影响：
派生类内部：可直接访问基类的public、protected重载函数（若未被派生类同名函数隐藏）；
派生类外部：无法直接访问基类任何继承来的成员（包括public重载函数），即使通过基类作用域解析符也不行；
若派生类定义了同名函数，基类的所有同名重载函数被隐藏，且无论基类函数原本是什么权限，派生类外部都无法访问。
示例（私有继承下的重载与访问）：
cpp
#include <iostream>
using namespace std;
class Base {
public:
void show() { cout << "Base: 无参数 show()" << endl; }
void show(int a) { cout << "Base: int参数 show(): " << a << endl; }
protected:
void display() { cout << "Base: protected display()" << endl; }
};
// 私有继承
class Derived : private Base {
public:
void test() {
show(); // 正确：派生类内部可访问基类继承来的private成员
show(10); // 正确：内部访问
display(); // 正确：内部访问
}
// 定义同名函数，隐藏基类所有show()
void show(double b) {
cout << "Derived: double show(): " << b << endl;
}
};
int main() {
Derived d;
d.test(); // 正确：调用派生类public函数，间接访问基类成员
// d.show(); // 错误：基类show()被隐藏，且派生类show(double)是public，但基类的无法访问
// d.show(10); // 错误：基类show(int)被隐藏，外部无法访问
// d.Base::show();// 错误：私有继承，基类public成员已变为派生类private，外部无法访问
d.show(3.14); // 正确：调用派生类自身的show(double)
return 0;
}
}3. 公有继承与私有继承的核心区别总结（表格对比）
| 对比维度 | 公有继承（public） | 私有继承（private） |
|---|---|---|
| 基类public成员 → 派生类权限 | public（外部可访问） | private（外部不可访问） |
| 基类protected成员 → 派生类权限 | protected（外部不可访问） | private（外部不可访问） |
| 派生类内部访问基类成员 | 可访问public、protected成员 | 可访问public、protected成员 |
| 派生类外部访问基类继承成员 | 可访问public成员（未被隐藏） | 不可访问任何基类继承成员 |
| 名字隐藏规则 | 派生类同名函数隐藏基类所有同名重载函数 | 与公有继承一致，隐藏规则不受继承方式影响 |
| 核心语义 | is-a（派生类是基类的一种），适合代码复用、多态 | has-a（派生类拥有基类的功能），适合隐藏基类接口 |
四、常见避坑点（重点）
1. 误区1：继承中同名不同参的函数是重载
错误原因：忽略了"重载必须在同一作用域"。基类与派生类是不同作用域，因此同名不同参的函数不是重载，而是名字隐藏。
解决方案：若需在派生类中使用基类的重载函数，可通过using 基类名::函数名;将基类的重载函数引入派生类作用域，避免隐藏。
cpp
class Derived : public Base {
public:
using Base::show; // 引入基类所有show()重载函数
void show(double b) { // 与基类show()形成重载（同一作用域）
cout << "Derived: double " << b << endl;
}
};
// 调用示例
Derived d;
d.show(); // 调用基类show()
d.show(10); // 调用基类show(int)
d.show(3.14); // 调用派生类show(double)
}2. 误区2：私有继承后，派生类无法访问基类成员
错误原因：混淆了"派生类内部访问"和"外部访问"。私有继承下，派生类内部可正常访问基类的public、protected成员，只是这些成员在派生类中变为private，外部无法访问。
3. 误区3：继承方式影响名字隐藏
错误原因：名字隐藏的触发条件是"派生类有同名函数"，与继承方式无关。无论公有、私有继承，只要派生类定义了与基类同名的函数，都会隐藏基类的所有同名重载函数。
五、总结（必背核心）
1. 继承中重载的核心规则
重载仅发生在同一作用域，基类与派生类的同名函数不是重载，是名字隐藏；
派生类同名函数会隐藏基类所有同名重载函数，可通过using 基类名::函数名;解除隐藏；
派生类内部可重载自身的同名函数，遵循普通重载规则。
2. 公有与私有继承的核心区别
核心差异：基类成员在派生类中的访问权限，以及派生类外部能否访问这些成员；
公有继承：基类public成员保留public权限，外部可访问，适合is-a关系；
私有继承：基类public、protected成员变为private权限，外部不可访问，适合has-a关系；
共同点：二者都遵循名字隐藏规则，且都无法直接访问基类的private成员。
掌握继承中的重载规则和公有、私有继承的区别，能有效避免语法错误，合理设计类的层次结构，是C++面向对象编程从基础到进阶的关键一步，务必结合代码多练习、多验证。