c++ 继承

最新推荐文章于 2020-09-26 07:59:15 发布
最新推荐文章于 2020-09-26 07:59:15 发布
阅读量1.5k 收藏
点赞数
分类专栏： c++编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianguo_liao19840726/article/details/8549041
版权 


#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Item_base {

public:
    Item_base(const std::string &book = "", 
              double sales_price = 0.0):
                     isbn(book), price(sales_price) { }

    std::string book() const { return isbn; }

    //为了指明函数为虚函数，在其返回类型前面加上保留字virtual，除了构造函数之外，任意非static成员函数都可以是虚函数，保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上。
    virtual double net_price(std::size_t n) const 
               { return n * price; }

    virtual ~Item_base() { } 
private:
    std::string isbn;   
protected:
    double price;       

};

class Bulk_item : public Item_base {

public:
       double net_price(std::size_t) const;
       void memfcn(const Bulk_item &d, const Item_base &b);
private: 
	std::size_t min_qty;
        double discount;

};

//下面如果为 “virtual double Bulk_item::net_price(size_t cnt) const “，会报："virtual outside class declaration" 错误，验证了：保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上
 double Bulk_item::net_price(size_t cnt) const
{
	if(cnt >= min_qty)
              return cnt * (1 - discount) * price;
        else
              return cnt * price;
}

void Bulk_item::memfcn(const Bulk_item &d, const Item_base &b)
{
	double ret = price;
        ret = d.price;
        //ret = b.price;  报错：‘double Item_base::price’ is protected‘ ，说明派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限
}





 


#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Item_base {

public:
    Item_base(const std::string &book = "", 
              double sales_price = 0.0):
                     isbn(book), price(sales_price) { }

    std::string book() const { return isbn; }

    //为了指明函数为虚函数，在其返回类型前面加上保留字virtual，除了构造函数之外，任意非static成员函数都可以是虚函数，保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上。
    virtual double net_price(std::size_t n) const 
    { 
     cout << "------Item_base::net_price call------" << endl;
     return n * price; 
    }

    virtual ~Item_base() { } 
private:
    std::string isbn;   
protected:
    double price;       

};

class Bulk_item : public Item_base {

public:
       double net_price(std::size_t) const;
       void memfcn(const Bulk_item &d, const Item_base &b);
private: 
	std::size_t min_qty;
        double discount;

};

//下面如果为 “virtual double Bulk_item::net_price(size_t cnt) const “，会报："virtual outside class declaration" 错误，验证了：保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上
 double Bulk_item::net_price(size_t cnt) const
{
	cout << "------Bulk_item::net_price call------" << endl;
	if(cnt >= min_qty)
              return cnt * (1 - discount) * price;
        else
              return cnt * price;
}

void Bulk_item::memfcn(const Bulk_item &d, const Item_base &b)
{
	double ret = price;
        ret = d.price;
        //ret = b.price;  报错：‘double Item_base::price’ is protected‘ ，说明派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限
}

void print_total(ostream &os, 
                 const Item_base &item, size_t n)
{
    os << "ISBN: " << item.book() 
       << "\tnumber sold: " << n << "\ttotal price: "
       << item.net_price(n) << endl;
}

int main()
{
//测试代码，可以在运行时确定virtual函数调用
 Item_base base;
 Bulk_item derived;
 print_total(cout,base,10);
 cout << "-------------------------" << endl;
 print_total(cout,derived,10);
 
 return 0;
}

输出： 

pateo@pateo-B86N53X:~/work/study$ g++ main.cc -o main
pateo@pateo-B86N53X:~/work/study$ ./main
------Item_base::net_price call------
ISBN: 	number sold: 10	total price: 0
-------------------------
------Bulk_item::net_price call------
ISBN: 	number sold: 10	total price: 0
pateo@pateo-B86N53X:~/work/study$ 


#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Item_base {

public:
    Item_base(const std::string &book = " ", 
              double sales_price = 0.0):
                     isbn(book), price(sales_price) { }

    std::string book() const { 
       
       return "Item_base::book"; 
     }

    //为了指明函数为虚函数，在其返回类型前面加上保留字virtual，除了构造函数之外，任意非static成员函数都可以是虚函数，保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上。
    virtual double net_price(std::size_t n) const 
    { 
     cout << "------Item_base::net_price call------" << endl;
     return n * price; 
    }

    virtual ~Item_base() { } 
