c++类继承

最新推荐文章于 2022-09-01 18:27:50 发布
原创 最新推荐文章于 2022-09-01 18:27:50 发布 · 307 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++继承

基类与派生类

（1）派生类对象存储了基类的数据成员
（2）派生类可以使用基类的方法
（3）派生类需要自己的构造函数
（4）派生类可以根据需要添加额外的数据成员和成员函数。

构造函数的考虑：
派生类不能直接访问基类的私有成员，而必须通过基类方法进行访问。
创建派生类对象时，程序首先创建基类对象。
派生类构造函数应通过成员初始化列表将基类信息传递给基类构造函数，派生类构造函数应初始化派生类新增的数据成员。

创建派生类对象时，程序 首先调用基类构造函数，因此将使用隐式构造函数。
派生类对象过期时，程序首先调用派生类析构函数，然后调用基类析构函数。

派生类与基类有一些特殊的关系。派生类对象可以使用基类的方法。
另外 两个重要关系是 基类指针（基类引用）在不进行显示类型转换的情况下指向派生类对象。

多态公有继承

有两种方法可以实现定义基类的方法：
1.在派生类中重新定义基类的方法。
2.使用虚方法。

开发brass类和brassplus类：

// brass.h  -- bank account classes
#ifndef BRASS_H_
#define BRASS_H_
#include <string>
// Brass Account Class
class Brass
{
private:
    std::string fullName;
    long acctNum;
    double balance;
public:
    Brass(const std::string & s = "Nullbody", long an = -1,
                double bal = 0.0);
    void Deposit(double amt);
    virtual void Withdraw(double amt);
    double Balance() const;
    virtual void ViewAcct() const;
    virtual ~Brass() {}
};

//Brass Plus Account Class
class BrassPlus : public Brass
{
private:
    double maxLoan;
    double rate;
    double owesBank;
public:
    BrassPlus(const std::string & s = "Nullbody", long an = -1,
            double bal = 0.0, double ml = 500,
            double r = 0.11125);
    BrassPlus(const Brass & ba, double ml = 500, 
                                double r = 0.11125);
    virtual void ViewAcct()const;
    virtual void Withdraw(double amt);
    void ResetMax(double m) { maxLoan = m; }
    void ResetRate(double r) { rate = r; };
    void ResetOwes() { owesBank = 0; }
};

// brass.cpp -- bank account class methods
#include <iostream>
#include "brass.h"
using std::cout;
using std::endl;
using std::string;

// formatting stuff
typedef std::ios_base::fmtflags format;
typedef std::streamsize precis;
format setFormat();
void restore(format f, precis p);

// Brass methods

Brass::Brass(const string & s, long an, double bal)
{
    fullName = s;
    acctNum = an;
    balance = bal;
}

void Brass::Deposit(double amt)
{
    if (amt < 0)
        cout << "Negative deposit not allowed; "
             << "deposit is cancelled.\n";
    else
        balance += amt;
}

void Brass::Withdraw(double amt)
{
    // set up ###.## format
    format initialState = setFormat();
    precis prec = cout.precision(2);

    if (amt < 0)
        cout << "Withdrawal amount must be positive; "

             << "withdrawal canceled.\n";
    else if (amt <= balance)
        balance -= amt;
    else
        cout << "Withdrawal amount of $" << amt
             << " exceeds your balance.\n"
             << "Withdrawal canceled.\n";
    restore(initialState, prec);
}
double Brass::Balance() const
{
    return balance;
}

void Brass::ViewAcct() const
{
     // set up ###.## format
    format initialState = setFormat();
    precis prec = cout.precision(2);
    cout << "Client: " << fullName << endl;
    cout << "Account Number: " << acctNum << endl;
    cout << "Balance: $" << balance << endl;
    restore(initialState, prec); // Restore original format
}

