c++继承层次结构实践

简介: 这篇文章通过多个示例代码,讲解了C++中继承层次结构的实践应用,包括多态、抽象类引用、基类调用派生类函数,以及基类指针引用派生类对象的情况,并提供了相关的参考链接。

类库开发实践。

一 polymorphic_value.cpp


//https://www.zhihu.com/question/564819820/answer/2747041093

#include <iostream>
#include <vector>
#include <array>
#include <iterator>
#include <memory>
#include <utility>
#include <typeinfo>
#include <cassert>
#include <QCoreApplication>

class Shape
{
   
public:
    std::unique_ptr<Shape> Clone() const
    {
   
        std::unique_ptr<Shape> result = DoClone();
        assert(typeid(*result) == typeid(*this) && "Every derived class must correctly override DoClone.");
        return result;
    }

    virtual void Draw() = 0;

    virtual ~Shape() = default;
protected:
    Shape() = default;

    Shape(const Shape&) = default;
    Shape(Shape &&) = default;
    Shape& operator=(const Shape&) = default;
    Shape& operator=(Shape&&) = default;

private:
    virtual std::unique_ptr<Shape> DoClone() const = 0;
};

class Circle : public Shape
{
   

public:
    void Draw() override
    {
   
        std::cout << "Draw a circle." << std::endl;
    }

private:
    std::unique_ptr<Shape> DoClone() const override
    {
   
        return std::make_unique<Circle>(*this);
    }
};

class Square : public Shape
{
   

public:
    void Draw() override
    {
   
        std::cout << "Draw a Square." << std::endl;
    }

private:
    std::unique_ptr<Shape> DoClone() const override
    {
   
        return std::make_unique<Square>(*this);
    }
};


class Picture
{
   
public:
    explicit Picture(std::unique_ptr<Shape> shape):shape_(std::move(shape)){
   };

    explicit Picture(const Shape& shape):shape_(shape.Clone()){
   }

    Picture(const Picture &rhs) : shape_(rhs.shape_->Clone()){
   }

    Picture& operator=(const Picture& rhs)
    {
   
        if(this!=&rhs)
        {
   
            shape_ = rhs.shape_->Clone();
        }
        return *this;
    }

    Picture(Picture&&) = default;

    Picture& operator=(Picture&&) = default;
    ~Picture() = default;

    void ChangeShape(std::unique_ptr<Shape> shape)
    {
   
        shape_ = std::move(shape);
    }

    void ChangeShape(const Shape& shape)
    {
   
        shape_ = shape.Clone();
    }

    void Draw()
    {
   
        shape_->Draw();
    }

private:
    std::unique_ptr<Shape> shape_;
};

int main(int argc, char *argv[])
{
   
    QCoreApplication a(argc, argv);

    Picture picture1(std::make_unique<Circle>());
    picture1.Draw();
    Picture picture2(std::make_unique<Square>());
    picture2.Draw();

    Picture picture3(picture1);
    picture3.Draw();

    picture3 = picture2;
    picture3.Draw();

    Picture picture4(std::move(picture1));
    picture4.Draw();
    picture4 = std::move(picture2);
    picture4.Draw();

    Picture picture5(std::move(picture1));
    picture5.Draw();
    picture5.ChangeShape(std::make_unique<Square>());
    picture5.Draw();

    Circle circle;
    Square square;

    Picture picture6(circle);
    picture6.Draw();
    picture6.ChangeShape(square);
    picture6.Draw();

    Picture picture7(Circle{
   });
    picture7.Draw();
    picture7.ChangeShape(Square{
   });
    picture7.Draw();

    std::vector<Picture> pictures1;
    pictures1.emplace_back(std::make_unique<Circle>());
    pictures1.emplace_back(std::make_unique<Square>());
    pictures1.emplace_back(Circle{
   });
    pictures1.emplace_back(Square{
   });
    for(auto& picture : pictures1)
    {
   
        picture.Draw();
    }

    std::vector<std::unique_ptr<Shape>> shapes1;
    shapes1.push_back(std::make_unique<Circle>());
    shapes1.push_back(std::make_unique<Square>());
    for(auto& shape : shapes1 )
    {
   
        shape->Draw();
    }

    std::vector<Picture> pictures2{
   picture3,picture4,picture5,picture6,picture7};
    std::vector<Picture> pictures3(pictures1);
    std::vector<Picture> pictures4(std::move(pictures1));

    pictures3 = pictures2;
    pictures4 = std::move(pictures2);

    std::vector<std::unique_ptr<Shape>> shapes2;
    shapes2.push_back(std::make_unique<Circle>());
    shapes2.push_back(std::make_unique<Circle>());
    shapes2.push_back(std::make_unique<Circle>());

    auto init = std::to_array<std::unique_ptr<Shape>>({
   std::make_unique<Circle>(), std::make_unique<Square>()});
    std::vector<std::unique_ptr<Shape>> shape3(std::make_move_iterator(init.begin()), std::make_move_iterator(init.end()));

    std::vector<std::unique_ptr<Shape>> shapes5(std::move(shapes1));
    shapes5 = std::move(shapes2);

    return a.exec();
}