private:
    std::string isbn;   
protected:
    double price;       

};

class Bulk_item : public Item_base {

public:
       double net_price(std::size_t) const;
       void memfcn(const Bulk_item &d, const Item_base &b);
       std::string book() const { 
           return "Bulk_item::book"; 
     }
private: 
	std::size_t min_qty;
        double discount;

};

//下面如果为 “virtual double Bulk_item::net_price(size_t cnt) const “，会报："virtual outside class declaration" 错误，验证了：保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上
 double Bulk_item::net_price(size_t cnt) const
{
	cout << "------Bulk_item::net_price call------" << endl;
	if(cnt >= min_qty)
              return cnt * (1 - discount) * price;
        else
              return cnt * price;
}

void Bulk_item::memfcn(const Bulk_item &d, const Item_base &b)
{
	double ret = price;
        ret = d.price;
        //ret = b.price;  报错：‘double Item_base::price’ is protected‘ ，说明派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限
}

void print_total(ostream &os, 
                 const Item_base &item, size_t n)
{
    os << "ISBN: " << item.book() 
       << "\tnumber sold: " << n << "\ttotal price: "
       << item.net_price(n) << endl;
}

int main()
{
//测试代码，在编译时确定非virtual函数调用
 Item_base base;
 Bulk_item derived;
 print_total(cout,base,10);
 cout << "-------------------------" << endl;
 print_total(cout,derived,10);
 
 return 0;
}

输出： 

pateo@pateo-B86N53X:~/work/study$ g++ main.cc -o main
pateo@pateo-B86N53X:~/work/study$ ./main
------Item_base::net_price call------
ISBN: Item_base::book	number sold: 10	total price: 0
-------------------------
------Bulk_item::net_price call------
ISBN: Item_base::book	number sold: 10	total price: 0
pateo@pateo-B86N53X:~/work/study$ 
pateo@pateo-B86N53X:~/work/study$ 


#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Item_base {

public:
    Item_base(const std::string &book = " ", 
              double sales_price = 0.0):
                     isbn(book), price(sales_price) { }

    std::string book() const { 
       
       return "Item_base::book"; 
     }

    //为了指明函数为虚函数，在其返回类型前面加上保留字virtual，除了构造函数之外，任意非static成员函数都可以是虚函数，保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上。
    virtual double net_price(std::size_t n) const 
    { 
     cout << "------Item_base::net_price call------" << endl;
     return n * price; 
    }

    virtual ~Item_base() { } 
private:
    std::string isbn;   
protected:
    double price;       

};

class Bulk_item : public Item_base {

public:
       double net_price(std::size_t) const;
       void memfcn(const Bulk_item &d, const Item_base &b);
       std::string book() const { 
           return "Bulk_item::book"; 
     }
private: 
	std::size_t min_qty;
        double discount;

};

//下面如果为 “virtual double Bulk_item::net_price(size_t cnt) const “，会报："virtual outside class declaration" 错误，验证了：保留字virtual只在类内部的成员函数声明中出现，不能用在类定义体外部出现的函数定义上
 double Bulk_item::net_price(size_t cnt) const
{
	cout << "------Bulk_item::net_price call------" << endl;
	if(cnt >= min_qty)
              return cnt * (1 - discount) * price;
        else
              return cnt * price;
}

void Bulk_item::memfcn(const Bulk_item &d, const Item_base &b)
{
	double ret = price;
        ret = d.price;
        //ret = b.price;  报错：‘double Item_base::price’ is protected‘ ，说明派生类只能通过派生类对象访问其基类的protected成员，派生类对其基类类型对象的protected成员没有特殊访问权限
}

void print_total(ostream &os, 
                 const Item_base &item, size_t n)
{
    os << "ISBN: " << item.book() 
       << "\tnumber sold: " << n << "\ttotal price: "
       << item.net_price(n) << endl;
}

int main()
{
//测试代码，覆盖虚函数机制
 
 Bulk_item derived;
 Item_base *baseP = &derived;
 double d = baseP->Item_base::net_price(42);
 
 return 0;
}

输出： 

pateo@pateo-B86N53X:~/work/study$ g++ main.cc -o main
pateo@pateo-B86N53X:~/work/study$ ./main
------Item_base::net_price call------
pateo@pateo-B86N53X:~/work/study$