// BrassPlus Methods
BrassPlus::BrassPlus(const string & s, long an, double bal,
           double ml, double r) : Brass(s, an, bal)
{
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

BrassPlus::BrassPlus(const Brass & ba, double ml, double r)
           : Brass(ba)   // uses implicit copy constructor
{
    maxLoan = ml;
    owesBank = 0.0;
    rate = r;
}

// redefine how ViewAcct() works
void BrassPlus::ViewAcct() const
{
    // set up ###.## format
    format initialState = setFormat();
    precis prec = cout.precision(2);

    Brass::ViewAcct();   // display base portion
    cout << "Maximum loan: $" << maxLoan << endl;
    cout << "Owed to bank: $" << owesBank << endl;
    cout.precision(3);  // ###.### format
    cout << "Loan Rate: " << 100 * rate << "%\n";
    restore(initialState, prec); 
}

// redefine how Withdraw() works
void BrassPlus::Withdraw(double amt)
{
    // set up ###.## format
    format initialState = setFormat();
    precis prec = cout.precision(2);

    double bal = Balance();
    if (amt <= bal)
        Brass::Withdraw(amt);
    else if ( amt <= bal + maxLoan - owesBank)
    {
        double advance = amt - bal;
        owesBank += advance * (1.0 + rate);
        cout << "Bank advance: $" << advance << endl;
        cout << "Finance charge: $" << advance * rate << endl;
        Deposit(advance);
        Brass::Withdraw(amt);
    }
    else
        cout << "Credit limit exceeded. Transaction cancelled.\n";
    restore(initialState, prec); 
}

format setFormat()
{
    // set up ###.## format
    return cout.setf(std::ios_base::fixed, 
                std::ios_base::floatfield);
} 

void restore(format f, precis p)
{
    cout.setf(f, std::ios_base::floatfield);
    cout.precision(p);
}

virtual void Withdraw(double amt);
double Balance() const;
virtual void ViewAcct() const;
定义虚函数，使用虚函数后程序将根据引用或者指针指向的对象类型来选择方法。
原则上在派生类方法中是通解析运算符来调用基类方法。

虚函数的工作原理

编译器处理虚函数的方法是：给每个对象添加一个隐藏成员。隐藏成员保存了一个指向函数地址数组的指针。这些数组称为虚函数表。

总之使用虚函数时内存和执行速度有一定的成本：
（1）每个对象都将增大，增大量为存储地址的空间。
（2）对于每个类编译器都将创建一个虚函数的地址表。 、
（3）每个函数调用，都需要执行一项额外的操作，即到表中查找地址。
以上说明构造函数不是虚函数，而析构函数是虚函数。

继承和动态内存分配

基类使用了动态分配，并重新定义赋值和复制构造函数，将怎样影响派生类呢？

第一种情况：
派生类不使用new

派生类不需要 定义显式 析构函数、复制构造函数、赋值构造函数。

第二种情况：

派生类使用new
这种情况下，必须为派生类定义显示析构函数 ，复制构造函数、赋值运算符。
使用动态内存分配和友元继承的示例：

// dma.h  -- inheritance and dynamic memory allocation
#ifndef DMA_H_
#define DMA_H_
#include <iostream>

//  Base Class Using DMA*强调内容*
class baseDMA
{
private:
    char * label;
    int rating;

public:
    baseDMA(const char * l = "null", int r = 0);
    baseDMA(const baseDMA & rs);
    virtual ~baseDMA();
    baseDMA & operator=(const baseDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, 
                                     const baseDMA & rs);
};

// derived class without DMA
// no destructor needed
// uses implicit copy constructor
// uses implicit assignment operator
class lacksDMA :public baseDMA
{
private:
    enum { COL_LEN = 40};
    char color[COL_LEN];
public:
    lacksDMA(const char * c = "blank", const char * l = "null",
              int r = 0);
    lacksDMA(const char * c, const baseDMA & rs);
    friend std::ostream & operator<<(std::ostream & os, 
                                     const lacksDMA & rs);
};

// derived class with DMA
class hasDMA :public baseDMA
{
private:
    char * style;
public:
    hasDMA(const char * s = "none", const char * l = "null",
              int r = 0);
    hasDMA(const char * s, const baseDMA & rs);
    hasDMA(const hasDMA & hs);
    ~hasDMA();
    hasDMA & operator=(const hasDMA & rs);  
    friend std::ostream & operator<<(std::ostream & os, 
                                     const hasDMA & rs);
};

// dma.cpp --dma class methods

#include "dma.h"
#include <cstring>

// baseDMA methods
baseDMA::baseDMA(const char * l, int r)
{
    label = new char[std::strlen(l) + 1];
    std::strcpy(label, l);  
    rating = r;
}

baseDMA::baseDMA(const baseDMA & rs)
{
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
}

baseDMA::~baseDMA()
{
    delete [] label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs)
{
    if (this == &rs)
        return *this;
    delete [] label;
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
    return *this;
}

std::ostream & operator<<(std::ostream & os, const baseDMA & rs)
{
    os << "Label: " << rs.label << std::endl;
    os << "Rating: " << rs.rating << std::endl;
    return os;
}

// lacksDMA methods
lacksDMA::lacksDMA(const char * c, const char * l, int r)
    : baseDMA(l, r)
{
    std::strncpy(color, c, 39);
    color[39] = '\0';
}

lacksDMA::lacksDMA(const char * c, const baseDMA & rs)
    : baseDMA(rs)
{
    std::strncpy(color, c, COL_LEN - 1);
    color[COL_LEN - 1] = '\0';
}

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls)
{
    os << (const baseDMA &) ls;
    os << "Color: " << ls.color << std::endl;
    return os;
}

