Day-3

2021-12-06 20:30:12 阅读：107 来源： 互联网

1、类

1、定义
类包含了数据表示法和处理数据的方法，都被称为成员，函数在类中也被称为成员。
一般情况类的数据成员都定义为私有成员，而函数成员为共有成员。
类成员函数可以访问任何的数据成员。不管是私有的还是被保护的。
2、友元函数
（友元函数/类破坏了类的封装性，一般不太使用。）
友元函数不是类的成员函数，但是可以访问类中的成员，包括私有成员。需要在类中声明一下友元函数：

class A{
public:
friend int A(int a,int b) //A为友元函数，可以访问类中的任意成员。还可以定义在private下边。
}

友元类具有相同的用法。
注意：友元函数和友元类无法被继承。

2、继承

一个类继承另一个类，原来就存在的类叫做基类，后来继承的叫做派生类。

class Animal{
//sleep函数
//eat函数
};

class Dog: public Animal,public B{ //继承了两个基类：Animal,B,用逗号分开。
//bark函数
};

默认情况下是private继承。
一个派生类可以继承多个基类。派生类可以访问基类的非私有成员

3、重载函数和重载运算符

重载函数

在同一个定义域内多次定义同一个函数或运算符。
同一个函数或运算符名称一样，但是参数类型、参数个数、或者顺序不同。不能通过返回类型的不同来重载函数。
在编译时，编译器会将重载函数与调用的函数进行参数类型的对比，找到最合适的函数 ——重载决策。

重载运算符

对已经存在的运算符进行重新定义。
重载的运算符是特殊的函数：类型 operator+(参数) ，对+号进行重载。

重载、覆盖、重定义

重载：发生在函数、运算符之间，重载函数的名称相同，但是参数个数、类型或者顺序不能相同，不能返回类型不同而重载函数。
覆盖：发生在类中，子类对基类的成员函数进行重新定义，函数名称、参数、返回类型要相同。
重定义：子类对父类的非虚函数进行重定义，名称一样，参数可以不同。

4、多态

多态发生在类中，尤其在继承中。根据调用函数的对象的类型来执行不同的函数。
子类可以定义一个与基类相同的成员函数，实现方式不同，甚至参数都是可以相同的。

虚函数

虚函数是定义在基类中，在子类中要重新定义的函数：

class Shape{
	protected:
		int width,height;
	public:
		Shape( int a=0, int b=0)
      		{
         		width = a;
        		height = b;
      		}
    	virtual int area() //虚函数：在函数前面使用关键字 virtual 声明,告诉编译器不要静态链接到该函数
    		{
    	 	cout << "Parent class area :" <<endl;
         	return 0;
    		}
};

纯虚函数

需要在基类中给出虚函数，以便在子类中重新定义函数，但是在基类中又无法给出具体的函数实现，这时可以使用纯虚函数：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0; //纯虚函数，没有给出具体实现
};

PS（很重要）

形成多态的条件：
1、类间必须存在继承关系
2、继承关系必须有同名虚函数
3、存在基类类型的指针或引用，通过该指针或引用调用虚函数。

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;           //第三个条件：通过指针调用虚函数。
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

纯虚函数、虚函数的声明：

virtual void funtion1()=0; //纯虚函数的声明
virtual ReturnType FunctionName(Parameter);//虚函数的声明

友元函数不是成员函数，只有成员函数才能是虚函数，所以友元函数不能是虚拟的，但是可以通过友元函数调用虚函数来解决友元函数的虚拟问题。
析构函数应该是虚函数。
父类中的虚函数在子类中依然是虚函数。如果避免某个成员函数被重写，可以使用final关键字：

#include<iostream>
using namespace std;
class Base // final :如果不希望类被继承，也可以使用final关键字
{
    public:
        virtual void func()
        {
            cout<<"This is Base"<<endl;
        }
};
class _Base:public Base
{
    public:
        void func() final//正确，func在Base中是虚函数 ，但是再有子类就无法再重写。
        {
            cout<<"This is _Base"<<endl;
        }
};

5、抽象类（接口）

一个类中包含纯虚函数，则该类为抽象类。抽象类不能被实例化，只有在纯虚函数被具体实现后才能进行实例化。（跟多态有点像）

标签：函数,int,成员,Day,基类,重载,public
来源： https://blog.csdn.net/weixin_42200096/article/details/121479904

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9