如下公共、私有和保护的继承 
#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Base{
public :
        void basemem();
protected :
        int i;        
};

struct Public_derived : public Base
{
	int use_base(){return i;}

};

struct Private_derived : private Base
{
	int use_base(){return i;}

};

int main()
{
  Base b;
  Public_derived d1;
  Private_derived d2;
  b.basemem();//ok
  d1.basemem();//ok
  d2.basemem();//error 
 return 0;
}

输出： 

pateo@pateo-B86N53X:~/work/study$ g++ main.cc -o main
main.cc: In function ‘int main()’:
main.cc:8: error: ‘void Base::basemem()’ is inaccessible
main.cc:32: error: within this context
main.cc:32: error: ‘Base’ is not an accessible base of ‘Private_derived’
pateo@pateo-B86N53X:~/work/study$ 


#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Base{
public :
        void basemem();
protected :
        int i;        
};

struct Public_derived : public Base
{
	int use_base(){return i;}

};

struct Private_derived : private Base
{
	int use_base(){return i;}

};

struct Derived_from_Public : public Public_derived
{
	int use_base(){return i;}
};

int main()
{
  Derived_from_Public d3;
  d3.basemem();//ok
 return 0;
}

说明： 

派生方式	基类的public成员	基类的protected成员	基类的private成员	派生方式引起的访问属性变化概括
private派生	变为private成员	        变为private成员	        不可见	          基类中的非私有成员都成为派生类中的私有成员
protected派生	变为protected成员	变为private成员	        不可见	          基类中的非私有成员在派生类中的访问属性都降一级
public派生	仍为public成员	        仍为protected成员	不可见	          基类中的非私有成员在派生类中的访问属性保持不变

如果进行private或protected继承，则基类成员的访问级别在派生类中比在基类中更受限 



#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Base{
public :
        int basemem(){return i;}
protected :
        int i;        
};



class Private_derived : private Base
{
        public:
               using Base::basemem;//使用using声明访问基类中成员
        protected :
               using Base::i;//使用using声明访问基类中成员
};



int main()
{
  Private_derived d1;
  d1.basemem();//ok
  return 0;
}

比较下面 

#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Base{
public :
        int basemem(){return i;}
protected :
        int i;        
};



class Private_derived : private Base
{
};



int main()
{
  Private_derived d1;
  d1.basemem();//error
  return 0;
}

使用class关键字来定义类，那么定义在第一个访问标号前的任何成员都隐式制定为private；如果使用struct关键字，那么这些成员都是public。使用class还是struct关键字来定义类，仅仅影响默认的初始化访问级别。同样，使用class保留字定义的派生类默认具有private继承，而用struct保留字定义的类默认具有public继承，如下 

#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Base{
public :
        int basemem(){return i;}
protected :
        int i;        
};



class Private_derived :  Base
{
};



int main()
{
  Private_derived d1;
  d1.basemem();//error
  return 0;
}

对比下面 

#include <iostream>
#include <string>
using namespace std;
using std::string;  

class Base{
public :
        int basemem(){return i;}
protected :
        int i;        
};



struct Private_derived :  Base
{
};



int main()
{
  Private_derived d1;
  d1.basemem();//ok
  return 0;
}