// hasDMA methods
hasDMA::hasDMA(const char * s, const char * l, int r)
         : baseDMA(l, r)
{
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const char * s, const baseDMA & rs)
         : baseDMA(rs)
{
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const hasDMA & hs)
         : baseDMA(hs)  // invoke base class copy constructor
{
    style = new char[std::strlen(hs.style) + 1];
    std::strcpy(style, hs.style);
}

hasDMA::~hasDMA()
{
    delete [] style;
}

hasDMA & hasDMA::operator=(const hasDMA & hs)
{
    if (this == &hs)
        return *this;
    baseDMA::operator=(hs);  // copy base portion
    delete [] style;         // prepare for new style
    style = new char[std::strlen(hs.style) + 1];
    std::strcpy(style, hs.style);
    return *this;
}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs)
{
    os << (const baseDMA &) hs;
    os << "Style: " << hs.style << std::endl;
    return os;
}

// dma.cpp --dma class methods

#include "dma.h"
#include <cstring>

// baseDMA methods
baseDMA::baseDMA(const char * l, int r)
{
    label = new char[std::strlen(l) + 1];
    std::strcpy(label, l);
    rating = r;
}

baseDMA::baseDMA(const baseDMA & rs)
{
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
}

baseDMA::~baseDMA()
{
    delete [] label;
}

baseDMA & baseDMA::operator=(const baseDMA & rs)
{
    if (this == &rs)
        return *this;
    delete [] label;
    label = new char[std::strlen(rs.label) + 1];
    std::strcpy(label, rs.label);
    rating = rs.rating;
    return *this;
}

std::ostream & operator<<(std::ostream & os, const baseDMA & rs)
{
    os << "Label: " << rs.label << std::endl;
    os << "Rating: " << rs.rating << std::endl;
    return os;
}

// lacksDMA methods
lacksDMA::lacksDMA(const char * c, const char * l, int r)
    : baseDMA(l, r)
{
    std::strncpy(color, c, 39);
    color[39] = '\0';
}

lacksDMA::lacksDMA(const char * c, const baseDMA & rs)
    : baseDMA(rs)
{
    std::strncpy(color, c, COL_LEN - 1);
    color[COL_LEN - 1] = '\0';
}

std::ostream & operator<<(std::ostream & os, const lacksDMA & ls)
{
    os << (const baseDMA &) ls;
    os << "Color: " << ls.color << std::endl;
    return os;
}

// hasDMA methods
hasDMA::hasDMA(const char * s, const char * l, int r)
         : baseDMA(l, r)
{
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const char * s, const baseDMA & rs)
         : baseDMA(rs)
{
    style = new char[std::strlen(s) + 1];
    std::strcpy(style, s);
}

hasDMA::hasDMA(const hasDMA & hs)
         : baseDMA(hs)  // invoke base class copy constructor
{
    style = new char[std::strlen(hs.style) + 1];
    std::strcpy(style, hs.style);
}

hasDMA::~hasDMA()
{
    delete [] style;
}

hasDMA & hasDMA::operator=(const hasDMA & hs)
{
    if (this == &hs)
        return *this;
    baseDMA::operator=(hs);  // copy base portion
    delete [] style;         // prepare for new style
    style = new char[std::strlen(hs.style) + 1];
    std::strcpy(style, hs.style);
    return *this;
}

