学完C再学C++(6)继承类

最新推荐文章于 2024-08-19 18:41:12 发布

觊

最新推荐文章于 2024-08-19 18:41:12 发布

阅读量137

点赞数

分类专栏： C++ 文章标签： c++ c语言 p2p

本文链接：https://blog.csdn.net/qq_45054754/article/details/125121906

版权

C++ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

/*
第12章类的继承
1.派生一个类
   class NewClassName: public FatherClassName{
   //自己的构造函数,数据成员和成员函数
   }
   派生类对象存储了基类的数据成员,派生类对象存储了基类的方法(相当于结构体套娃)
   派生类的构造函数必须给自己和基类成员提供数据.

   派生类的构造函数:
   NewClassName:NewClassName(...):FatherClassName(...)使用基类的特定某个构造函数
   NewClassName:NewClassName(...)等价于下面的
   NewClassName:NewClassName(...):FatherClassName()使用基类的默认构造函数
   派生类会先创建基类再创建自己,派生类不能访问基类的私有成员
2.多态公有继承
   虚函数:

   当派生类中有与基类一样的方法时,在基类声明时使用virtual 关键字代表它是虚函数,当基类用指针或者引用强制指向派生类,然后再强转这是会有不一样.
   NewClassName a;
   FatherClassName *b =&a;
   (*b).Virtualfunc()
   //   若有创建虚方法,则是NewClassName::Virtualfunc(),没有声明则是FatherClassName的方法.
   //意思是不管你指针指类型换成谁,原来的指针是虚函数我就要调用原来那个的.
   使用虚的析构函数可以保证不管你咋折腾你的对象她还是最后会先调用派生类的析构函数,然后再调用基类的析构函数

   记住,派生类要在某个函数定义中调用自己与基类有同名字的函数时,要加上作用域.
   不然结果变成你想调用基类的,最后调用自己的了.
   BothFunc() //NewClassName的
   FatherClassName:BothFunc() //FatherClassName的

3.静态联合编译和动态联合编译
编译过程中就能知道调用哪个函数叫静态联编,
但是由于虚函数的出现就导致不能编译时就确定,需要再程序运行时确定使用哪个同名函数.

   指针和引用的兼容性
   一般情况不允许一个指针指向其他的类型,比如int的指针指向double的地址,
   但是基类和派生类例外.
   基类的指针可以指向派生类的引用(地址).
   也可以派生类指针指向基类,不过要做显式的强制转换

   静态联编效率更高但是不能编虚函数,若设计了虚函数,则需要动态联编.
4.访问控制:protected
   protected 派生类和自己可以访问其他不能访问

5.抽象基类
ABC简称abstract base class 意思是两个类有些共同点,然后就写一个基类派生出这两个类

   纯虚函数:
       ABC相较于被抽象的不能实现的函数
       形式为:虚函数后面加一个const=0;

   ABC中必须有至少一个纯虚函数,不然她就不叫抽象了.
6.继承中的内存分配
   大前提:基类使用了new分配空间
   派生类使用new和不使用new是两种情况
   不使用
       就不需要编写额外的赋值重载函数和构造函数,这在stringbad里面是一样的
   使用new:
       析构函数只需要释放自己分配的空间,C++会自动调用基类的析构函数,不需要释放基类的空间.

       派生类复制类的构造函数
       入想把一个派生类赋值给另一个派生类,编写函数时,先用基类的复制构造函数把基类部分复制过去,再复制自己的.
       这么写: SonClass::SonClass(const SonClass &sc):FatherClass(sc){new xx ;strcpy xx;}

派生类等号的重载
等号重载同样要多一步,那就是将其所包含的基类也赋值了

       SonClass &SonClass::operator=(const SonClass &sc)
       {
           if(this==sc)return *this;
           FatherClass::operator=(cs);//让自己的基类也被赋值
           delete [] x;
           x= new(...);
           strcpy(...);//赋值自己的内存空间
           ///.....
       }
       若使用友元函数重载符号,那么友元函数不属于这个类,所以不能用作用域区分谁的,怎么让派生类也使用基类的重载后的运算符呢?
       答案是使用派生类的友元重载,然后在派生类中使用强制类型转换成基类,这样就能兼容了

这一章又臭又长,寄
*/

#include <iostream>
#include <fstream>
#include<string.h>
#include "study.h"//里面写的#define DAY1....