沈纵情
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++中 overload、redefine 和 override的含义和区别
BigJGarden
11-04 1758
C++中 overload 和 override的含义和区别Overloading FunctionsCONCEPT如何定义参数列表不同合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章...
C++中“Virtual outside class declaration ”解决办法
yukaiqweR的博客
09-26 6796
C++中“Virtual outside class declaration ”
C++虚函数使用注意点（持续更新...）
懒人_人懒
03-26 1008
1.  基类为虚函数时，子类默认为虚函数，virtual可写可不写，不过写了更清晰，造福后来人；2. 虚函数只有在声明的时候才写vitual，类外定义虚函数的时候不写virtual，不然会报错 ‘virtual’ outside class declaration；3. 如果基类指针指向子类对象，而该子类对象是在堆上开辟的内存，此时基类析构函数声明为virtual，防止内存泄漏；4. 子类和基类中...
ClassDeclaration.java类的状态
raphaelxia的专栏
03-28 1446
ClassDeclaration.javaJava中类的8种状态1. CLASS_UNDEFINED=0     //类定义尚未装载2. CLASS_UNDECIDED=1    //二进制定义被装载,但是源文件的定义是否被装载尚未知道3. CLASS_BINARY=2             // 二进制文件已经被装载4. CLASS_SOURCE=3          //
C++继承介绍
09-05
总结来说，C++继承是实现代码复用和创建类层次结构的重要手段。通过选择适当的继承类型、访问修饰符和虚函数，开发者可以构建灵活且强大的类体系，同时确保类型安全和多态性。理解和熟练运用这些概念对于编写高效、...
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
c++继承的视频
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许一个类（子类或派生类）从另一个类（基类或父类）继承特性，从而实现代码的重用和扩展。在Qt框架中，C++的继承机制同样被广泛应用，以构建丰富的用户界面和...
c++继承描述
01-05
c++继承描述
关于c++ class中virtual 函数的几种替代方案
姜的理想国
10-17 1490
1 NVI （Non-Virtual Interface） 看下面的类继承关系： class GameCharactor { public: virtual void CalculateScore(const GameCharactor& charactor); }; class ACharactor : public GameCharactor { public: virtu
C++封装、继承、多态
热门推荐
ruyue_ruyue的专栏
11-22 10万+
C++封装继承多态总结 面向对象的三个基本特征 面向对象的三个基本特征是：封装、继承、多态。其中，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！ 封装
CppPrimer自学（3）公有继承
桥粑粑的博客
12-20 248
**①如果在main函数里，main既不是父类的友元函数也不是成员函数，所以不能用父类里的私有成员和受保护的成员。 ②在main函数里，即使是子类，也不能用父类受保护的成员。 ③受保护的成员可以继承类用，但是父类是不能在类外的地方用，即使没在main函数里。***公有继承表示在继承类外（如main函数里），除了公有成员可以用，其他是不能的。受保护的在继承类里用是可以的 也是受保护的对象。 私有
浅谈C++继承方式
complety的专栏
04-24 5万+
简单地说下C++类的3种继承方式，分别是public继承，protected继承，private继承。 最常用的还是public继承。class默认的是private继承，它的member如果没写权限也是默认 private。struct则相反，默认的是public继承。结合下面的图示和代码，对C++的继承就有了 比较清晰的认识了。 继承之后，derived class 继承过后的me
10 个免费的 C/C++ 集成开发环境
weixin_34191845的博客
05-23 745
http://cnbeta.com/articles/188721.htm   集成开发环境（IDE）可以给程序员提供很大的帮助。大多数的IDE包含编译器和解释器。例如微软的 Visual Studio 本身内置的编译器和解释就是很好的例子，Eclipse 是另一个很好的例子。鼓励程序员使用IDE的主要原因是开发软件应用程序的各个组成部分之间可方便的进行切换。 一般一个特定的IDE是负责处理...
适合C/C++的集成开发环境
学无止境
09-26 1万+
“工欲善其事，必先利其器”，选择合适的集成开发环境（IDE）往往能做到事半功倍的作用，下面给您介绍一下适合C/C++语言的集成开发环境。 适合C/C++常用IDE工具 序号 名称 适合操作系统 1 Codeblocks Windows、Linux、MacOS 2 Dev-C++ Windows 3
C++ 继承与组合的区别
Dablelv 的博客专栏。
02-13 6161
C++ 程序开发中，设计孤立的类比较容易，设计相互关联的类却比较难，这其中会涉及两个概念，一个是继承（Inheritance），一个是组合（Composition）。因为二者有一定的相似性，往往令程序员混淆不清。类的组合和继承一样，是软件重用的重要方式。组合和继承都是有效地利用已有类的资源。但二者的概念和用法不同。
C++总结5——继承与多态
wendy_keeping的博客
07-16 3445
1.C++的继承 继承有3种形式：私有继承、保护继承、公有继承，缺省的继承方式是私有继承。 不论哪种继承方式，派生类都是显示的继承类基的保护成员变量和函数和公有成员变量和函数，继承方式只是限定在派生类中这两种成员变量的访问方式（即访问权限）。私有的成员变量和函数也被继承到派生类中，但是不能被访问，它是隐藏的，在派生类中不可见。 派生类继承基类，除基类的构造函数和析构函数不外，其他的所有都继承

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值