二 AbstractClassReference.cpp

//https://blog.csdn.net/daydr/article/details/121789356
//https://my.oschina.net/hanshubo/blog/1600658

#include<iostream>
using namespace std;
class Number
{
   
    public:
    Number(int i)
    {
   
        val=i;
    }
    virtual void show()const=0;//纯虚函数
    protected:
    int val;
};

class Hex:public Number
{
   
    public:
    Hex(int i):Number(i){
    }
    void show()const//别忘记后面的const
    {
   cout<<"Hex="<<val<<endl;}
};

class Dex:public Number
{
   
    public:
    Dex(int i):Number(i) {
    }
    void show()const
    {
   cout<<"Dex="<<val<<endl;}
};

class Oct:public Number
{
   
    public:
    Oct(int i):Number(i) {
    }
    void show()const
    {
   
        cout<<"Oct="<<val<<endl;
    }
};

void fun(Number &n)//普通函数定义引用抽象类的引用参数
{
   
    n.show();
}

void FUNShared(shared_ptr<Number> n)
{
   
    n->show();
}

int main()
{
   
#if 0
    Dex n1(50);
    fun(n1);//Dex::show();
    Hex n2(70);
    fun(n2);//Hex::show()
    Oct n3(29);
    fun(n3);//Oct::show()
#else

//    shared_ptr<Dex> n1(new Dex(50));
//    auto n1 = std::make_shared<Dex>(50);

    shared_ptr<Dex> n1 = std::make_shared<Dex>(50);
    FUNShared((std::shared_ptr<Number>)(n1));//Dex::show();
    FUNShared(static_pointer_cast<Number> (n1));//Dex::show();

    shared_ptr<Hex> n2 = std::make_shared<Hex>(70);
    FUNShared(static_pointer_cast<Number> (n2));//Hex::show()

    shared_ptr<Oct> n3 = std::make_shared<Oct>(29);
    FUNShared(static_pointer_cast<Number> (n3));//Hex::show()

    auto p2 = std::make_shared<string>("s");

#endif

}

三 baseCallDeriveFun.cpp

//https://blog.csdn.net/daydr/article/details/121863051
//https://blog.csdn.net/weixin_46222091/article/details/104832221

#include<iostream>
#include<cstring>
#include<memory.h>>
using namespace std;
class A_class
{
   
    char name[20];
    public:
    void put_name(char * s)
    {
   
        strcpy_s(name,s);
    }
    void show_name()const
    {
   cout<<name<<"\n";}
};
class B_class:public A_class
{
   
    char phone_num[20];
    public:
    void put_phone(char * num)
    {
   strcpy_s(phone_num,num);}
    void show_phone()const
    {
   cout<<phone_num<<"\n";}
};

int main()
{
   
#if 0
    A_class * A_p;
    A_class A_obj;
    B_class B_obj;
    A_p=&A_obj;
    A_p->put_name((char*)"Wang Liao hua");
    A_p->show_name();
    A_p=&B_obj;//基类指针指向派生类指针
    A_p->put_name((char*)"chen ming");//调用基类成员函数
    A_p->show_name();
    B_obj.put_phone((char*)"3333_12345678");//调用派生类成员函数
    ((B_class*)A_p)->show_phone();//对基类指针进行强制化转化

    //wrong
//    A_p=&B_obj;
//    A_p->put_phone((char*)"3333_12345678");
//    A_p->show_phone();

#else

//    cout << "使用智能指针" << endl;
    shared_ptr<A_class> *A_p;
//    shared_ptr<A_class*> A_p;
    shared_ptr<A_class> A_obj = make_shared<A_class>();
    shared_ptr<B_class> B_obj = make_shared<B_class>();

    A_p=&A_obj;
    A_p->get()->put_name((char*)"Wang Liao hua");
    A_p->get()->show_name();

//基类指针指向派生类指针 TODO
//    A_p=&B_obj;
//    A_p = std::dynamic_pointer_cast<B_class>(B_obj);
//    A_p = static_pointer_cast<B_class>(B_obj);
//    static_pointer_cast<B_class>(A_p)->get()->put_name((char*)"chen ming");//调用基类成员函数
//    A_p->get()->show_name();
//    static_pointer_cast<B_class>(A_p)->get()->put_name((char*)"chen ming");//调用基类成员函数
//    B_obj->get()->put_phone((char*)"3333_12345678");//调用派生类成员函数
//    ((B_class*)A_p)->show_phone();//对基类指针进行强制化转化
//    static_pointer_cast<B_class>(A_p)->show_phone();

#endif


}