#ifdef DAY7
//练习课后题4.  课后题3给人感觉完全没卵用,强行为了抽象而抽象.
#ifndef Hfile
//头文件部分
using namespace std;
//基类
class port
{
private:
    char* brand;    //应该是型号
    char style[20];//红酒品类吧
    int bottles;    //酒的数量

public:
    port(const char* br = "none", const char* st = "none", int bo = 0);
    port(const port& p);//防止构造时生成默认的,默认的会直接复制对象,里面指针还是没变
    virtual    ~port() { delete[] brand; }
    port& operator=(const port& p);
    port& operator+=(int b);
    port& operator-=(int b);
    virtual void show()const;
    int bottle_count()const { return bottles; }
    friend ostream& operator<<(ostream& os, const port& p);

};
//老程序员留的烂摊子,派生类
//问题b:为什么有些方法重新定义了,有些没有?
//答:因为show多了nickname和year,等号也需要给新的这些成员赋值
//问题c:为什么这个没有将operator=和operator<<声明成虚的?
//答:operator<<声明成了友元函数,没理由变成虚的,等号是因为若是等号也虚了,那么指针就无法相互转换了 
// 比如vp *a= b(p) 就会变成 vp::operator=(b);那最后就变成直接重新分配了一个空间给*a,虚函数作用就体现不出来了.
//声明成虚的那两个,析构函数必须保证能释放完全,show则是也要想显示完全
class vin_port :public port
{
private:
    char* nickname;
    int year;
public:
    //vin_port();
    vin_port(const char *br="none", int bo=0, const char* nn="none", int y=0);
    vin_port(const vin_port& p);
    ~vin_port() { delete[] nickname; }
    vin_port& operator=(const vin_port& vp);
    void show()const;
    friend ostream& operator<<(ostream& os, const vin_port& vp);

};


#endif

//基类部分
port::port(const char* br , const char* st , int bo)
{
    int len = strlen(br)+1 ;
    brand = new char[len];
    memcpy(brand,br,len);
    len= strlen(st);
    memcpy(style, st,len);
    bottles = bo;
}
port::port(const port& p)
{
    int len = strlen(p.brand)+1;
    brand = new char[len];
    memcpy(brand, p.brand, len);
    len = strlen(p.style);
    memcpy(style, p.style, len);
    bottles = p.bottles;
}
//为了防止赋值时把指针也复制过去
port& port::operator=(const port& p)
{
    if (this == &p)return *this;
    free(brand);//先释放原来的
    int len = strlen(p.brand)+1;
    brand = new char[len];
    memcpy(brand, p.brand, len);
    len = strlen(p.style);
    memcpy(style, p.style, len);
    bottles = p.bottles;
    return *this;
}
port& port:: operator+=(int b)
{
    bottles += b;
    return *this;
}
port& port:: operator-=(int b)
{
    bottles -= b;
    return *this;
}
void port::show()const
{
    cout << "Brand:" << brand << endl;
    cout << "Kind:" << style << endl;
    cout << "Bottles:" << bottles << endl;
}
//友元函数,返回os是为了os<<a<<b也能用
ostream& operator<<(ostream& os, const port& p)
{
    os << p.brand << ", " << p.style << ", " << p.bottles << endl;
    return os;
}

//派生类部分
vin_port::vin_port(const char* br, int bo, const char* nn, int y):port(br,"none", bo)
{
    int len = strlen(nn) + 1;
    nickname = new char[len];
    memcpy(nickname, nn, len);
    year = y;
}
vin_port::vin_port(const vin_port& vp):port(vp)
{
    int len = strlen(vp.nickname) + 1;
    nickname = new char[len];
    memcpy(nickname, vp.nickname, len);
    year = vp.year;
}
vin_port& vin_port::operator=(const vin_port& vp)
{
    if (this == &vp)return *this;
    port::operator=(vp);
    
    free(nickname);//先释放原来的
    int len = strlen(vp.nickname) + 1;
    nickname = new char[len];
    memcpy(nickname, vp.nickname, len);
    year = vp.year;
    return *this;
}
void vin_port::show()const
{
    port::show();
    cout << "Name:" << nickname << endl;
    cout << "Year:" << year << endl;
}
ostream& operator<<(ostream& os, const vin_port& vp)
{
    os << ", " << vp.nickname<<", "<<vp.year;
    return os;
}
int main()
{
    port* point;
    port p1 ("老八","小汉堡儿",114514);
    p1.show();
    p1 = p1;
    cout << p1;

    vin_port p2("老八",14,"豆腐乳",514);
    point = &p2;
    point->show();
    cout << *point;//会调用port的<<
    //vin_port();= (vin_port)p1
    
    return 0;
}

#endif`