继承、运算符重载、多态、指针

本文详细介绍了C++中的面向对象编程概念,包括继承、覆盖、构造与析构函数、运算符重载、类型转换和异常处理。特别讨论了继承的三种方式(公共、保护和私有),以及虚函数和多态性在动态联编中的作用。此外,还提到了静态和动态类型转换,以及指针和函数的交互,包括指针运算、函数指针和回调函数。文章最后讨论了指针与数组的关系,并举例说明了数组名和指针的区别。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.继承

1.1继承的基本语法

继承的好处:可以减少重复的代码
基本语法:class A : class B{}
A类为派生类
B类为基类

派生类的成员分为两部分:
①基类中的所有成员
②自己增加的成员

1.2 继承特性

  • 派生类拥有基类的所有成员变量和成员函数
  • 派生类的各个成员函数都访问不到基类的private成员
  • 派生类所占内存空间包括基类中所有成员变量所占的内存空间

1.3 继承方式

一种有三种继承方式:
①公共继承:

class A
{
    public:
    int t1;
    protected:
    int t2;
    private:
    int t3;  
}
class B:public A
{
   public:
   int t4;
}

int main()
{
  //派生类的对象可以赋值给基类对象
  B b;
  A a;
  a = b;
  //派生类对象可以初始化基类引用
  A &a2 = b;
  //派生类对象的地址可以赋值给基类指针
  A* a3 = &b;
  return 0;
}
  • 派生类的对象可以赋值给基类对象
  • 派生类对象可以初始化基类引用
  • 派生类对象的地址可以赋值给基类指针(有可能出现数据损失,只会保存a和b中都有的成员变量)

以上称为派生类向基类的转换,是不可逆的。

②保护继承
基类的public成员和protected成员成为派生类的protected成员

③私有继承
基类的public成员成为派生类的private成员,基类的protected成员成为派生类的private成员

1.4 覆盖

派生类可以定义一个和基类成员同名的成员,叫做覆盖,要在派生类中访问由基类定义的同名成员时,要使用作用域符号::

1.5 派生类的构造析构

在创建派生类对象时,需要调用基类的构造函数:初始化派生类对象中从基类继承的成员
在执行一个派生类的构造函数之前,总是先执行基类的构造函数
调用基类构造函数的两种方式:
①显式调用:在派生类的构造函数中,为基类的构造函数提供参数
②隐式调用:在派生类的构造函数中,未显式调用基类构造函数时,派生类的构造函数则自动调用基类的默认构造函数
各种情况下的调用基类构造函数

派生类对象的析构顺序:与构造函数执行顺序相反
①先执行派生类自己的析构函数
②再依次执行各成员对象类的析构函数
③最后执行基类的构造函数

2.运算符重载

运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型
写法:
返回值类型 operator 运算符(形参表)
{
代码段
}
特性:
①重载为成员函数时,参数个数为运算符目数减一
②重载为普通全局函数时,参数个数为运算符目数

2.1 重载规则

  • 并非所有运算符都可以被重载,加减乘除、比较运算符、位运算符等可以重载,“.”、“::”、“?:”、sizeof等运算符不能被重载
  • 运算符重载不能改变运算符的优先级和结合性
  • 重载不会改变运算符的用法
  • 运算符重载函数不能有默认的缺省参数(注:缺省参数指在调用函数的时候,没有传入参数的情况下,会自动调用默认的参数值,传入参数的情况下,则会将传入的参数替代掉默认的参数)
  • 运算符重载函数既可以作为类的成员函数,也可以作为全局函数
  • 重载运算符()、[]、->或者赋值运算符=时,运算符重载函数必须声明为类的成员函数

2.2 自增自减运算符重载

自增运算符++、自减运算符–有前后置之分,为了区分所重载的运算符是前置还是后置运算符,C++规定:
前置运算符作为一元运算符
重载为成员函数时:

  • T& operator++()
  • T &operator–()

重载为全局函数时:

  • T1 &operator++(T2);
  • 他 &operator–(T2);

后置运算符作为二元运算符重载,多一个参数:
重载为成员函数时

  • T operator++(int);
  • T operator–(int)

重载为全局函数时:

  • T1 &operator++(T2, int);
  • T1 &operator–(T2, int);

3. C++扩展

3.1 类型强制转换

  • static_cast

static_cast用来进行低风险的转换,比如整型和实数型、字符型之间的转换

  • reinterpret_cast

reinterpret_cast用来进行不同类型指针、引用等之间的转换

  • const_cast

用来进行去除const属性的转换,将const引用转换成同类型的非const引用,将const指针转换成同类型的非const指针时使用

  • dynamic_cast