四 ReferencesBaseObjectsWithDerivedClassPointers.cpp

//https://blog.csdn.net/daydr/article/details/121863051
//https://blog.csdn.net/xiaobai_xuec/article/details/124830524

#include<iostream>
#include<cstring>
using namespace std;

class Date
{
   

public:
    Date(int y,int m,int d)
    {
   
        SetDate(y,m,d);
    }

    void SetDate(int y,int m,int d)
    {
   
        year=y;
        month=m;
        day=d;
    }

    void print()
    {
   
        cout<<year<<'\''<<month<<"\'"<<day<<";";
    }

protected:
    int year,month,day;
};

class Datetime:public Date
{
   

public:
    Datetime(int y,int m,int d,int h,int mi,int s):Date(y,m,d)
    {
   
        settime(h,mi,s);
    }

    void settime(int h,int mi,int s)
    {
   
        hours=h;
        minutes=mi;
        seconds=s;
    }

    void print()const
    {
   
        cout<<hours<<":"<<minutes<<":"<<seconds<<":"<<'\n';
    }

private:
    int hours,minutes,seconds;
};

int main()
{
   

#if 0

//    Datetime dt(2021,12,22,12,30,0);
//    Datetime*pdt=&dt;
//    ((Date)dt).print();//对象类型的转化,调用基类函数
//    dt.print();
//    ((Date*)pdt)->print();//对象指针类型的转化,调用基类函数
//    pdt->print();

#else

    std::shared_ptr<Datetime> dt(new Datetime(2021,12,22,12,30,0));
    std::shared_ptr<Datetime> *pdt = &dt;
    static_pointer_cast<Date>(dt)->print();
    dt->print();//2021'12'22;12:30:0:

//    ((Date*)pdt)->print();
//    pdt->get()->print();//-1648667856'428'-1648667760;12:30:0:

    ((std::shared_ptr<Date> *)pdt)->get()->print();
    pdt->get()->print();//2021'12'22;12:30:0:

#endif

//    shared_ptr<int> p(new int(1));
//    shared_ptr<int> p1 = p;    // p和p1指向同一块内存
//    shared_ptr<int> p2;
//    // 使用reset初始化share_ptr
//    p2.reset(new int(1));    // p2和p3指向同一块内存
//    shared_ptr<int> p3(p2);
//    cout << (int*)&(*p) << endl;
//    cout << (int*)&(*p1) << endl;
//    cout << (int*)&(*p2) << endl;
//    cout << (int*)&(*p3) << endl;

//    shared_ptr<void> point(new int(1)); //共享指针内部保存void型指针
//    shared_ptr<int> point1(static_cast<int *>(point.get())); //compile error,undefined pointer
//    static_pointer_cast<int *>(point);    // OK

//    static_pointer_cast
//    dynamic_pointer_cast
//    const_pointer_cast
}

五 参考链接

https://www.zhihu.com/question/564819820/answer/2747041093
https://blog.csdn.net/daydr/article/details/121789356
https://my.oschina.net/hanshubo/blog/1600658
https://blog.csdn.net/daydr/article/details/121863051
https://blog.csdn.net/weixin_46222091/article/details/104832221
https://blog.csdn.net/daydr/article/details/121863051
https://blog.csdn.net/xiaobai_xuec/article/details/124830524