std::ostream & operator<<(std::ostream & os, const hasDMA & hs)
{
    os << (const baseDMA &) hs;
    os << "Style: " << hs.style << std::endl;
    return os;
}
// usedma.cpp -- inheritance, friends, and DMA
// compile with dma.cpp
#include <iostream>
#include "dma.h"
int main()
{
    using std::cout;
    using std::endl;

    baseDMA shirt("Portabelly", 8);
    lacksDMA balloon("red", "Blimpo", 4);
    hasDMA map("Mercator", "Buffalo Keys", 5);
    cout << "Displaying baseDMA object:\n";
    cout << shirt << endl;
    cout << "Displaying lacksDMA object:\n";
    cout << balloon << endl;
    cout << "Displaying hasDMA object:\n";
    cout << map << endl;
    lacksDMA balloon2(balloon);
    cout << "Result of lacksDMA copy:\n";
    cout << balloon2 << endl;
    hasDMA map2;
    map2 = map;
    cout << "Result of hasDMA assignment:\n";
    cout << map2 << endl;
    // std::cin.get();
    return 0; 
}
C++类继承基础3——访问控制与继承
2301_80224556的博客
03-30 1582
我们看个例子我们看个例子。
Format函数详解
07-13 3983
Format是一个很常用，却又似乎很烦的方法，本人试图对这个方法的帮助进行一些翻译，让它有一个完整的概貌，以供大家查询之用：首先看它的声明：function Format(const Format: string; const Args: array of const): string; overload;事实上Format方法有两个种形式，另外一种是三个参数的，主要区别在于它是线程安全...
c++ 继承
weixin_54389166的博客
09-01 367
c++继承内容学习理解
C++_进阶_1_继承
成功的方式只有一个，按自己的方式，度过人生。欢迎共赴知识与乐趣的探索之旅！
06-18 398
C++_进阶—1_继承 文章目录C++_进阶—1_继承面向对象的三大特性： 面向对象的三大特性： 封装：封装本质是一种更好的管理 相对C语言面向过程，把数据和方法都放在类中进行管理，再通过访问限定符进行限制。 继承：从类设计角度讲， 在设计如下类的时候： 由于Teacher，Student有很多相似的属性 多态 ...
彻底弄懂C++虚拟继承
热门推荐
weixin_44212838的博客
07-27 1万+
为了解决普通继承的“数据冗余”和“二义性”的问题，C++引入了虚拟继承使得在多重继承下，基类成员只继承一份。 这篇博客主要解析1.虚拟继承机制，如何做到的？ 2.它和普通继承有什么区别？3.虚拟继承同时满足多态会怎样？ .........
C++类继承
Afanda
10-21 8837
C++类继承 文章目录C++类继承1.is-a继承1.1公有继承1.2私有继承1.3保护继承2.has-a关系3.多态公有继承3.1特性：3.2虚函数实现原理4.纯虚函数和抽象基类5.多继承、多重继承和虚拟继承6.模板类 1.is-a继承 1.1公有继承 特性： //保持基类的访问权限不变，基类数据成员只能通过基类的方法访问 //派生类需要自己的构造函数，创建对象时，需要使用成员初始化列表，将基...
C++类的继承
潜心钻研技术
02-07 2260
继承的概念和定义 概念 我们知道C++是一个面向对象的语言，继承是面向对象程序设计使代码可以复用的最重要的手段，使在逻辑上是继承关系的对象在用类来描述对象语言层面实现了代码复用，这样产生的新的类叫做派生类 例如用学生系统来举例 图中的学生管理系统建立了四个类用来描述 人、学生、老师、助教，但是我们发现学生、助教、老师这三个类都有人这个类的属性，在这个属性上才会多出来一些不同的特征，例如学生可能会有学号、班级…，于是学生从人继承部分属性就是类中的继承，人这个类叫做 父类 或者 基类 ，学生这个类别叫做 子类
C++类继承示例
01-20
C++的子类与孙子类都实现了虚函数时，孙子类的实现会覆盖掉子类的实现。 　继承的主要的应用是把不同的类放到一个数组中，然后遍历调用同名函数。 　实例如下： #include #include #include using ...
C++类继承之子类调用父类的构造函数的实例详解
08-29
C++类继承之子类调用父类的构造函数的实例详解 C++类继承是一种重要的面向对象编程技术，通过继承可以实现代码的重用和模块化。在C++类继承中，子类可以继承父类的成员变量和成员函数，但是在子类中调用父类的构造...
C++类继承 继承后函数的值实现详解
08-25
主要介绍了C++类继承 继承后函数的值实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
C++多态公有继承的一个例子
Felaim的博客
08-29 806
如果希望同一个方法在派生类和基类中的行为是不同的，换句话说，方法的行为应取决于调用该方法的对象，这种较复杂的行为称为多态——具有多种形态，即同一个方法的行为随上下文而异。 经常使用的两种重要的机制可用于实现多态公有继承；在派生类中重新定义基类的方法使用虚函数代码实现的功能比较简单，在实际应用中肯定还是要加很多功能的，这里仅仅是一个开户功能和取款的功能，主要还是为了熟悉C++的一些特性为主。bras
将两个顺序表的合并为顺序表
jjcoder的专栏
04-21 1950
#include using namespace std; const int x=100; const int y=100; const int z=200; void main(){     int a[x]; int b[y]; int c[z];     int i,j,k,m,n;     cout     cin>>m;     la:for(i=0;i     
C++实现顺序表
jjcoder的专栏
04-20 904
c++实现顺序表
操作系统字节顺序表示
jjcoder的专栏
06-28 822
假设变量x的类型是int,位于地址ox100处，它的十六进制数值为 ox01234567。地址范围为ox100~ox103的字节顺序依赖于机器的类型：大端法：ox100 ox101 ox 102 ox103- - - - - - - - - - - - – — - - -01 23
c++的代码重用
jjcoder的专栏
06-06 473
包含对象成员的类c++的主要目标是促进代码的重用。公有继承是实现目标之一，但并不是唯一的机制，其中之一便是本身使用另一个类的对象。这种方法称为包含，组合。假如要设计一个学生类，一个成员表示姓名，一个成员表示分数。对于姓名，可以使用字符数组来表示，但这将限制姓名长度，也可以使用char指针和动态内存分配，但这样会需要大量代码支持。一个较好的解决方法是使用一个已经开发好的类的对象来表示。对于考试分数，也
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值