专门用于将多态基类的指针或应用,强制转换为派生类的指针或者引用

3.2 异常

出现异常的原因

  1. 数组越界
  2. 访问空指针
  3. 除数为0
  4. 动态内存分配所需储存空间太大
  5. 类型转换出现问题

使用try、catch、throw进行异常处理:

  1. try:try块中的代码标识将被激活的特定异常。它后面通常跟着一个或者多个catch块
  2. catch:在想要处理问题的地方,通过异常处理程序捕获异常,catch关键字用于捕获异常
  3. throw:当问题出现时,程序会抛出一个异常。

3. 多态

3.1 虚函数和多态

虚函数:在类的成员函数声明前加virtual
多态:
编译时:函数重载、运算符重载
运行时:拥有虚函数的类,在运行时编译器根据其指针或者引用来确定调用的函数所属的类

3.2 多态的表现形式

指针形式:派生类指针可以赋给基类指针
通过基类指针调用基类和派生类中的同名虚函数时,根据指针指向判断调用基类还是派生类的同名虚函数

引用形式:派生类对象可以赋给基类引用
通过基类引用调用基类和派生类中的同名虚函数时,根据引用哪个对象来判断调用基类还是派生类的同名虚函数

3.3 多态的实现原理

动态联编:多态关键在于通过基类指针或者引用调用一个虚函数时,编译时不确定(举例if else语句)到底调用的是基类还是派生类中的同名虚函数,只有运行时才确定

虚函数表:列出了该类对象的虚函数地址

多态的调用:多态的函数调用语句被编译成,由基类指针指向的对象,对象中存放一组由虚函数表的地址,在虚函数表中查找虚函数地址,调用虚函数

3.4 构造和析构函数中的多态

  1. 构造和析构函数中调用虚函数,不是多态,这是因为在编译时就已经确定了调用的时哪个虚函数
  2. 构造函数不能为虚函数
  3. 析构函数可以为虚函数,称为虚析构函数
    代码示例:
class people{
public:
virtual void hello(){cout<<"hello people"<<endl;}
virtual void bye(){cout<<"bye people"<<endl;}
};
class son:public people{
public:
void hello(cout<<"hello son"<<endl;);
son(){hello();};
~son(){bye();};
};
class grandson:public son{
public:
void hello(){cout<<"hello grandson"<<endl;};
void bye(){cout<<"bye grandson"<<endl;};
grandson(){cout<<"constructing grandson"<<endl;};
~grandson(){cout<<"destructing grandson"<<endl;};
};
int main(){
grandson gson;
son *pson;
pson = &gson;
pson->hello();
return 0;
}

以上代码运行后的结果是?
hello son
constructing grandson
hello grandson
destructing grandson
bye people

假如将class son中加入bye()的虚函数,打印bye son语句,则最终打印结果中的bye people将改变为bye son

3.5 虚析构函数

通过基类的指针删除对象时,通常编译器只会调用基类的析构函数
如果在基类的析构函数前加virtual关键字,则当通过基类的指针删除派生类的对象时,编译器会先调用派生类的析构函数,再调用基类的析构函数

示例代码:

class son{
public:
virtual	~son(){cout<<"bye son"<<endl;};
};
class grandson:public son{
public:
~grandson(){cout<<"bye grandson"<,endl;};
};
int main(){
son* pson;
pson = new grandson();
delete son;
return 0;
}

运行结果:
bye grandson
bye son
假如不在son()加virtual关键字,则运行结果将会只有bye son

3.6 纯虚函数和抽象类

纯虚函数:没有函数体的虚函数
class A{
public:
virtual void Print() = 0;
}
抽象类:包括纯虚函数的类

  • 抽象类只能作为基类来派生新类使用,不能创建独立的抽象类的对象
  • 抽象类的指针和引用可以指向由抽象类派生出来的类的对象

在抽象类的成员函数内可以调用纯虚函数,但是在构造和析构函数内部不能调用纯虚函数
传递性:如果一个类从抽象类派生而来,那么当且仅当它实现了基类中的所有纯虚函数,才成为非抽象类

4. 指针综合

4.1 指针初步

4.1.1 指针概念

定义:T* ptr,T表示类型,ptr表示指针变量名
概念:
1、每个变量都被存放在从某个内存地址(以字节为单位)开始的若干个字节中
2、指针大小为4个字节的变量,内容代表一个内存地址
3、通过指针能够对指针指向的区域进行连续读写

4.1.2 定义指针

通过指针访问其指向的内存空间
int* p = (int *)40000;
//往地址40000处起始的若干个字节的内存空间里写入5000
*p = 5000;
//将地址40000处起始的若干个字节的内容赋值给n
int n = *p;