相关文章
|
4月前
|
监控 算法 数据处理
基于 C++ 的 KD 树算法在监控局域网屏幕中的理论剖析与工程实践研究
本文探讨了KD树在局域网屏幕监控中的应用,通过C++实现其构建与查询功能,显著提升多维数据处理效率。KD树作为一种二叉空间划分结构,适用于屏幕图像特征匹配、异常画面检测及数据压缩传输优化等场景。相比传统方法,基于KD树的方案检索效率提升2-3个数量级,但高维数据退化和动态更新等问题仍需进一步研究。未来可通过融合其他数据结构、引入深度学习及开发增量式更新算法等方式优化性能。
139 17
|
3月前
|
存储 安全 Java
c++--继承
c++作为面向对象的语言三大特点其中之一就是继承,那么继承到底有何奥妙呢?继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用,继承是类设计层次的复用,继承就是类方法的复用。
88 0
|
8月前
|
存储 算法 C++
【C++数据结构——查找】二分查找(头歌实践教学平台习题)【合集】
二分查找的基本思想是:每次比较中间元素与目标元素的大小,如果中间元素等于目标元素,则查找成功;顺序表是线性表的一种存储方式,它用一组地址连续的存储单元依次存储线性表中的数据元素,使得逻辑上相邻的元素在物理存储位置上也相邻。第1次比较:查找范围R[0...10],比较元素R[5]:25。第1次比较:查找范围R[0...10],比较元素R[5]:25。第2次比较:查找范围R[0..4],比较元素R[2]:10。第3次比较:查找范围R[3...4],比较元素R[3]:15。,其中是顺序表中元素的个数。
294 68
【C++数据结构——查找】二分查找(头歌实践教学平台习题)【合集】
|
8月前
|
存储 C语言 C++
【C++数据结构——栈与队列】顺序栈的基本运算(头歌实践教学平台习题)【合集】
本关任务:编写一个程序实现顺序栈的基本运算。开始你的任务吧,祝你成功!​ 相关知识 初始化栈 销毁栈 判断栈是否为空 进栈 出栈 取栈顶元素 1.初始化栈 概念:初始化栈是为栈的使用做准备,包括分配内存空间(如果是动态分配)和设置栈的初始状态。栈有顺序栈和链式栈两种常见形式。对于顺序栈,通常需要定义一个数组来存储栈元素,并设置一个变量来记录栈顶位置;对于链式栈,需要定义节点结构,包含数据域和指针域,同时初始化栈顶指针。 示例(顺序栈): 以下是一个简单的顺序栈初始化示例,假设用C语言实现,栈中存储
332 77
|
6月前
|
安全 C++
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
341 6
|
8月前
|
存储 C++
【C++数据结构——树】哈夫曼树(头歌实践教学平台习题) 【合集】
【数据结构——树】哈夫曼树(头歌实践教学平台习题)【合集】目录 任务描述 相关知识 测试说明 我的通关代码: 测试结果:任务描述 本关任务:编写一个程序构建哈夫曼树和生成哈夫曼编码。 相关知识 为了完成本关任务,你需要掌握: 1.如何构建哈夫曼树, 2.如何生成哈夫曼编码。 测试说明 平台会对你编写的代码进行测试: 测试输入: 1192677541518462450242195190181174157138124123 (用户分别输入所列单词的频度) 预
191 14
【C++数据结构——树】哈夫曼树(头歌实践教学平台习题) 【合集】
|
8月前
|
存储 C++ 索引
【C++数据结构——栈与队列】环形队列的基本运算(头歌实践教学平台习题)【合集】
【数据结构——栈与队列】环形队列的基本运算(头歌实践教学平台习题)【合集】初始化队列、销毁队列、判断队列是否为空、进队列、出队列等。本关任务:编写一个程序实现环形队列的基本运算。(6)出队列序列:yzopq2*(5)依次进队列元素:opq2*(6)出队列序列:bcdef。(2)依次进队列元素:abc。(5)依次进队列元素:def。(2)依次进队列元素:xyz。开始你的任务吧,祝你成功!(4)出队一个元素a。(4)出队一个元素x。
241 13
【C++数据结构——栈与队列】环形队列的基本运算(头歌实践教学平台习题)【合集】
|
8月前
|
算法 C++
【C++数据结构——查找】二叉排序树(头歌实践教学平台习题)【合集】
【数据结构——查找】二叉排序树(头歌实践教学平台习题)【合集】 目录 任务描述 相关知识 测试说明 我的通关代码: 测试结果: 任务描述 本关任务:实现二叉排序树的基本算法。 相关知识 为了完成本关任务,你需要掌握:二叉树的创建、查找和删除算法。具体如下: (1)由关键字序列(4,9,0,1,8,6,3,5,2,7)创建一棵二叉排序树bt并以括号表示法输出。 (2)判断bt是否为一棵二叉排序树。 (3)采用递归方法查找关键字为6的结点,并输出其查找路径。 (4)分别删除bt中关键
206 11
【C++数据结构——查找】二叉排序树(头歌实践教学平台习题)【合集】
|
8月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
167 19
|
8月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类(头歌实践教学平台习题)【合集】
声明一个CPU类,包含等级(rank)、频率(frequency)、电压(voltage)等属性,以及两个公有成员函数run、stop。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中,类是创建对象的蓝图。类的声明定义了类的成员,包括数据成员(变量)和成员函数(方法)。一个简单的类声明示例如下: classMyClass{ public: int
204 13