关于c++的多态和c#多态

最新推荐文章于 2023-02-11 12:42:54 发布
最新推荐文章于 2023-02-11 12:42:54 发布
阅读量371 收藏
点赞数 1
文章标签： 多态
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37627370/article/details/86737565
版权

参考：
1，C++ Primer Plus（第六版）中文版
2，http://c.biancheng.net （C语言中文网）
3，https://blog.csdn.net/czg13548930186/article/details/76076642
4，https://blog.csdn.net/chengonghao/article/details/51062291
5，https://blog.twofei.com/496/

C++中多态：
若继承关系为Public时，基类的成员函数，在整个继承链中，可属于每个派生类；只不过成员函数中的this参数，指向不同的基类对象或者派生类对象。

记一局题外话：在需要形成继承关系时，需要分析是否满足is-a关系，如果只是has-a关系的话，利用组合方式：比如将需要的数据以成员变量形成呈现

类其实也是一种数据类型，也可以发生数据类型转换，不过这种转换只有在基类和派生类之间才有意义，并且只能将派生类赋值给基类，包括将派生类对象赋值给基类对象、将派生类指针赋值给基类指针、将派生类引用赋值给基类引用，这在 C++ 中称为向上转型（Upcasting）。相应地，将基类赋值给派生类称为向下转型（Downcasting）。

c++向上转换是安全的，隐式的；向下则需要不安全的，是强式的。
当我们想把派生类转换成基类，我们只需要丢掉一些基类没有数据，即可。
但是，我们想把基类转换成派生类形成一个完整的数据，派生类对象内存中很多信息都无从填充，转换不了一个完成的派生类对象。但是，向下转换在语法上是可行的操作，需要程序员进行干预执行。

1,将派生类对象赋值给基类对象

#include <iostream>
using namespace std;


class A{
public:
    void display()
	{
		cout<<"this is A :"<<m_a<<endl;
	}
public:
    int m_a;
};


class B: public A
{
public:
    void display()//覆盖基类的同名成员函数,则不会用到基类的成员函数
	{
		cout<<"this is B :"<<m_a<<endl;
	}
};
int main(){
	A a;
	a.m_a = 1;
	a.display();

	B b;
	b.m_a = 2;
	b.display();
	
	//向上转换
	a = b;//此处，对象b的内存中的数据copy给对象a的内存里
	a.display();
	//此处调用a对象类型的所属函数，并将a对象地址赋值给this指针
    return 0;
}

在这里插入图片描述

2,将派生类指针赋值给基类指针

#include <iostream>
using namespace std;

class A{
public:
    void display()
	{
		cout<<"this is A :"<<m_a<<endl;
	}
public:
    int m_a;
};


class B: public A
{
public:
    void display()//覆盖基类的同名成员函数,则不会用到基类的成员函数
	{
		cout<<"this is B :"<<m_a<<endl;
	}
};


int main(){
	A* a = new A();//动态分配堆上的内存
	a->m_a = 1;

	B* b = new B();
	b->m_a = 2;
	//
	a = b;
	cout<<a->m_a<<endl;
	a->display();
	//此处调用指针a类型的所属函数，并将指针a赋值给this指针。
	return;
}

在这里插入图片描述

题外话：下面演示一下比较有意思的内存偏移现象

#include <iostream>
using namespace std;

class A{
public:
	int m_a;
    void display()
	{
		cout<<"this is A :"<<m_a<<endl;
	}

};

class C{
public:
    int m_c;
	void display()
	{
		cout<<"this is C :"<<m_c<<endl;
	}
};


class B: public A, public C 
{
public:
    void display()
	{
		cout<<"this is B :"<<m_a<<endl;
	}
};


int main(){

	C* c = new C();
	B* b = new B();
	cout<<c<<endl;
	cout<<b<<endl;
	
	c = b;
	cout<<c<<endl;
	cout<<b<<endl;
	return 0;
}

在这里插入图片描述
当我们把指针变量b的值（即b对象的地址）赋值给了指针变量c后，两个值应该是一样的。但是结果却不是一样。

在这里插入图片描述
在派生类指针赋值给基类指针时，c++编译器会自动计算地址偏移（这个程序的偏移量则是因为b先继承了A的m_a的4个字节），并减去！使其符合基类c的内存布局。

（引用的赋值先跳过）

3，主要看看虚成员函数以及虚函数(表)实现机制

3.1 虚函数 演示

#include <iostream>
using namespace std;

class A{
public:
	int m_a;
    virtual void display()
	{
		cout<<"this is A"<<endl;
	}

};

class B: public A
{
public:
    void display()
	{
		cout<<"this is B"<<endl;
	}
};

class C{
public:
	int m_c;
    void display()
	{
		cout<<"this is c"<<endl;
	}

};


