精华内容
下载资源
问答
  • 对象之间不能相互通信
    千次阅读
    2020-12-30 17:51:12

    第一种:直接调用(强耦合、循环嵌套)

    #include <iostream>
    
    using namespace std;
    
    class CouplingB
    {
    public:
        void HandleMessage(int i)
        {
            cout << i << endl;
        }
    };
    
    class CouplingA
    {
    public:
        void SendMessage(int i)
        {
            m_b.HandleMessage(i);
        }
    
    private:
        CouplingB m_b;
    };
    
    int main()
    {
        CouplingA coupleingA;
        coupleingA.SendMessage(100);
    	return 0;
    }
     
    

    第二种:中介者(解耦)

    class DecouplingClassA
    {
    public:
        void SendMessage(int i);
        void HandleMessage(int i)
        {
            cout << "DecouplingClassB::HandleMessage(): " << i << endl;
        }
    };
    
    class DecouplingClassB
    {
    public:
        void SendMessage(int i);
        void HandleMessage(int i)
        {
            cout << "DecouplingClassB::HandleMessage(): " << i << endl;
        }
    };
    
    class Mediation
    {
    private:
        Mediation() {}
    
    public:
        DecouplingClassA GetClassA()
        {
            return m_classA;
        }
    
        DecouplingClassB GetClassB()
        {
            return m_classB;
        }
    public:
        static Mediation* Instance()
        {
            if(nullptr == m_instance)
            {
                m_instance = new Mediation;
            }
            return m_instance;
        }
    
    private:
        DecouplingClassA m_classA;
        DecouplingClassB m_classB;
    
    private:
        static Mediation *m_instance;
    };
    
    Mediation *Mediation::m_instance = nullptr;
    
    void DecouplingClassA::SendMessage(int i)
    {
        cout << "DecouplingClassA::SendMessage -> ";s
    
        DecouplingClassB classB = Mediation::Instance()->GetClassB();
        classB.HandleMessage(i);
    }
    
    void DecouplingClassB::SendMessage(int i)
    {
        cout << "DecouplingClassB::SendMessage -> ";
    
        DecouplingClassA classA = Mediation::Instance()->GetClassA();
        classA.HandleMessage(i);
    }
    
    int main()
    {
        // 去耦合(中介器)
        DecouplingClassA classA = Mediation::Instance()->GetClassA();
        classA.SendMessage(200);
        DecouplingClassB classB = Mediation::Instance()->GetClassB();;
        classB.SendMessage(300);
        
        return 0;
    }
    
    

    第三种:回调接口(常用、可扩展成观察者模式)

    #ifndef CALLBACK_H
    #define CALLBACK_H
    
    #include <iostream>
    using namespace std;
    
    
    class Interface
    {
    public:
        virtual ~Interface() {}
        virtual void Test(int i) = 0;
    };
    
    class Invoker
    {
    public:
        Invoker() {}
    
        Invoker(Interface *interface)
        {
            m_interface = interface;
        }
    
        void SetHandler(Interface *interface)
        {
            m_interface = interface;
        }
    
        void Invoke()
        {
            if(nullptr != m_interface)
                m_interface->Test(500);
        }
    
    private:
        Interface *m_interface;
    };
    
    class Realizer : public Interface
    {
    public:
        Realizer() {}
    
        void Test(int i)
        {
            cout << "Realizer::test(): " << i << endl;
        }
    };
    
    #endif // CALLBACK_H
    
    
    int main()
    {
        // 回调接口
        Realizer *realizer = new Realizer;
        Invoker *invoker = new Invoker(realizer);
        invoker->Invoke();
    
        return 0;
    }
    
    

    第四种:绑定函数指针

    第五种:Qt的信号槽(很强大)

    更多相关内容
  • 闲话少说正题如下:本人在开发过程中曾经碰过一个疑惑:面向对象开发时候在类之间通信如何做?1:如果把所有的需要参数都通过结构指针传过去那么需要调用类的一些功能函数如何处理?2:我就写个全局变量吧,爱什么数据就...

    本人才学有限,望大师手下留情给以多支持和鼓励,感恩中......

    闲话少说正题如下:

    本人在开发过程中曾经碰过一个疑惑:

    面向对象开发时候在类之间的通信如何做?

    1:如果把所有的需要参数都通过结构指针传过去那么需要调用类的一些功能函数如何处理?

    2:我就写个全局变量吧,爱什么数据就往那边去取吧?但是如果你要建立多份单独处理数据如何做??,你在动全局变量的时候别的代码也在用,如何同步???随着代码的增加,你的全局变量也悄悄增加了不少.一行错误的修改全局变量让你查上几天几夜偶有发生.就如本人以前一个小程序是否有人和我有同感?

    3:我要对我自己类对象里面数据做单独处理,不要全局来全局去了,可以创建多份对象?但是我取不到我需要的上层数据或者其他模块数据或功能,这个是困扰我很久一直致力去寻找解决方案的问题.也许是本人学习能力不强吧,在没有高人指点下,自己查资料看书,长时间无所理解和领悟.

    4:我要更换其中一个模块,或在中间加一个控制层的时候天要塌下来了,很多以前调试过的痛苦又要来一遍.

    5:几个人一起开发做几个模块个人认为用dll比较好一个模块一个dll,但是通信又是如何做?无数个接口函数?传无数种类的参数?

    6:数据库接口想单独一个模块,但是如果查询有几个结果后发送数据给客户端....等等不是说好的模块化了嘛数据库的项目得包含网络模块貌似不太合理,不包含给上层调用者吗?数据没有固定多少个返回什么?用万能指针?得开辟空间!!!如图:如果底层模块相互之间通信这复杂程度和调试维护代价将是不小负担。

    总结上面几个困扰,其实无非是通信问题.以下一点感想献给和我一样存在困惑的人的一点自己拙劣的想法来个抛砖引玉希望能有老师指正:

    先做一个演示工程吧:

    这边是3个工程我用2个动态库加一个exe工程来做下演示:

    说明下,对话框那边就是我们人机对话的工程是属于上层数据库的是用来存储本地数据,我用的是基于FastDB来做我的数据库存储,网络通信我基于hp-sock代码来做的

    看到图片想了这个问题了吧 CnetIoSpi是么东西?做什么用的?

    是的就是一个给下层类里面提供回调的接口当网络消息回来了往我们上层推送数据给上层去处理吧。

    这样继承就够了么?没有。。。。

    这样就能调用上层的回调函数了

    数据库模块如何调用网络模块呢?同样注册这个模块在主调上层中就有调用这个类的功能了转接到上层去调用网络功能,这也就是mfc和windows常采用回调方式去解决复杂调用关系和模块通信的难题吧。

    水平实在有限错漏也难免,理论功底不厚不能写出精彩文章,只要能给您的思想有些启示那么本文目的达到了,希望与诸君共同学习进步。本文图片的代码由于牵涉太多是我现在手上开发还没有完成的所以就不发了,直接给你们最新构建的3个模块演示的版本来说明.

    需要演示代码可以去:https://download.csdn.net/download/lyfwwb/10381665

    下载:点击打开链接

    展开全文
  • C++对象之间通信的三种常见方式

    万次阅读 2017-11-03 18:53:19
    经过这一年多对C++的使用,总结出了下边的三种常见对象之间通信方式。这里就上代码了。只作为一种设计思想,记录下来方便自已以后使用,和大家一起学习,这只是自已在工作中的总结,如果谁有更好的经验,请回复...

    经过这一年多对C++的使用,总结出了下边的三种常见对象之间的通信方式。这里就不上代码了。只作为一种设计思想,记录下来方便自已以后使用,和大家一起学习,这只是自已在工作中的总结,如果谁有更好的经验,请回复我,我再加进去。

    1:使用一个全局单例对象作为交互对象的中介;

    在这种交互方式中,有三个对象参加进来。

    类1:ClassA;             //用来创建交互对象1:obj1

    类2:ClassB;             //用来创建交互对象2:obj2

    类3:ClassC;             //单例类,用来创建单例对象:objS

    如果obj1现在要给obj2发送一条消息,就要先从objS中取得obj2的对象指针地址。然后通过这个地址把消息发送给obj2。当然,用同样的方法,我们也可以让obj2给Obj1发送消息。

    这里使用时要注意的问题有两个。

          1) obj1给obj2发送消息时,objS中存的obj2对象地址不能为空

          2) 当创建obj2时,要马上把obj2的实例地址传送给单例objS,在销毁obj2时,要马上把obj2在单例objS中保存的对象地址清空为NULL

    C++对象之间通信的三种常见方法 - ♂苹果 - 眼睛想旅行

     

    2:为交互的对象创建一个虚接口代理类;

         这种方式,适合自已常常要给第三方发回调消息的对象,比如按钮或者控件什么的。因为自已包含于目标对象,所以比较方便设置代理,也可以使用目标对象对控件对象对外组合封装起来。

         这种交互方式中,有两个对象参加进来,创建类时,需要创建发消息对象的虚代理类。在而目标对象要继承这个虚代理类并实现这个代理类的虚方法。他和第三种方式相比,优点是可以创建多条消息通道。

    类1:ClassA;              //用来创建交互类ClassC,将作为obj1的一个父类

    类2:ClassB;              //用来创建发送消息的对象2:obj2

    虚接口类:ClassX;    //用来实现交互,在obj2中会包含一个ClassX的实例类型变量。以方便保存obj1的对象地址。

    类3: ClassC;               //继承自ClassA和ClassX,用来创建交互对象1:obj1

    C++对象之间通信的三种常见方法 - ♂苹果 - 眼睛想旅行

    3:创建交互对象的基类方法函数指针。

           这种方式和第二种其实是差不多的,只是这种方式,比较适合只有一条回调消息的情况。这里只有两个对象,和一个对象方法函数指针。这里只强调一下,对象函数指针的定义方式。

           类1:ClassA;                               //用来创建交互对象1:obj1

           类2:ClassB;                                //用来创建交互对象2:obj2

    这里说明一下obj1和obj2的方法函数指针都怎么创建:

          假如:

                   ClassA有一个对象方法,void func1(); 我们给这个方法定义一个指针类型如下

                   typedef  void  (ClassA::*FUNC1)();

            在对象obj2中就可以定义这么一个FUNC1类型的对象指针。定在创建obj1中创建obj2时把obj1的这个FUNC1的指针类型赋上obj1的回调方法指针。这样就可以在obj2中使用使用obj1的这个对象方法指针调用obj2的回调方法了。 请看图:

    C++对象之间通信的三种常见方法 - ♂苹果 - 眼睛想旅行

    第一种方法最常用容易理解,第二方法速度快,第一种与三种结合适合批量对象交互,可组成MVC或观察着模式。
    UML图画的并不标准,正在学习中。

    欢迎转载,转载注明出处: http://fengmm521.blog.163.com/blog/static/25091358201421292224959/
    另外我有一个QQ群,欢迎爱技术的来一起学习交流:213571088
    展开全文
  • Python处理器相互通信

    千次阅读 2020-12-05 12:18:44
    下图显示了多个子进程之间同步的各种通信机制各种沟通机制在本节中,我们将了解各种通信机制。机制如下所述 -队列队列可以与多进程程序一起使用。 多处理 模块的Queue类与 Queue.Queue 类相似。因此,可以使用相同的...

    流程互通是指流程之间的数据交换。有必要在进程之间交换数据以开发并行应用程序。下图显示了多个子进程之间同步的各种通信机制

    各种沟通机制

    在本节中,我们将了解各种通信机制。机制如下所述 -

    队列

    队列可以与多进程程序一起使用。 多处理 模块的Queue类与 Queue.Queue 类相似。因此,可以使用相同的API。 多处理

    .Queue为我们提供了一个线程和进程安全的FIFO(先进先出)进程之间的通信机制。

    下面是一个简单的例子,它来自python官方文档的多处理,以理解Queue类的多处理的概念。

    from multiprocessing import Process, Queue

    import queue

    import random

    def f(q):

    q.put([42, None, 'hello'])

    def main():

    q = Queue()

    p = Process(target = f, args = (q,))

    p.start()

    print (q.get())

    if __name__ == '__main__':

    main()

    输出

    [42, None, 'hello']

    管道

    它是一种数据结构,用于在多进程程序中的进程之间进行通信。Pipe()函数返回一个由管道连接的连接对象,默认情况下是双工(双向)。它以下列方式工作 -

    它返回一对连接对象,表示管道的两端。

    每个对象都有两个方法 - send() 和 recv() ,以便在进程之间进行通信。

    下面是一个简单的例子,它取自python官方文档的多处理,以理解多处理的 Pipe() 函数的概念。

    from multiprocessing import Process, Pipe

    def f(conn):

    conn.send([42, None, 'hello'])

    conn.close()

    if __name__ == '__main__':

    parent_conn, child_conn = Pipe()

    p = Process(target = f, args = (child_conn,))

    p.start()

    print (parent_conn.recv())

    p.join()

    产量

    [42, None, 'hello']

    Manager

    Manager是一类多处理模块,它提供了一种在所有用户之间协调共享信息的方法。管理器对象控制服务器进程,该进程管理共享对象并允许其他进程操作它们。换句话说,管理者提供了一种创建可在不同流程之间共享的数据的方法。以下是经理对象的不同属性

    管理器的主要属性是控制管理共享对象的服务器进程。

    另一个重要属性是在任何进程修改它时更新所有共享对象。

    下面是一个示例,它使用manager对象在服务器进程中创建列表记录,然后在该列表中添加新记录。

    import multiprocessing

    def print_records(records):

    for record in records:

    print("Name: {0}\nScore: {1}\n".format(record[0], record[1]))

    def insert_record(record, records):

    records.append(record)

    print("A New record is added\n")

    if __name__ == '__main__':

    with multiprocessing.Manager() as manager:

    records = manager.list([('Computers', 1), ('Histoty', 5), ('Hindi',9)])

    new_record = ('English', 3)

    p1 = multiprocessing.Process(target = insert_record, args = (new_record, records))

    p2 = multiprocessing.Process(target = print_records, args = (records,))

    p1.start()

    p1.join()

    p2.start()

    p2.join()

    输出

    A New record is added

    Name: Computers

    Score: 1

    Name: Histoty

    Score: 5

    Name: Hindi

    Score: 9

    Name: English

    Score: 3

    管理器中命名空间的概念

    Manager Class带有命名空间的概念,这是一种跨多个进程共享多个属性的快捷方法。命名空间没有任何可以调用的公共方法,但它们具有可写属性。

    以下Python脚本示例帮助我们利用名称空间在主进程和子进程之间共享数据 -

    import multiprocessing

    def Mng_NaSp(using_ns):

    using_ns.x +=5

    using_ns.y *= 10

    if __name__ == '__main__':

    manager = multiprocessing.Manager()

    using_ns = manager.Namespace()

    using_ns.x = 1

    using_ns.y = 1

    print ('before', using_ns)

    p = multiprocessing.Process(target = Mng_NaSp, args = (using_ns,))

    p.start()

    p.join()

    print ('after', using_ns)

    产量

    before Namespace(x = 1, y = 1)

    after Namespace(x = 6, y = 10)

    Ctypes-Array和Value

    多处理模块提供Array和Value对象,用于将数据存储在共享内存映射中。 Array 是从共享内存分配的ctypes数组, Value

    是从共享内存分配的ctypes对象。

    为了使用,从多处理导入Process,Value,Array。

    以下Python脚本是一个从python文档中获取的示例,它利用Ctypes Array和Value在进程之间共享一些数据。

    def f(n, a):

    n.value = 3.1415927

    for i in range(len(a)):

    a[i] = -a[i]

    if __name__ == '__main__':

    num = Value('d', 0.0)

    arr = Array('i', range(10))

    p = Process(target = f, args = (num, arr))

    p.start()

    p.join()

    print (num.value)

    print (arr[:])

    输出

    3.1415927

    [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

    通信顺序进程(CSP)

    CSP用于说明系统与具有并发模型的其他系统的交互。CSP是一个通过消息传递编写并发或程序的框架,因此它对描述并发性很有效。

    Python库 - PyCSP

    为了实现CSP中的核心原语,Python有一个名为PyCSP的库。它使实现非常简短和可读,因此可以非常容易地理解它。以下是PyCSP的基本流程网络

    在上面的PyCSP过程网络中,有两个过程 - 过程1和过程2.这些过程通过两个通道传递消息进行通信 - 通道1和通道2。

    安装PyCSP

    借助以下命令,我们可以安装Python库PyCSP

    pip install PyCSP

    以下Python脚本是一个相互并行运行两个进程的简单示例。它是在PyCSP python libabary的帮助下完成的

    from pycsp.parallel import *

    import time

    @process

    def P1():

    time.sleep(1)

    print('P1 exiting')

    @process

    def P2():

    time.sleep(1)

    print('P2 exiting')

    def main():

    Parallel(P1(), P2())

    print('Terminating')

    if __name__ == '__main__':

    main()

    在上面的脚本中,创建了两个函数,即 P1 和 P2 ,然后使用 @process 进行修饰,以将它们转换为进程。

    输出

    P2 exiting

    P1 exiting

    Terminating

    展开全文
  • 对象之间通信

    千次阅读 2013-05-25 19:14:58
    对象之间进行通信最基本的方式就是消息传递,在Cocoa中提供Notification Center机制来完成这一任务。其主要作用就是负责在任意两个对象之间进行通信。使用方法很简单,如下几个步骤即可:  假设A与B之间进行通信...
  • 线程之间相互通信

    千次阅读 2018-08-22 19:48:00
    线程之间相互通信  在介绍线程相互通信前为大家介绍一下有关线程通信的一些知识    线程的状态(线程的生命周期)  线程的状态 NEW 新建状态,刚刚创建完成还没开启的状态 RUNNABLE 可运行状态,...
  • 计算机之间是如何实现通信的?

    千次阅读 2021-08-16 09:52:13
    在计算机网络中,计算机之间要实现连接和通信,就需要遵守一定的规则,我们把这种连接和通信的规则称为网络通信协议,它对数据的传输格式,传输速率和传输步骤等都做了统一规定,通信双方都必须遵守才能完成数据...
  • Fragment之间通信

    千次阅读 2018-12-05 19:14:29
    两个fragment之间不应该直接进行通信。 定义接口 为了允许fragment和它的Activity通信,你应该fragment类中定义一个接口并在Activity中实现它。Fragment在onAttach()回调函数中获取接口的具体实现的对象。后面...
  • 今天,我将全面讲解Android Native端与Flutter端通信的三种交互方式
  • 串行通信总结(实现两个单片机之间通信

    万次阅读 多人点赞 2017-01-06 11:47:59
    串行通信实现的是两个对象之间的数据传递,对象通常是单片机。通信实际上是在两个单片机上连上线,通过线路来传递信息。 如图,调制解调器非常重要,其作用是实现数字信号和模拟信号的转换。但是注意,调制解
  • 早期方法的不足: 早期的方法只使用一种系统的视角作为构造块,而没有容纳其他视角。 1、结构化分析和设计方法集中于将功能作为系统的构造块...为了克服传统开发方法的不足,面向对象方法解决问题的思路 是从现实世...
  • Activity与Fragment之间通信的多种方式

    千次阅读 2022-04-12 23:33:00
    前言 本文主要介绍Activity与Fragment之间通信,以及同属于一个Activity的Fragment之间通信。主要的方式有 1、通过
  • 安卓中不同APP之间的消息通信

    万次阅读 2016-04-15 14:13:13
    昨天在腾讯实习生招聘初试面试时面试官问道我关于两个APP之间相互通信的方式,当时自己回道到了contentProvider与BroadcastReceiver。但他接着问还有没有其它的方式,我跟他说可以使用AIDL,但是当时没说清楚,所以...
  • 10种React组件之间通信的方法

    千次阅读 2020-11-13 19:58:27
    组件间通信方式总结 父组件 => 子组件: Props Instance Methods 子组件 => 父组件: Callback Functions Event Bubbling 兄弟组件之间: Parent Component 太相关的组件之间: Context Portals Global Variables...
  • vue各页面/组件之间通信

    千次阅读 2021-03-05 14:46:38
    二、通过Vue.prototype挂载一个全局的对象 在main.js中定义 Vue.prototype.$EventBus = new Vue() 在B页面中,页面加载函数里,定义一个监听事件 this.$EventBus.$on("switchTab",(val)=>{ }) 在A页
  • Vue中嵌入html页面并相互通信

    千次阅读 2022-03-22 15:31:39
    vue通过iframe嵌套html页面并且相互之间通信
  • Vue 兄弟组件之间通信

    千次阅读 多人点赞 2021-08-13 14:56:24
    而且掌握Vue组件之间的通讯方式还是掌握Vue组件的另一种能力。 在Vue中,Vue的组件自身就很棒,因为它可以帮助我们使用重用的代码片段,我们也可以使用Vue提供的所有功能。现在我们要掌握怎么建立组件之间的连接,...
  • 一个窗口更新localStorage,另一个窗口监听window对象的”storage”事件,来实现通信。 注:两个页面要同源(URL的协议、域名和端口相同) 2、cookie+setInterval() page1将要传递的信息存储在cookie中,page2使用...
  • 专栏 >实现游戏对象与对象之间通信

    千次阅读 2012-08-06 02:21:46
    游戏中,对象与对象之间需要交流,实现的方法多种,例如:可定义静态变量,其他脚本直接调用, 也可用到: SendMessage 今天主要学习SendMessage的用法。   1、创建两个脚本:“Cube0”和“Cube1”; 2、将两个...
  • 利用Micropython+socket通信实现两块esp32之间通信
  • 〖Python语法进阶篇⑤〗 - 进程间的通信

    千次阅读 多人点赞 2022-04-10 22:33:56
    今天的章节我们来学习一下进程之间通信,通过...但有的时候两个进程之间需要进行相互之间的配合才能完成工作,这就需要今天所要学习的主题:`通信` 的帮助。接下来我们就学习一下 `进程的通信` 都需要那些知识吧。
  • JAVA系统之间通信方式总结

    千次阅读 2017-08-14 15:24:10
    据我所知,目前对于Java系统之间通信方式有如下几种: 同步:RMI,Hessian,Burlap,Http invoker 异步:JMS,AMQP RMI: 1.java的远程方法调用,底层(运输层)使用tcp连接,自定义应用层协议,协议格式如...
  • iframe通信

    千次阅读 2022-03-14 10:44:08
    父子页面元素操作 跨域情况下是不能直接获取子页面元素的,但如果是同一主域的跨域,如:aaa.test.com和bbb.test.com,可以采用如下方法: 实现的关键点,是在父、子页面都加入一条js语句: 父页面代码: aaa ...
  • 多线程之间通信的5种方式

    万次阅读 2020-01-05 15:11:39
    首先,我们知道线程间通信的模型有两种:共享内存和消息传递,以下方式都是基本这两种模型来实现的; 以客户卖包子为例,当店家在包子加工到第4步时就可以卖给客户为例说明,A,B两个线程,示例如下: 方式一:使用...
  • 两个项目之间如何通信

    万次阅读 2017-12-11 11:47:22
    不同项目之间通信方式分为,http、socket、webservice;其中socket通信的效率最高,youtube就采用的是原始的socket通信,他们信奉的原则是简单有效。 一、http通信:  Http通信主要有两种方式POST方式和GET...
  • 进程间通信和线程间通信

    千次阅读 2020-08-18 20:26:22
    线程间通信 进程和线程的区别 程序只是一组指令的有序集合,它本身没有任何运行的含义,它只是一个静态的实体。而进程则不同,它是程序在某个数据集上的执行。进程是一个动态的实体,它有自己的生命周期。它因...
  • python多进程间通信与接口间调用

    千次阅读 2020-12-29 09:03:42
    但是使用由主系统推送信息,到机器人执行完成,再返回主系统结果,这样的单进程模式,显然合理,于是想到了利用python的多进程模式。flow.png多进程多进程使用python内置的multiprocessing模块,它提供了一个...
  • 前面实现了服务器与多个客户端之间通信,我们真正的目的是要实现多个客户端之间通信 使用TCP协议实现的方案: 客户端的数据包通过服务器中转,发送到另一个客户端 实现步骤: 1、对象序列化:(对象...
  • 从事汽车软件开发,通信中间件绕开,当前最火热的无非有 2 种:Some/IP 和 DDS。DDS 是一种分布式通信标准,有很多商业和开源的实现,Fast DDS 是其中的一种。它在 ROS2 中被应用,而 Apollo 中的 CyberRT 框架中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,675
精华内容 60,270
热门标签
关键字:

对象之间不能相互通信