面向对象 (11小节)
约 9603 字大约 32 分钟
2026-11-11
1.面向对象思想
面向对象 OOP 入门(三大特性:封装、继承、多态)
先分清两种思维:
- 面向过程 POP:关心步骤,第一步做啥、第二步做啥(比如C语言)
- 面向对象 OOP:先找有哪些事物(类/对象),事物有什么特征(属性)、能干什么(方法),再看事物之间的关系
饭店例子理解: 你去吃饭,只需要告诉服务员你要点菜(调用接口),不用关心后厨是怎么洗菜、炒菜的;后厨的细节被隐藏起来了,这就是封装思想。
1. 封装(Encapsulation)
把属性(数据)+ 方法(函数)打包到一个类里面;把内部细节藏起来,只留出对外接口给别人用。
访问权限(三个):
public:公有的,外部可以直接访问(对外接口)protected:保护的,子类可以访问,外部不行private:私有的,只有类自己内部能访问,外面、子类都碰不到(用来隐藏内部数据)
示例代码:
#include <iostream>
using namespace std;
class Person
{
private:
int age; // 私有属性,外部不能直接改
public:
// 对外接口
void setAge(int a)
{
if(a>0 && a<150) // 可以加校验,防止非法数据
age = a;
}
void showAge()
{
cout << age << endl;
}
};
int main()
{
Person p;
// p.age = 20; // ❌ private,外面不能直接访问
p.setAge(20); // ✅ 通过公开接口访问
p.showAge();
return 0;
}好处:数据安全,控制外部怎么修改数据;内部代码改了,外面调用方式不变。
2. 继承(Inheritance)
复用已有类的代码,在旧类(父类/基类)基础上,衍生出新类(子类/派生类) 子类可以:
- 拿到父类非private的属性和方法
- 新增自己独有的属性、方法(扩展功能)
- 重写父类的方法(为多态打基础)
#include <iostream>
using namespace std;
// 父类
class Animal
{
public:
void eat()
{
cout << "动物会吃东西" << endl;
}
};
// 子类Dog,公有继承Animal
class Dog : public Animal
{
public:
void bark() // 子类自己新增方法
{
cout << "汪汪叫" << endl;
}
};
int main()
{
Dog d;
d.eat(); // 继承父类来的
d.bark(); // 自己的
return 0;
}3. 多态(Polymorphism)⭐最难、考试重点
一句话:同一个接口,不同对象,执行不同的实现;编译时不确定,运行时才确定调用哪个函数 核心口诀:父类指针/引用,指向子类对象;配合虚函数 virtual
#include <iostream>
using namespace std;
class Animal
{
public:
// 虚函数,是实现多态的关键
virtual void speak()
{
cout << "动物发声" << endl;
}
};
class Cat : public Animal
{
public:
void speak() override
{
cout << "喵喵喵" << endl;
}
};
class Dog : public Animal
{
public:
void speak() override
{
cout << "汪汪汪" << endl;
}
};
// 同一个形参(父类引用),传不同子类,表现不一样
void test(Animal &a)
{
a.speak();
}
int main()
{
Cat c;
Dog d;
test(c); // 输出喵喵喵
test(d); // 输出汪汪汪
return 0;
}没有
virtual的话,就不会触发多态,永远调用父类的函数,叫静态绑定;加virtual是运行时绑定。
极简背诵版
- 封装:打包属性方法,隐藏细节,留接口(权限控制)
- 继承:代码复用,子类拓展父类
- 多态:一个接口,多种形态;虚函数 + 父类指针/引用指向子类
小思考题
下面能不能构成多态?
class Base{
public:
void func(){}
};
class Son:public Base{
public:
void func(){}
};
Base *p = new Son;
p->func();你判断一下。 ❌ 不对哦,不能构成多态!
解析:
class Base{
public:
void func(){} // 不是虚函数,没有 virtual
};
class Son:public Base{
public:
void func(){}
};
Base *p = new Son;
p->func();这里只是普通的函数隐藏(重定义),不是多态。
- 没有
virtual→ 静态绑定,编译阶段就确定调用 Base 的 func p->func()执行的永远是父类 Base 的func,不会跑到子类里
✅ 想要多态,两个硬性条件必须同时满足:
- 父类里的函数必须加
virtual声明成虚函数 - 使用父类指针 / 父类引用指向子类对象
改对版本:
class Base{
public:
virtual void func(){} // 加上virtual
};
class Son:public Base{
public:
void func() override {}
};
Base *p = new Son;
p->func(); // 运行时绑定,调用Son::func,这才是多态我们把4种组合一次性整理成一张对照,方便背诵(带virtual、开启多态的版本)
| 代码 | 指针类型 | 实际对象 | 调用哪个 |
|---|---|---|---|
Base *p = new Base; p->func(); | Base | Base | Base::func |
Base *p = new Son; p->func(); | Base | Son | Son::func |
Son *p = new Son; p->func(); | Son | Son | Son::func |
Son s; Base &r = s; r.func(); | 引用Base | Son | Son::func |
多态的判断逻辑:看实际对象是谁,不是看指针类型是谁(前提:有virtual)
再巩固一个考点区分:
- 重定义(隐藏):无virtual,同名函数,父类指针调父类版本
- 重写(覆盖):有virtual,函数签名完全一致,触发多态
只要父类没有 virtual,子类写一个同名函数,就是隐藏。
哪怕参数不一样,也叫隐藏;只要名字相同,父类的同名函数就被隐藏了。
class Base {
public:
void func() { cout << "Base func\n"; } // 没有virtual
};
class Son : public Base {
public:
void func() { cout << "Son func\n"; } // 重定义 / 隐藏
};
int main(){
Son s;
s.func(); // Son::func
s.Base::func(); // 想要调用父类版本,必须显式加 Base::
}虚函数
虚函数就是为了实现「一套统一接口,不同对象自己实现自己的逻辑」,也就是多态;让调用方不用关心对象到底是哪个子类。 如果没有
如果没有虚函数
你想让不同动物叫,定义一个speak函数你就得写一堆重载,或者写 if 判断:
void speak(Dog &d){ d.Dog::speak(); }
void speak(Cat &c){ c.Cat::speak(); }
// 以后新增一个 Pig,你又要再加一个speak函数,改调用代码每新增一个子类,上层调用代码就要跟着改。违反开闭原则:对扩展开放,对修改关闭。
有虚函数之后
只需要一个统一接口:
void test(Animal &a)
{
a.speak();
}纯虚函数(抽象类)
virtual void speak() = 0;带 =0,这个类叫抽象类,不能实例化对象,它就纯粹只用来定义接口,强制子类必须实现这个函数。这就是我们常说的接口类。
虚函数实现多态的例子
#include <iostream>
using namespace std;
// 父类:动物
class Animal
{
public:
// 虚函数,统一接口
virtual void speak()
{
cout << "动物发出声音" << endl;
}
};
// 子类:狗,公有继承Animal
class Dog : public Animal
{
public:
// 重写虚函数
void speak() override
{
cout << "汪汪汪" << endl;
}
};
// 子类:猫
class Cat : public Animal
{
public:
void speak() override
{
cout << "喵喵喵" << endl;
}
};
// 统一调用函数,只认父类引用(接口)
void testSpeak(Animal &a)
{
a.speak();
}
int main()
{
Animal ani;
Dog dog;
Cat cat;
testSpeak(ani);
testSpeak(dog);
testSpeak(cat);
return 0;
}运行输出:
动物发出声音
汪汪汪
喵喵喵改成【纯虚函数版本(抽象类,纯接口)】
加上 =0,Animal 就不能创建对象了,强制子类必须实现 speak:
#include <iostream>
using namespace std;
class Animal
{
public:
// 纯虚函数 → 抽象类
virtual void speak() = 0;
};
class Dog : public Animal
{
public:
void speak() override
{
cout << "汪汪汪" << endl;
}
};
class Cat : public Animal
{
public:
void speak() override
{
cout << "喵喵喵" << endl;
}
};
void testSpeak(Animal &a)
{
a.speak();
}
int main()
{
Dog dog;
Cat cat;
testSpeak(dog);
testSpeak(cat);
return 0;
}输出:
汪汪汪
喵喵喵这里
Animal ani;会直接编译报错,抽象类不能实例化。
需要我再加一段父类指针new的写法对比吗? 给你补上new + 父类指针版本,同时记得释放内存,还有一个重要考点:基类析构最好加 virtual,不然子类析构函数不会被调用,内存泄漏!
#include <iostream>
using namespace std;
class Animal
{
public:
virtual void speak()
{
cout << "动物发出声音" << endl;
}
// 虚析构!多态new释放必备
virtual ~Animal()
{
cout << "Animal 析构" << endl;
}
};
class Dog : public Animal
{
public:
void speak() override
{
cout << "汪汪汪" << endl;
}
~Dog() override
{
cout << "Dog 析构" << endl;
}
};
class Cat : public Animal
{
public:
void speak() override
{
cout << "喵喵喵" << endl;
}
~Cat() override
{
cout << "Cat 析构" << endl;
}
};
void testSpeak(Animal &a)
{
a.speak();
}
int main()
{
// 父类指针,指向不同子类(堆上开辟)
Animal *p1 = new Animal;
Animal *p2 = new Dog;
Animal *p3 = new Cat;
p1->speak();
p2->speak();
p3->speak();
// 释放
delete p1;
delete p2;
delete p3;
return 0;
}输出:
动物发出声音
汪汪汪
喵喵喵
Animal 析构
Dog 析构
Animal 析构
Cat 析构
Animal 析构⚠️ 重点坑: 如果 ~Animal() 不加 virtual,delete p2 的时候只会调用Animal析构,Dog的析构不跑,造成内存泄漏。
2.类和对象
C++ 在 C 语言的基础上增加了面向对象编程,类是 C++ 的核心特性,通常被称为用户定义的类型。 类用于指定对象的形式。
类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
含义
本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作。
类定义
类定义是以关键字 class 开头,后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如,我们使用关键字 class 定义 Box 数据类型,如下所示:
class Box
{
public:
double length; // 盒子的长度
double breadth; // 盒子的宽度
double height; // 盒子的高度
};关键字 public 确定了类成员的访问属性。在类对象作用域内,公共成员在类的外部是可访问的。您也可以指定类的成员为 private 或 protected。
类提供了对象的蓝图,所以基本上,对象是根据类来创建的。
声明类的对象
就像声明基本类型的变量一样。
Box Box1; // 声明 Box1,类型为 Box
Box Box2; // 声明 Box2,类型为 Box对象 Box1 和 Box2 都有它们各自的数据成员。
访问数据成员
类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。
完整示例代码:
#include <iostream>
using namespace std;
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
};
int main()
{
Box Box1; // 声明 Box1,类型为 Box
Box Box2; // 声明 Box2,类型为 Box
double volume = 0.0; // 用于存储体积
// box 1 赋值
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;
// box 2 赋值
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;
// box 1 的体积
volume = Box1.height * Box1.length * Box1.breadth;
cout << "Box1 的体积:" << volume << endl;
// box 2 的体积
volume = Box2.height * Box2.length * Box2.breadth;
cout << "Box2 的体积:" << volume << endl;
return 0;
}需要注意的是,私有的成员和受保护的成员不能使用直接成员访问运算符
.来直接访问。
运行输出:
Box1 的体积:210
Box2 的体积:1560✅ 小总结
- 类 = 模板/蓝图,本身不存储数据、不占用实例内存;对象 = 根据模板创建出来的实体,拥有独立内存和成员数据
- 同一个类可以实例化多个对象,各个对象的成员变量互相独立、互不干扰
public成员:外部可以通过.直接访问;private / protected成员外部不能直接用.访问- 现在这种全部
public的写法比较简陋,后面可以改成封装:成员私有化,对外提供 set/get 成员函数,增加数据合法性校验
3.类成员函数
定义
类定义内部的函数,就像类定义中的其他变量一样。类成员函数是类的一个成员,它可以操作类的任意对象,可以访问对象中的所有成员。
成员函数有两种写法:
- 定义在类定义内部
- 在类内只写声明,在类的外部使用作用域解析运算符
::来定义
使用
方式1:成员函数写在类内部
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
void setLength(double len){
length = len;
}
void setBreadth(double bre){
breadth = bre;
}
void setHeight(double hei){
height = hei;
}
double getVolume(void)
{
return length * breadth * height;
}
};方式2:成员函数写在类外部(:: 作用域解析运算符)
:: 是C++里的作用域分解运算符,用来告诉编译器:这个函数属于哪一个类。
示例1(Stu类演示)
class Stu {
public:
int age;
int add(int a,int b); // 类内声明
};
// 类外实现,Stu:: 标记归属
int Stu::add(int a, int b)
{
return a + b;
}示例2(Box完整分离写法)
class Box
{
public:
double length; // 长度
double breadth; // 宽度
double height; // 高度
// 成员函数声明
double getVolume(void);
void setLength(double len);
void setBreadth(double bre);
void setHeight(double hei);
};
// 成员函数定义
double Box::getVolume(void)
{
return length * breadth * height;
}
void Box::setLength(double len)
{
length = len;
}
void Box::setBreadth(double bre)
{
breadth = bre;
}
void Box::setHeight(double hei)
{
height = hei;
}实战 main 调用
#include <iostream>
using namespace std;
// 上面Box类代码放这里
int main()
{
Box Box1; // 声明 Box1,类型为 Box
Box Box2; // 声明 Box2,类型为 Box
double volume = 0.0; // 用于存储体积
// box 1 赋值
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);
// box 2 赋值
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);
// box 1 的体积
volume = Box1.getVolume();
cout << "Box1 的体积:" << volume << endl;
// box 2 的体积
volume = Box2.getVolume();
cout << "Box2 的体积:" << volume << endl;
return 0;
}运行输出:
Box1 的体积:210
Box2 的体积:1560✅ 小总结
- 成员函数属于类,能直接访问这个类对象里的所有成员(public/private都可以)
- 写在类内:简单短小函数适合,默认是内联函数;写在类外:代码结构清晰,适合大项目(头文件放声明,源文件放实现)
- 类外实现必须加
类名::函数名,不然编译器会当成普通全局函数 - 调用方式:对象.成员函数(),例如
Box1.getVolume()
4.类的访问修饰符
在C++中,类的所有成员默认访问权限是 private(私有);而结构体 struct 的所有成员默认访问权限是 public(公有)。
公有(public)成员
公有成员在程序中类的外部是可访问的。
#include <iostream>
using namespace std;
class Line
{
public:
double length;
};
int main()
{
Line line;
// 不使用成员函数设置长度
line.length = 10.0; // OK:因为 length 是公有的
cout << line.length << endl;
return 0;
}私有(private)成员
成员和类的默认访问修饰符就是 private。 私有成员变量或函数在类的外部不可访问、不可查看。只有类自身的成员函数、友元函数可以访问私有成员。
#include <iostream>
using namespace std;
class Box
{
public:
double length;
void setWidth(double w) { width = w; }
double getWidth() { return width; }
private:
double width;
};
int main()
{
Box box;
box.length = 10.0; // OK:length 公有
cout << box.length << endl;
// box.width = 10.0; // Error:width 私有,外部不能直接访问
box.setWidth(10.0); // 通过公有成员函数操作私有变量
cout << box.getWidth() << endl;
return 0;
}保护(protected)成员
保护成员和私有成员很像,唯一区别:保护成员在派生类(子类)里面可以访问,外部依旧不能直接访问。
class Box
{
protected:
double width;
private:
double price;
};
// SmallBox 是 Box 的派生类(子类)
class SmallBox : Box
{
public:
void setSmallWidth(double wid)
{
width = wid; // ✅ protected 基类成员,子类可以访问
// price = 2.0; // ❌ private 基类成员,子类不能访问
}
};✅ 小总结
public:哪里都能访问,对外暴露的接口一般放这里private:只有本类内部、友元可以访问,数据成员优先放 private(封装思想)protected:本类 + 子类可以访问,普通外部不能访问,做继承的时候用- 记忆区分:
class默认 private;struct默认 public
5.类的构造函数和析构函数
一、构造函数
定义
类的构造函数是类的一种特殊成员函数,每次创建类的新对象时自动执行,用来给成员变量设置初始值。
✅ 构造函数特点:
- 函数名和类名完全相同
- 没有返回值,不能写
void - 可以重载(无参、带参构造可以同时存在)
- 如果你没有手写任何构造函数,编译器自动生成一个无参的默认构造函数;一旦你手写了带参构造,编译器就不再自动生成无参默认构造。
#include <iostream>
using namespace std;
class Date
{
private:
int year;
int month;
int day;
public:
// 带参构造函数
Date(int _year, int _month, int _day)
{
year = _year;
month = _month;
day = _day;
}
void display()
{
cout << year << "-" << month << "-" << day << endl;
}
};
int main()
{
// Date d1; // 报错!因为我们手写了带参构造,编译器不再提供无参默认构造
Date d2(2025, 7, 18); // 创建对象,自动调用带参构造
d2.display();
return 0;
}初始化列表(初始化表达式)
构造函数后加 :,在函数体执行之前完成成员初始化。
重点:
const常量成员、引用成员,只能用初始化列表初始化,在函数体内赋值会报错!
class student
{
public:
student(int i, int j):a(i),b(j) // 初始化列表写法 ✅
{
}
protected:
const int a; // const常量
int &b; // 引用
};
// 下面这种函数体内赋值是错误的!
// student::student(int i,int j)
// {
// a=i; // error const不能后期赋值
// b=j; // error 引用不能后期赋值
// }初始化列表后面继承(父子类)初始化还会用到。
二、析构函数
定义
也是特殊成员函数:名字和类名相同,前面加波浪号 ~,没有参数、没有返回值。 ✅ 析构函数特点:
- 一个类只能有一个析构函数,不能重载
- 不手写析构,编译器自动生成默认析构;手写之后,编译器不再生成默认析构
- 对象销毁的时候自动调用,一般用来释放堆内存、清理资源
new创建的对象,不会自动调用析构;只有执行 delete 的时候,才会调用析构函数
#include <iostream>
using namespace std;
class Demo
{
public:
Demo()
{
cout << "构造函数执行" << endl;
}
~Demo()
{
cout << "析构函数执行" << endl;
}
};
int main()
{
Demo d1; // 栈对象:创建调用构造,main结束销毁自动调用析构
Demo *d2 = new Demo; // new堆对象:调用构造
delete d2; // delete手动释放,触发析构函数
return 0;
}✅ 小总结
- 构造:出生的时候自动调用,初始化成员;析构:死亡的时候自动调用,清理资源
- 构造可以重载(无参/多参);析构不能重载,一个类只能一个
- 编译器默认规则:只要手写任意构造,就不再提供默认无参构造;只要手写析构,就不再提供默认析构
const、引用成员必须用初始化列表初始化,不能在构造函数大括号里面赋值- 栈上对象自动析构;
new出来的堆对象,必须手动delete才会执行析构
拷贝构造函数
定义
拷贝构造是一种特殊的构造函数,用一个已经存在的同类对象,去初始化另一个新对象。
✅ 格式:类名(const 类名 &对象名)
- 参数必须是同类的引用,一般加
const(保证原对象不会被修改) - 属于构造函数,没有返回值
- 如果不手写,编译器会自动生成默认拷贝构造:做浅拷贝(直接逐字节复制成员的值)
#include <iostream>
using namespace std;
class Date
{
private:
int year;
int month;
int day;
public:
// 普通带参构造
Date(int y, int m, int d)
{
year = y;
month = m;
day = d;
}
// 拷贝构造函数
Date(const Date &d)
{
year = d.year;
month = d.month;
day = d.day;
cout << "拷贝构造执行" << endl;
}
void show()
{
cout << year << "-" << month << "-" << day << endl;
}
};
int main()
{
Date d1(2025,7,18);
Date d2 = d1; // 触发拷贝构造
Date d3(d1); // 触发拷贝构造
d2.show();
d3.show();
return 0;
}📌 什么时候会调用拷贝构造(3种核心场景)
- 用已有对象初始化新对象:
Date d2 = d1;/Date d2(d1); - 函数参数是类对象(值传递),实参传给形参时
void func(Date tmp)
{
}
// 调用 func(d1); 会调用拷贝构造所以类对象传参优先用
const Date&引用传递,避免不必要拷贝
- 函数按值返回类对象,返回的时候会触发拷贝构造
⚠️ 浅拷贝 vs 深拷贝(重点考点)
- 浅拷贝(编译器默认拷贝构造):直接复制成员的值 如果成员里有
new出来的堆指针,拷贝后两个对象的指针指向同一块堆内存 析构的时候会重复释放同一块内存 → 程序崩溃
✅ 小结卡片
- 拷贝构造本质是构造函数,参数必须是同类const引用
- 默认拷贝 = 浅拷贝;有动态堆内存(new),必须手写深拷贝
- 拷贝构造调用三场景:对象初始化、值传参、值返回对象
6.this指针
含义
this 是C++关键字,是一个const指针,指向当前正在调用成员函数的对象,用来访问当前对象的成员。
注意:
this是成员函数的隐式参数,只存在于非静态成员函数里,静态成员函数没有this。
作用1:区分成员变量和形参(最常用)
当形参名 和 成员变量名字一模一样时,直接写 year = year 分不清,用 this-> 指明:左边是对象自己的成员。
Date(int year, int month, int day)
{
this->year = year;
this->month = month;
this->day = day;
}this->year:当前对象的成员变量- 右边
year:函数传入的形参
作用2:返回当前对象本身(链式调用,赋值重载高频)
Date& addDay(int d)
{
this->day += d;
return *this; // *this 就是当前对象本体,返回引用支持连续调用
}作用3:在成员函数中判断是不是自己给自己赋值
if(this == &other)
{
// 自己赋值给自己,直接return,防止重复释放内存
return *this;
}✅ this指针重要特性(背诵点)
- 类型:
类名 *const this→ 指针本身不可修改,不能让this指向别的对象;不是指向const对象,是指针const:
this这个地址值不能改,对象内容默认可以改。 如果是const成员函数:const 类名 *const this,对象内容也不能改 - 存储:一般存放在栈(或者寄存器),不属于对象本身,sizeof对象的时候不算this
- 不能在外面手动取、不能给this赋值,编译器自动传参
- 静态成员函数没有this指针,所以静态成员不能直接访问普通成员
小卡片总结
this:指向当前对象的const指针,非静态成员函数自带this->成员:访问当前对象成员,解决名字冲突*this:代表当前对象- 经典场景:同名参数区分、赋值重载自判、链式返回
7.友元
含义
正常情况下,类外面不能直接访问 private / protected 成员; 友元就是给外部开一个特权:让指定函数 / 指定类,可以直接访问本类的私有、保护成员。
关键字:
friend⚠️ 友元破坏封装性,属于“特例工具”,不要滥用。
友元分3种:全局友元函数、成员友元函数、友元类
1. 全局函数作为友元
在类内部声明 friend + 全局函数,这个全局函数就拥有访问权限
#include <iostream>
using namespace std;
class Box
{
double width; // 私有成员
public:
// 声明全局函数printWidth是友元
friend void printWidth(Box box);
void setWidth(double wid)
{
width = wid;
}
};
// 全局友元函数,不属于Box,但是能直接访问width
void printWidth(Box box)
{
cout << box.width << endl;
}
int main()
{
Box box;
box.setWidth(10.0);
printWidth(box);
return 0;
}2. 其他类的成员函数作为友元
只开放另一个类里某一个成员函数作为友元(精准授权)
class BigBox; // 前向声明,必须写!
class Box
{
double width;
public:
// 只把 BigBox 的Print函数设为友元
friend void BigBox::Print(int width, Box &box);
void setWidth(double wid)
{
width = wid;
}
};
class BigBox
{
public:
void Print(int w, Box &box)
{
box.setWidth(w);
cout << box.width << endl; // 可以访问Box私有成员
}
};3. 友元类(整个类都是友元)
friend class BigBox; 代表:BigBox里面所有成员函数,全都可以访问Box的私有/保护成员
class Box
{
double width;
public:
friend class BigBox; // 友元类,一次性全部开放
void setWidth(double wid)
{
width = wid;
}
};
class BigBox
{
public:
void func1(Box &b) { cout << b.width; }
void func2(Box &b) { cout << b.width; }
};📌 必考规则(背诵)
- 友元关系单向,不能传递,不能继承
- A是B的友元 ≠ B是A的友元
- A是B友元,B是C友元 ≠ A是C友元
- 父类友元,子类不会自动继承这个友元权限
friend只是声明,不是成员;友元函数不属于这个类,没有this指针- 友元声明放在
public / private / protected里面效果完全一样,只代表授权 - 什么时候常用:运算符重载(
<<输出重载,几乎都要用全局友元)
✅ 背诵小卡片
- friend:给外部开放私有成员访问权限,破坏封装,谨慎使用
- 三类友元:全局友元函数、别的类的成员友元函数、友元类
- 单向、不传递、不继承;友元不是类成员,无this
- 高频考点:
operator<<输出流重载,一般写成全局友元
下一节:静态成员(static 成员变量、static成员函数),继续吗?
8.类的静态成员
定义
使用 static 关键字来把类成员定义为静态的
特点
当我们声明类的成员为静态时,这意味着无论创建多少个类的对象,静态成员都只有一个副本。
class Box
{
public:
static int objectCount;
// 构造函数定义
Box(double l=2.0, double b=2.0, double h=2.0)
{
cout <<"Constructor 被调用." << endl;
length = l;
breadth = b;
height = h;
// 每次创建对象时增加 1
objectCount++;
}
double volume()
{
return length * breadth * height;
}
private:
double length; // 长度
double breadth; // 宽度
double height; // 高度
};
// 初始化类 Box 的静态成员
int Box::objectCount = 0;
int main(void)
{
Box box1(3.3, 1.2, 1.5); // 声明 box1
Box box2(8.5, 6.0, 2.0); // 声明 box2
// 输出对象的总数
cout << "对象数量: " << Box::objectCount << endl;
return 0;
}核心一句话:加上
static之后,这个成员不属于某个对象,属于整个类,所有对象共享同一份。
- 普通成员:每个对象独立一份,存在对象内存里
- 静态成员:全局静态区只有一份副本,不和对象绑定
静态成员变量(static 成员变量)
- 不属于对象,所有对象共享同一个变量
- 必须在类外面初始化(高频考点)
class Box { public: static int objectCount; // 类内只是【声明】,不是定义 Box() { objectCount++; } }; // ✅ 类外初始化、分配内存 int Box::objectCount = 0; - 两种访问方式:
// 方式1:类名::静态变量(推荐,无需创建对象) cout << Box::objectCount; // 方式2:对象.静态变量(语法允许,不推荐) Box b; cout << b.objectCount; - 静态成员变量同样受
public/private访问限定控制;private 静态成员外部不能直接访问。 - 本例用途:
objectCount用来统计一共创建了多少个Box对象,每次构造函数执行就+1。
静态成员函数 static 成员函数
class Box
{
public:
static int objectCount;
static void showCount()
{
// ✅ 可以访问静态成员变量
cout << objectCount << endl;
// ❌ 不能直接访问普通成员变量!没有this指针
// cout << length; 报错
}
};
int Box::objectCount = 0;静态成员函数核心规则:
- 没有this指针(超级高频考点)
- 只能直接访问静态成员变量 / 静态成员函数
- 不能直接访问普通成员(普通成员依附对象,没有this无法定位)
- 调用方式:
Box::showCount(); // 优先类名调用,不需要对象 Box b; b.showCount(); // 语法允许,不推荐
对比背诵表
| 项目 | 普通成员 | static静态成员 |
|---|---|---|
| 归属 | 属于单个对象,每个对象独立一份 | 属于类,所有对象共享同一份 |
| 存储位置 | 对象空间内(栈/堆) | 静态全局区,不在对象里 |
| this指针 | 有this | 没有this |
| 访问权限 | 成员函数可访问静态、普通成员 | 静态函数只能访问静态成员 |
| 初始化 | 构造函数初始化 | 静态变量类外单独初始化 |
| 调用 | 必须依托对象 obj.xxx | 类名::xxx / 对象.xxx |
⚠️ 易错坑
- 静态成员变量类内声明,类外定义初始化,忘记初始化 → 链接报错
- 静态成员函数想用普通成员:必须手动传入对象
void show(Box &b){b.length;} - static只代表归属类,
private/public访问控制依旧生效 - 静态成员不属于对象,
sizeof(Box)的大小不会包含静态成员
✅ 典型场景
- 对象计数(本例)
- 全局共享配置、常量
- 无状态工具函数、工具类
9.指向类的指针
与指向结构体的指针类似,访问指向类的指针成员,需要使用成员访问运算符
->与所有的指针一样,您必须在使用指针之前,对指针进行初始化。
#include <iostream>
using namespace std;
class Box
{
public:
Box(double l=2.0, double b=2.0, double h=2.0)// 构造函数定义
{
cout <<"构造函数的调用" << endl;
length = l;
breadth = b;
height = h;
}
double Volume()//计算体积
{
return length * breadth * height;
}
private:
double length; //长度
double breadth; //宽度
double height; //高度
};
int main(void)
{
Box Box1(3.3, 1.2, 1.5); //创建对象 Box1
Box Box2(8.5, 6.0, 2.0); //创建对象 Box2
Box *ptrBox; //创建一指向类的指针
ptrBox = &Box1;//保存第一个对象的地址
// 现在尝试使用成员访问运算符来访问成员
cout << "Box1 的体积是: " << ptrBox->Volume() << endl;
ptrBox = &Box2;//保存第二个对象的地址
// 现在尝试使用成员访问运算符来访问成员
cout << "Box2 的体积是: " << ptrBox->Volume() << endl;
return 0;
}✅ 小总结
- 对象访问成员两种写法
- 普通对象:
.,Box1.Volume() - 对象指针:
->,ptrBox->Volume() - 等价写法:
( *ptrBox ).Volume(),先解引用拿到对象,再用.
- 普通对象:
- 类指针可以反复指向不同对象,修改指针存储的地址即可。
- ⚠️ 重要:指针在使用前一定要赋值(初始化),野指针直接访问成员会崩溃。
- 本质:
Box*只是保存一个Box对象的起始地址,它本身不是对象,不包含成员变量。
对比速记
| 形式 | 符号 | 适用场景 |
|---|---|---|
| 对象名.成员 | . | 实体对象 |
| 指针->成员 | -> | 指向对象的指针 |
10.继承
定义
继承是代码可以复用的最重要的手段。 它允许程序员在保持原有类特性的基础上进行扩展,增加功能。这样产生的新类,称派生类(子类),被继承的类称基类(父类)。
举例:xx继承父亲遗产,xx是子类,父亲是父类;子类拥有父类的遗产,同时也可以拥有自己独有的财富。
语法格式:
class 新类的名字 : 继承方式 继承类的名字 {
};三种继承类型
开发中几乎只用 public 继承,protected、private继承很少使用。
| 继承方式 | 规则 |
|---|---|
public 继承 | 父类成员在子类中保持原有访问级别 |
private 继承 | 父类的 public / protected 成员,在子类全部变成 private |
protected 继承 | 父类 public → 子类 protected;父类 protected 保持 protected;父类 private 不变 |
✅ 重要结论: 无论哪种继承方式,父类的 private 成员,子类都不能直接访问;但是它在子类对象内存中依然存在。
示例代码
#include <iostream>
using namespace std;
class A {
private:
int a;
protected:
int b;
public:
int c;
A() {
a = 0;
b = 0;
c = 0;
}
void set(int a, int b, int c) {
this->a = a;
this->b = b;
this->c = c;
}
};
// public继承
class B : public A {
public:
void print() {
// cout << "a = " << a; // 报错,不能访问父类private
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
};
// protected继承
class C : protected A {
public:
void print() {
// cout << "a = " << a; // 报错
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
};
// private继承
class D : private A {
public:
void print() {
// cout << "a = " << a; // 报错
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
};
int main() {
A aa;
B bb;
C cc;
D dd;
aa.c = 100; // ok
bb.c = 100; // ok,public继承,c对外仍是public
// cc.c = 100; // err,protected继承后c变成protected,外部不能访问
// dd.c = 100; // err,private继承后c变成private,外部不能访问
aa.set(1, 2, 3);
bb.set(10, 20, 30);
// cc.set(40, 50, 60); // err
// dd.set(70, 80, 90); // err
bb.print();
cc.print();
dd.print();
return 0;
}继承中的构造函数(初始化列表调用父类构造)
规则:子类构造时,优先执行父类构造函数;如果父类有带参构造,子类必须通过初始化列表显式调用父类构造。
#include <iostream>
using namespace std;
class Base {
public:
Base(char _c, int _a) {
c = _c;
a = _a;
}
void display() {
cout << "a=" << a << " c=" << c << endl;
}
private:
int a;
char c;
};
class SubClass : public Base {
private:
int b;
public:
// 初始化列表调用父类构造 Base(c,a)
SubClass(int _b, int a, char c) : Base(c,a) {
b = _b;
}
void display() {
Base::display(); // 调用父类同名函数
cout << "子类自己的属性 b:" << b << endl;
}
};
int main() {
SubClass subClass(1,2,'x');
subClass.display();
return 0;
}多继承
C++ 支持多继承,但是日常开发少用,容易逻辑混乱,考试会考。 语法:多个父类用逗号隔开,每个父类可以单独指定继承方式
class D : public A, private B, protected C {
// D新增成员
};问题1:同名成员二义性(两个父类有同名函数)
#include <iostream>
using namespace std;
class Parent_f {
public:
void show() {
cout << "This is Parent_f\n";
}
};
class Parent_m {
public:
void show() {
cout << "This is Parent_m\n";
}
};
class Son: public Parent_f, public Parent_m {
public:
void display() {
cout << "This is son\n";
}
};
int main() {
Son son;
// son.show(); // 报错!二义性,不知道调用哪个父类show
son.display();
return 0;
}✅ 两种解决办法:
- 作用域限定符
::指定父类
son.Parent_f::show();
son.Parent_m::show();- 在子类定义同名函数,覆盖父类版本
class Son: public Parent_f, public Parent_m {
public:
void display() {
cout << "This is son\n";
}
void show() {
cout << "show:This is son.\n";
}
};问题2:菱形继承(路径二义性)
结构:Grandpa → Parent_f / Parent_m → Son Son同时继承Parent_f、Parent_m,而Parent_f、Parent_m都继承Grandpa,Son里面会存两份Grandpa成员,访问时产生歧义。
#include <iostream>
using namespace std;
class Grandpa {
public:
int year_old;
};
class Parent_f: public Grandpa {};
class Parent_m: public Grandpa {};
class Son: public Parent_f, public Parent_m {};
int main() {
Son son;
// son.year_old = 10; // 报错,二义性,两份year_old
return 0;
}✅ 解决方案:虚继承 virtual 在中间父类继承Grandpa时加上virtual,合并为同一份祖父类成员
#include <iostream>
using namespace std;
class Grandpa {
public:
int year_old;
void show() {
cout << "year_old:" << year_old << endl;
}
};
// virtual 虚继承
class Parent_f: virtual public Grandpa {};
class Parent_m: virtual public Grandpa {};
class Son: public Parent_f, public Parent_m {};
int main() {
Grandpa grp;
Parent_f pa_f;
Parent_m pa_m;
Son son;
grp.year_old = 100;
pa_f.year_old = 55;
pa_m.year_old = 50;
son.year_old = 10; // 现在没有二义性
grp.show();
pa_f.show();
pa_m.show();
son.show();
return 0;
}✅ 继承小结
- public继承:父类public对外依然public,protected子类内部可见、外部不可见,private子类永远不能直接访问;
- 子类构造,先父、后子;父类带参构造,子类必须初始化列表调用;
- 多继承容易产生二义性:同名成员用
类名::成员;菱形继承用virtual虚继承; - private/protected继承项目几乎不用,优先public继承。
11.多态
一、多态分类
- 静态多态(编译期多态) 编译阶段就确定调用哪个函数,代表:函数重载、运算符重载
- 动态多态(运行期多态,重点) 程序运行的时候,才判断调用哪个函数,靠 虚函数 virtual 实现
✅ 动态多态 两个必要条件(必须同时满足!)
- 使用基类指针 / 基类引用,指向子类对象
Person &tmp1 = s; // 引用方式
Person *tmp3 = new Student; // 基类指针指向子类
Person *tmp3 = &s;- 被调用的函数是虚函数(virtual)
缺一不可:只有普通继承、没有virtual,只会调用基类函数,不会多态。
二、虚函数 & 重写(override)
1. 基础写法
父类函数前面加 virtual,子类写一个一模一样的函数,就是重写
- 要求:函数名、参数列表、返回值 相同
- 小知识点:子类重写的时候,virtual 可以省略,仍然是虚函数(建议写上可读性更好)
class A {
public:
virtual void func(int val) {
cout << "A->" << val << endl;
}
};
class B : public A {
public:
// 这里virtual可以不写,依然是重写
void func(int val) {
cout << "B->" << val << endl;
}
};2. 特殊:协变(返回值不一样,但仍然构成重写)
规则:基类返回【基类指针/引用】,子类返回【子类指针/引用】,属于父子关系,允许返回值不同,叫做协变
class Person {
public:
virtual Person& buyBucket() {
cout << "全价" << endl;
return *this;
}
};
class student:public Person {
public:
virtual student& buyBucket() {
cout << "半价" << endl;
return *this;
}
};三、关键区分:虚函数 vs 普通成员函数
A *p2 = new B;
p2->func(2); // func是虚函数 → 多态,调用B::func
p2->add(); // add没有virtual → 不是虚函数,永远调用A::add一句话:基类指针只能访问基类的成员,能不能跑到子类版本,看这个函数是不是虚函数
四、底层原理:虚函数表 vtable
- 只要类里面有虚函数,这个类就会生成一张虚函数表(vtable),里面存放虚函数的地址
- 这个类的对象里面,会多一个虚表指针 vptr,指向本类的虚函数表
- 子类继承父类:
- 如果没有重写:虚表直接抄父类的虚函数地址
- 如果重写了虚函数:子类虚表里,对应位置替换成自己函数的地址
- 运行时:基类指针顺着vptr找到虚表,拿函数地址调用,实现运行时选函数
五、补充注意点
- 构造析构顺序:父类先构造,子类后构造;子类先析构,父类后析构
👉 重要考点:如果多态场景,基类析构函数建议写成虚析构 virtual ~A(),不然delete基类指针的时候,子类析构不会执行,内存泄漏!(你这份PPT这里没写,面试高频)
- 只有虚函数才能触发多态,普通成员函数、静态static函数都不行(static不属于对象,没有vptr)
六、背诵小卡片(刷题面试直接背)
- 静态多态:编译期,函数重载
- 动态多态:运行期,虚函数
- 动态多态两条件:基类指针/引用 + 虚函数重写
- 子类重写虚函数:virtual可省略;协变允许返回父子类引用/指针
- 底层:虚表vtable + 对象内虚表指针vptr
- 坑:普通函数不会多态;多态基类析构建议virtual