T p;//T可以是任何类型的名字,比如int double
p的类型:T

*p的类型 :T

通过表达式*p,可以读写从地址p开始的sizeof(T)个字节
*p等价于存放在地址p处的一个T类型的变量
*间接引用运算符

4.1.3 使用指针

char ch = ‘a’;
char* p = &ch;//使p指向变量ch

*: 间接引用运算符也叫解引用,*p表示地址为p开始的若干个字节的内容
&:取地址符,&ch表示取变量ch的地址

在c++中,指针可以直接参与运算,用指针p指向a的地址,然后对p进行加减操作,p就能指向a后面或前面的内存区域,通过p也就能访问这些内存区域
注意:不同类型指针之间,不经过强制转换不能直接互相赋值

4.1.4 指针运算

1、两个相同类型的指针变量可以比较大小
地址p1<地址p2等价于p1<p2值为真,地址p1=地址p2等价于p1==p2值为真

2、两个相同类型的指针变量可以相减,结果和类型有关
指针p1-指针p2 = (p1地址-p2地址)/sizeof(T)

3、指针变量加减一个整数的结果是指针,结果和类型有关
指针p±整数n = p地址±n*sizeof(T)

4、指针变量可以自增自减,效果同3
p++,++p:p指向n+sizeof(T)

5、指针可以用下标运算符"[]"进行运算
p[n]等价于*(p+n)

4.1.5 特殊指针

二级指针:指向指针的指针

定义:T** p
p为指向指针的指针,p的类型为T**,p所在的内存空间存放一个T*类型的指针
使用**来访问数据
int n = 123;
int *p = &n;
int **pp = &p;
cout << *(*p) << endl;

多级指针:三级指针使用T ,访问数据时使用***。之后就此类推

野指针:只想不能访问或者已经被释放的内存空间的指针
char* str;
gets(str);
puts(str);
运行结果:程序编译不通过或输入后崩溃

空指针:不指向任何东西的指针,也可以表示为指向NULL或nullptr的指针
地址0不允许访问,在C语言中使用NULL表示0,可以用NULL关键字对任何类型的指针进行赋值,值为NULL的指针即为空指针,C++中推荐使用nullptr,原因:函数重载
NULL可以用做条件表达式使用,在做判断时,if§等价于if(p! = NULL)

void指针:void *p
万能指针,能够使用任何类型的指针对void指针赋值或初始化
double d = 1.54;
void p = nullptr;
p = &d;
注意:因为void没有特定的类型,所以sizeof(void)没有定义,同样对于void
类型的指针p,*p无定义,++p,–p等均无定义。

4.1.6 指针和函数

指针作为函数参数
用指针变量作函数参数可以将函数外部的地址传递到函数内部,使得在函数内部可以操作函数外部的数据,并且这些数据不会随着函数的结束而被销毁

指针作为函数返回值:函数返回值为指针(地址)
注意:函数运行结束后会放弃在函数内部定义的所有局部数据,包括局部变量、局部数组和形式参数,函数返回的指针尽量不要指向这些数据

4.1.7 函数指针

函数指针:指向一个函数的指针变量,可以通过函数声明或使用原型匹配的函数为指针赋值
定义:类型名(* 指针变量名)(参数类型1,参数类型2,…)
例如:int (*pf)(int, int);
使用:通过函数指针,并提供函数参数从而调用它指向的函数
函数指针名(实参表);如pf(1, 2);

回调函数:将函数作为函数参数传递,在C/C++中可以通过函数指针实现。
举例:函数指针和qsort库函数
c语言快速排序库函数:可以对任意类型的数组进行排序
void qsort(void* base, size_t num, unsigned int width, int (*pfCompare)(const void , const void ));
pfCompare:函数指针,它指向一个“比较函数”
该比较函数应为以下形式:
int 函数名(const void
elem1, const void
elem2);

4.1.8 指针和数组

关于数组名:
数组的名字是一个指针常量,指向数组的起始地址
T a[N]//a的类型为T* ,可以使用数组名a为T*类型的指针赋值
1、数组名可以赋值给指针,但数组名不是指针
2、数组名可以参与指针运算
3、数组名指向地址和数组首元素取地址,两者值相同,意义不同
举例:
int a[] = {1, 2, 3, 4, 5, 6};
int *p1 = a;
int *p2 = &a[0];
假设a首地址为p,sizeof(int) = 4, *(p1+1) = p + sizeof(a), *(p2+1) = a[1] = p + 1 * 4;

&a和&a[0]
&a表示取数组的地址,指针指向整个数组地址,字节大小包括数组长度
&a[0]表示取数组首元素的地址,指针指向数组首元素

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值