int main(){
	A a_test;
	B b_test;
	a_test = b_test;
	a_test.display();//这里还是A类所属的函数

	A* a = new A();
	a->display();
	a = new B();
	a->display();

	cout<<sizeof(A)<<endl;
	cout<<sizeof(B)<<endl;
	cout<<sizeof(C)<<endl;

	return 0;
}

在这里插入图片描述
这里可以看出构成多态的条件：
1，必须存在继承关系；
2，继承关系中必须有同名的虚函数，并且它们是遮蔽（覆盖）关系。
3，存在基类的指针，通过该指针调用虚函数。

3.2 虚函数表 演示
首先，函数不存在对象内存中，然后发现含有虚函数的对象中的内存数据中除了成员变量的4个字节，含有其他的四个字节，这就是虚函数表地址（int型）

#include <iostream>
using namespace std;

class A{
public:
	int m_a;
    virtual void display()
	{
		cout<<"this is A"<<endl;
	}
	
};

class B: public A
{
	virtual void display()
	{
		cout<<"this is B"<<endl;
	}
};

class C: public A
{
};

int main(){
	A a;
	a.m_a = 1;
	B b;
	b.m_a = 2;
	C c;
	c.m_a = 3;
	return 0;
}

在这里插入图片描述
虚函数表则是一个数组，元素则是虚函数地址，而在对象中只存放着_vfptr这个变量，其值是第一个数组元素的地址。则可通过这个地址值索引到各个虚函数。可以认为_vfptr是数组名（首元素的地址）

对象b中_vfptr数组中的虚函数地址则是新的地址，而对象c中_vfptr数组中则是基类虚函数的地址

关于更多的虚函数的详情，大家可以直接慢慢的看完这篇博客：https://blog.twofei.com/496/。
这篇博客详细的分析了虚函数表的内存布局，以及虚函数的使用方法及总结要领。如果想了解虚函数表的内存布局可以慢慢研读。这边博客的作者还很热心的帮助博主解疑答惑。

在这里这做下虚函数的总结：（不分析其运行机制，总结要领），想研究其内部机制的同学则可花时间慢慢研究:
1，若调用的函数为虚函数，则在指针指向的对象实例中的虚函数表中查询对应的虚函数进行调用
2，若调用的函数不为虚函数，则调用指针类型的所属函数进行调用。

4,c++中抽象类实现多态

抽象类一般作为基类，在派生过程中去实现成员函数(纯虚函数)，抽象类是无法进行对象实例化的。派生类实现了纯虚函数才可以实例化

#include <iostream>
using namespace std;

class	Person{
public:
	int _age;
	Person(int age)
	{
		_age = age;
	}
    virtual void displayName() = 0;//纯虚函数
    virtual void displayAge() = 0;
	
};

class Jay:public Person{//继承于Person但未完全实现其方法函数，于是不能实例化
public:
	Jay(int age):Person(age)
	{

	}
    void displayAge()
	{
		cout<<_age<<endl;
	}
};	


class Tim:public Person{
public:
	Tim(int age):Person(age)
	{
	
	}
    void displayAge()
	{
		cout<<_age<<endl;
	}

	void displayName()
	{
		cout<<"Tim"<<endl;
	}
};

class Hebe:public Person{
public:
	Hebe(int age):Person(age)
	{
	
	}
    void displayAge()
	{
		cout<<_age<<endl;
	}

	void displayName()
	{
		cout<<"Hebe"<<endl;
	}
};


int main()
{
	Person* p = new Tim(18);
	p->displayAge();
	p->displayName();
	p = new Hebe(19);
	p->displayAge();
	p->displayName();
	return 0;
}

在这里插入图片描述

**

以上关于c++多态相关demo和演示，下面总结下C#相关多态的实现。

**
1，override&hide

1.1 demo1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace multi
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Base basetest= new Base();
            basetest.show();
            basetest = new Deriveover();
            basetest.show();
            basetest = new Derivehide();
            basetest.show();
          
        }
    }
     class Base
    {
         public virtual void show()
         {
             Console.WriteLine("this is base");
         }
    }

     class Deriveover : Base
     {
         public override void show()
         {
             Console.WriteLine("this is Deriveover");
         }
     }

     class Derivehide : Base
     {
         public  void show()
         {
             Console.WriteLine("this is Derivehide");
         }
     }
}

在这里插入图片描述
当基类和派生类形成重写状态，则实现多态效果；
当派生类隐藏覆盖原先的函数（注意不是重载！）时，函数的调用则选择基类函数所属方法 basetest = new Derivehide();basetest.show();

1.2 demo2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace multi
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Base basetest= new Base();
            basetest.show();
            basetest = new Deriveover();
            basetest.show();
            basetest = new Derivehide();
            basetest.show();
          
        }
    }

     class Base
    {
         public virtual void show()
         {
             Console.WriteLine("this is base");
         }
    }

     class Deriveover : Base
     {
         public override void show()
         {
             Console.WriteLine("this is Deriveover");
         }
     }

     class Derivehide : Deriveover
     {
         public void show()
         {
             Console.WriteLine("this is Derivehide");
         }
     }
}

在这里插入图片描述
demo2这种情况比较有意思，这种情况在c++时不会出现的。c++在基类存在虚函数时，派生类时不会出现隐藏效果的。

2，c#抽象基类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace multi
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Base basetest = new Derive1();
            basetest.display();
            basetest = new Derive2();
            basetest.display();
        }
    }
    
    abstract class Base
    {
        public abstract void display();
    }

    class Derive1 : Base
    {
        public override void display()
        {
            Console.WriteLine("this is Derive1");
        }
    }
    
    class Derive2 : Base
    {
        public override void display()
        {
            Console.WriteLine("this is Derive2");
        }
    }
}

在这里插入图片描述
2，c#接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Worker w1 = new jay();
            w1.showname();
            w1.showange();
            w1 = new tim();
            w1.showname();
            w1.showange();

        }
    }

    interface Worker
    {
        void showname();
        void showange();
    }


    internal class jay:Worker
    {
        public void showname()
        {
            Console.WriteLine("jay");
        }

        public void showange()
        {
            Console.WriteLine("22");
        }
    }


    internal class tim : Worker
    {
        public void showname()
        {
            Console.WriteLine("tim");
        }

        public void showange()
        {
            Console.WriteLine("21");
        }
    }
}

在这里插入图片描述

Java.net
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#调用C++类（托管C++实现）
u014577128的博客
08-12 8294
往往一个项目，算法是用C++写的，而界面需要用C#的Winform去编写，这个时候C#界面需要去调用C++类里面的函数，因为C#和C++是两种不同的语言，两者之间不能直接调用，所以他们之间需要一个桥梁，而托管C++可以充当这个桥梁 具体实现过程如下：看看第三方库文件是如何创建出来的 1.2修改项目属性 在对第一步的C++类进行暴露的时候，只需要将共有的类成员暴露就行 2.3引入第一步建立的库文件 2.3.1第一步的.h文件 （例如：E:\vs2022
C++多态
qq_63580639的博客
04-05 272
C++多态的详细使用方法和一些注意事项与常见问题
C++多态存在的问题
qq_36685978的博客
12-26 222
C++多态存在的问题
C++多态的理解
weixin_44244332的博客
03-15 5784
1.多态的概念及分类 多态是面向对象程序设计的一个重要特征。多态的字面意思就是多种状态，在面向对象的程序设计中，一个接口，多种实现即为多态。c++的多态性具体体现在编译和运行两个阶段。编译时多态是静态多态，在编译时就可以确定使用的接口。运行时多态是动态多态，具体引用的接口在运行时才能确定。 静态多态和动态多态区别其实只是在什么时候将函数实现和函数调用关联起来，是在编译时期还是运行时期，即函数地址是早绑定还是晚绑定。静态多态是指在编译期间就可以确定函数的调用地址，并产生代码，这是静态的，也就是说地址是早绑
C++中的多态
热门推荐
weixin_57023347的博客
08-29 1万+
前言 我认为多态是因为有了虚函数，通过继承，派生类可以重写虚函数，才有了C++的多态。所以要了解多态的原理，需要重点了解虚函数和虚基表。 一.多态的概念
C#继承多态 某公司雇员(Employee)包括经理(Manager)，技术人员(Technician)和销售员(Salesman)
04-20
某公司雇员(Employee)包括经理(Manager)，技术人员(Technician)和销售员(Salesman)。开发部经理(DeveloperManger)，既是经理也是技术人员。...特别注意pay()的定义和调用方法：先用同名覆盖，再用运行时多态。
C#类的多态性详解
01-20
C#语言的方法重载与C++、java基本是一样的，但是C#还包含C++的运算符重载，java里面没有这个概念。 第二种：运行时的多态性，是在系统运行时，调用一个名字相同，参数类型也相同以及个数也完全一样的方法，但会完成...
Java,C#,C++在继承，覆盖和多态,抽象类等几个方面的比较归纳
12-24
Java,C#,C++在继承，覆盖和多态,抽象类等几个方面的比较归纳..........................
易语言动态多态编程简单例子-易语言
06-12
，不懂就百度，另外别拿C#和java的对比c++的重写 1.重写必须继承，重载不用。2.重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。3.重写的方法修饰符大于等于父类的方法，重载和修饰符...
棋牌的胡牌算法。实现 lua 、c++ 、c# 、golang 、js 、java 、python 版本.zip
最新发布
01-13
面向对象： Java是一种纯粹的面向对象编程语言，支持封装、继承和多态等面向对象的概念。这使得Java编写的代码更加模块化、可维护和可扩展。 多线程支持： Java内置了对多线程的支持，允许程序同时执行多个任务。这...
c语言实现多态
11-21
c语言实现多态
C 多态总结
the_sea1的博客
10-23 1598
1、多态的实现三个条件： (1)要有继承 (2)要有虚函数重写(即动态绑定) (3)至少有一个基类类型的指针或基类类型的引用。这个指针和引用可以对virtual成员函数进行调用 C++的多态性分为两种：编译时的多态、运行时的多态； 使用重载来实现编译时的多态，使用虚函数来实现运行时的多态。 2、基类中的虚函数必须要实现吗？ （1）在main函数中，如果有基类或者派生类的实例对象，...
C++ 多态 超详细讲解
drnrrwfs的博客
06-02 1932
多态字面意思就是多种形态。 我们先来想一想在日常生活中的多态例子：买票时，成人买票全价，如果是学生那么半价，如果是军人，就可以优先买票。不同的人买票会有不同的实现方法，这就是多态。C++的多态必须满足两个条件： 1 必须通过基类的指针或者引用调用虚函数 2 被调用的函数是虚函数，且必须完成对基类虚函数的重写 我们来看看具体实现。 调用的两个BuyTicket() 答案是什么呢？ 如果不满足多态呢？ 这说明了很重要的一点，如果满足多态，编译器会调用指针指向对象的虚函数，而与指针的类型无关。如果不满足多态，
C语言：多态
一鸣惊人的博客
04-23 3609
多态指同一个接口的多种实现方式，是面向对象的核心。一般实现多态需满足：必须要有继承，必须要有重写 ，必须要父类引用/指针指向子类对象，三个必要条件。本文将从多态的三个必要条件入手，借鉴Javascript原型链设计并实现了一种C语言的多态实现范式。
C++之多态【详细总结】
includeevey的博客
02-11 5024
多态：同一个行为产生出不同的状态！
C/C++中的多态理解
Lynnllh的博客
08-30 1万+
定义 多态的定义简单来说就是使一条语句有多种状态。 实现方式 多态的实现方式分为三块：重载、重写、重定义。下面我们来谈一谈他们各自的实现方式和实现原理。 重载 实现方式 重载是在同一作用域内（不管是模块内还是类内，只要是在同一作用域内），具有相同函数名，不同的形参个数或者形参类型。返回值可以相同也可以不同（在函数名、形参个数、形参类型都相同而返回值类型不同的情况下无法构成重...
c++与c#多态
qq_28014453的博客
11-03 133
一. 通常我们使用多态特性的时候，基础的使用场景如下： 1.先定义(接口或者抽象）类 human 定义实现(抽象/接口)的类woman man. 2.再依靠human实现多态 3.执行效果如下 ////////////////////////////////////////////////--------------黄金分割线------------------------------/////////////////////////////////////// 二. 多态不止是同一段代码时巧妙
C语言--面向对象编程之多态
weixin_46185705的博客
03-27 3182
系列文章目录 C语言–面向对象编程之封装 C语言–面向对象编程之继承 文章目录系列文章目录前言一、多态是什么？二、使用步骤1.引入库2.读入数据总结 – 前言 C语言实现面向对象编程的第三篇，在前面两篇里面我们已经讨论了C语言实现面向对象的封装与继承，这篇我们了解，面向对象的最后一个特性，多态，顺便了解一下C++中的虚指针与虚表。 一、多态是什么？ 多态指的是能够根据对象的不同类型调用同一个接口，实现不同的功能。在C++中有一个叫做重载的功能，作用类似，比如下面的函数。 看例子： /*函数重载*/ in
c语言与c++与c#区别
05-24
C、C++和C#都是编程语言，但它们有许多不同之处。 1. C语言是一种过程式编程语言，它以顺序执行的方式运行代码。它通常用于系统编程、设备驱动程序和嵌入式系统等领域。C++是一种基于对象的编程语言，它在C语言的基础上添加了更多的特性和功能，如类、继承和多态等。C++通常用于游戏开发、桌面应用程序和操作系统等领域。 2. C#是一种面向对象的编程语言，它由微软开发并在.NET框架上运行。它是为了与Java竞争而开发的，因此具有很多相似之处。C#通常用于开发Web应用程序、桌面应用程序、游戏和移动应用程序等。 3. C语言比C++和C#更简单易学，但它的功能和特性相对较少。C++比C更复杂，但它提供了更多的功能和灵活性。C#相对于C++来说更容易学习，因为它提供了自动垃圾收集和其他高级特性。 4. C语言和C++都需要手动管理内存，而C#具有自动垃圾收集功能，可以自动释放不再使用的内存。 总之，C、C++和C#都有各自的优势和适用场景，开发者应该根据自己的需求和项目要求来选择合适的编程语言。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值