C++中建立对象间消息连接的系统方法

数据中心光模块升级实录:从200G QSFP56到400G QSFP-DD的踩坑指南 本文记录了数据中心从200G QSFP56升级至400G QSFP-DD光模块的完整实战经验。文章深入剖析了升级过程中面临的兼容性、链路预算、布线、散热与功耗管理等核心挑战,并提供了具体的解决方案与排坑指南,为高速网络升级提供了宝贵的实践参考。 阅读详情

  用过C++进行过面向对象程序设计的用户都知道,程序中的对象很少单独存在。不考虑对象间的相互作用几乎是不可能的。所以,标识对象间的关系或建立对象间的消息连接是面向对象程序设计的一项重要任务。本文着重从C++程序设计的角度,提出一种建立对象间消息连接的实用方法。如果你想详细了解面向对象程序设计技术,请参阅有关专著。

  大家都知道对象是数据和方法的封装体。在C++中,它们分别表现为数据成员和成员函数。程序设计者通过执行对象的各种方法,来改变对象的状态(即改变对象的属性数据)。从而使该对象发生某些“事件”。当一对象发生某事件时,它通常需向其它相关对象发送“消息”,请求它们作出一些处理。 这时,发生事件并向其它对象请求处理的对象被称为“事件对象”,而处理事件的对象被称为“回调对象”。回调对象对事件的处理称为“回调函数”。

  在C++中,这一过程相当于:当事件对象发生事件时,调用回调对象的某些成员函数。通常的作法是回调对象向事件对象传递对象指针。但这种方法不通用。为了减少程序设计的工作量,本文提出一种建立对象间消息连接的系统方法。它的思路是:将“事件发生→请求处理→执行处理”这一过程抽象成一个“回调”(CallBack)类。通过继承,用户可以轻松获取建立对象间消息连接的机制。

  一、回调类的数据结构及其成员函数

  本文提出的CallBack类支持三种回调函数。它们是:回调对象中的成员函数,属于回调类的静态成员函数和普通的C函数。CallBackle类中包含一回调函数表callBackList。它用于记录事件名称,指向回调函数及回调对象的指针。该表的每一个节点为一个事件记录EventRecord。每个事件记录包含三个域:事件名指针eventName,指向回调对象的指针pointerToCBO,指向回调函数的指针pointerToCBF或pointerToCBSF(其中,pointerToCBF指向回调对象的成员函数,pointerToCBSF指向回调类的静态成员函数或普通函数。它们同处于一共用体内)。CallBack类所提供的回调机制是这样的:在事件对象上注册回调对象中的回调函数;当事件发生时,事件对象在其回调表中检索并执行回调函数。从而使二者的消息连接得以建立。(关于该类的具体实现,请参阅文后所附的程序清单) 回调对象

  事件对象

  事件名 回调对象指针 回调函数指针

“event” pointerCBO pointerToCBF或

pointerTOCBSF

- - - - - -

  AddCallBack: 注册事件名和指向回调函数,回调对象的指针

  CallCallBack: 在回调表中,检索注册在指定事件上回调函数并调用它们

  事件发生时,调用CallCallBack函数

  对事件event进行处理的成员函数

  从CallBack类继承的回调表callBackList, 成员函数AddCallBack和CallCallBack。

  当回调函数为静态成员函数或普通C函数时, pointerToCBO为NULL。

  事件名是回调表callBackLis中的检索关键字。

  回调对象中其它成员函数

  CallBack类的成员函数AddCallBack用来将回调函数注册到事件对象的回调表中。它有两个重载版本:

void CallBack::AddCallBack(char *event,CallBackFunction cbf,CallBack *p);
void CallBack::AddCallBack(char *event,CallBackStaticFunction cbsf);

  其中,第一个AddCallBack用来将某回调对象的成员函数注册到事件对象的回调表中。第二个AddCallBack用来将或某回调类的静态成员函数注册到事件对象的回调表中。在上参数表中,event是指向事件名字符串的指针,p是指向回调对象的指针,cbf和cbsf分别是指向成员函数及静态成员函数(或普通函数)的指针。当回调函数来自某回调对象SomeObject时,传递成员函数指针应采用如下格式:

(CallBackFunction)&SomeObject::MemberFunctionName; 传递SomeObject类的某静态成员函数指针应采用格式:
(CallBackStaticFunction)& SomeObject::FunctionName;传递程序中普通函数指针时,只需传递函数名即可。

  CallBack类的成员函数void CallBack::CallCallBack(char *ename, CallData calldata = NULL)用来调用注册在事件ename上的所有回调函数。其中,calldata为数据指针(CallData实际上就是void*,详见程序清单)。事件对象可通过它向回调对象传递有用的数据。该成员函数通常在事件对象的成员函数中调用,因为通常只有事件对象的成员函数才能改变对象的内部数据,从而使某些事件发生。

  成员函数RemoveCallback用来删除注册在事件对象上的回调函数。它的三个重载版本依次为:

void CallBack::RemoveCallBack(char *event,CallBackFunction cbf,CallBack *p);

void CallBack::RemoveCallBack(char *event,CallBackStaticFunction cbsf);

void CallBack::RemoveCallBack(char *event);

  其中,event,cbf,cbsf,p等参数和成员函数AddCallBack中各参数一样。第一个RemoveCallBack用于删除注册在事件event上某回调对象的一个成员函数。第二个RemoveCallBack用于删除注册在事件event上的某普通函数或某回调类的一个静态成员函数。第三个RemoveCallBack用于删除注册在事件event上的全部回调函数。

  二、CallBack类的使用方法

  使用CallBack类,可按以下步骤进行:

  1.确定程序中哪些对象间存在关系,需要建立消息连接。并确定在各特定消息连接关系中,哪个对象是事件对象,哪个对象是回调对象。

  2.事件对象类和回调对象类都必须从CallBack类继承,以获得回调支持。

  3.为事件对象注册回调数据。包括:事件名,回调函数名,指向回调对象的指针。

  4.当你感兴趣的事件发生时,在事件对象类引发事件的成员函数中调用CallCallBack函数。

  下面是一个具体的例子。通过它你会对Callback类的使用方法有进一步的了解。

file://测试程序文件:test.cpp

#include"callback.h"

file://“扬声器”类

class Speaker:public CallBack
{
 private:
  int volume;
 public:
  Speaker(int v): volume(v) {}
  void IncreaseVolume(int v) file://增加音量成员函数
  {
   volume += v;
   if(volume > 20){ file://“音量大于20”事件发生了
    file://调用注册在两事件上的回调函数
    CallCallBack("音量改变了");
    CallCallBack("音量大于20", &volume);
   }
  }

 void DecreaseVolume(int v) file://降低音量成员函数
 {
  volume -= v;
  if(volume < 5){ file://“音量小于5”事件发生了
   file://调用注册在两事件上的回调函数
   CallCallBack("音量改变了");
   CallCallBack("音量小于5", &volume);
  }
 }
};

file://“耳朵”类

class Ear : public CallBack
{
 public:
  static void Response(CallData callData) file://对“音量改变”的反应
  {
   cout<<"音量改变了."<<endl;
  }
  void HighVoiceResponse(CallData callData)//对高音的反应
  {
   cout<<”喂!太吵了!现在音量是:"<<*((int *)callData)<<endl;
  }
  void LowVoiceResponse(CallData callData)// 对低音的反应
  {
   cout<<"啊!我听不清了。现在音量是:"<<*((int *)callData)<<endl;
  }
};

void main(void)
{
 Speaker s(10); file://现在音量为10
 Ear e;
 file://为事件对象s注册回调函数
 s.AddCallBack("音量大于20”,(CallBackFunction)&Ear::HighVoiceResponse,&e);
 s.AddCallBack("音量小于5”,(CallBackFunction)&Ear::LowVoiceResponse,&e);
 s.AddCallBack("音量改变了",(CallBackStaticFunction)&Ear::Response);
 s.IncreaseVolume(12);//将音量增加12,现在音量位22
 s.DecreaseVolume(20);//将音量减少20,现在音量位2
}

  运行结果:

  音量改变了.

  喂!太吵了!现在音量是:22

  音量改变了.

  啊!我听不清了。现在音量是:2

  在上例中,扬声器对象s为事件对象,耳朵对象e为回调对象。。s上被注册了三个事件:“音量改变了”,“音量大于20”,“音量小于5”。 回调函数分别为:Ear::Response, Ear::HighVoiceResponse,Ear::LowVoiceResponse。当扬声器s通过其成员函数IncreaseVolume和 DecreaseVolume改变音量时,回调对象e会自动作出反应。可见,通过使用CallBack类,在对象间建立消息连接已变为一项很简单和优美的工作。

  由于笔者水平有限,该类的设计必有不完善之处。如果您对它感兴趣,笔者可与各位C++玩家共同探讨这类问题。
附:程序清单(本程序在MS VC++5.0和TC++3.0上均编译通过)

file://回调类的类结构:callback.h

#ifndef _CALLBACK_H

#define _CALLBACK_H

#include<stdlib.h>

#include<string.h>

#include<iostream.h>

#define CALLBACKLIST_INIT_SIZE 10

#define CALLBACKLIST_INCREMENT 5

class CallBack;

typedef void *CallData;//回调数据指针类型定义

typedef void (CallBack::*CallBackFunction)(CallData); file://指向回调成员函数的指针

typedef void (*CallBackStaticFunction)(CallData); file://指向静态成员函数或普通函数的指针类型定义

class EventRecord{
 private:
  char *eventName; file://回调事件名称
  CallBack *pointerToCBO;//指向回调对象的指针
  file://指向成员函数的指针和指向静态成员函数(或普通函数)指针的共用体
  union{
   CallBackFunction pointerToCBF;
   CallBackStaticFunction pointerToCBSF;
  };
 public:
  EventRecord(void); file://事件记录类的缺省构造函数
  file://构造包含成员函数的事件记录
  EventRecord(char *ename,CallBack *pCBO,CallBackFunction pCBF);
  file://构造包含静态成员函数或普通函数的事件记录
  EventRecord(char *ename,CallBackStaticFunction pCBSF);
  ~EventRecord(void);//析构事件记录
  void operator = (const EventRecord& er);//重载赋值运算符
  file://判断当前事件记录的事件名是否为ename

  int operator == (char *ename) const;

  file://判断当前事件记录是否和指定事件记录相等

  int operator == (const EventRecord& er) const;

  void Flush(void); file://将当前事件记录清空

  int IsEmpty(void) const;//判断事件记录是否为空(即事件名是否为空)

  friend class CallBack; file://让CallBack类能访问EventRecord的私有成员;

};

class CallBack {
 private:
  EventRecord *callBackList; file://回调事件表
  int curpos; file://当前事件记录位置
  int lastpos; file://回调表中最后一空闲位置
  int size; file://回调表的大小

  void MoveFirst(void) { curpos = 0; }//将当前记录置为第一条记录
  void MoveNext(void) file://将下一条记录置为当前记录
  {
   if(curpos == lastpos) return;
   curpos++;
  }

  file://判断回调表是否被遍历完

  int EndOfList(void) const { return curpos == lastpos; }
   public:
    CallBack(void);//构造函数
    CallBack(const CallBack& cb);//拷贝构造函数
    ~CallBack(void);//析构函数

  void operator = (const CallBack& cb);// 重载赋值运算符

  file://将回调对象的成员函数、静态成员函数(或普通函数) file://注册为事件对象的回调函数

  void AddCallBack(char *event,CallBackFunction cbf,CallBack *p);
  void AddCallBack(char *event,CallBackStaticFunction cbsf);
  file://删除注册在指定事件上的回调函数

  void RemoveCallBack(char *event,CallBackFunction cbf,CallBack *p);
  void RemoveCallBack(char *event,CallBackStaticFunction cbsf);
  void RemoveCallBack(char *event);// 删除某事件的全部记录

  file://执行注册在某一事件上的所有回调函数

  void CallCallBack(char *event, CallData calldata = NULL);

 };

 #endif

 file://回调类的实现:callback.cpp

 #include"callback.h"

 file://EventRecord类的实现

 EventRecord::EventRecord(void)
 {
  eventName = NULL;
  pointerToCBO = NULL;
  file://因为sizeof(CallBackFunction) > sizeof(CallBackStaticFunction)
  pointerToCBF = NULL;
 }

 EventRecord::EventRecord(char *ename, CallBack *pCBO, CallBackFunction pCBF)
 :pointerToCBO(pCBO), pointerToCBF(pCBF)
 {
  eventName = strdup(ename);
 }

 EventRecord::EventRecord(char *ename, CallBackStaticFunction pCBSF)
 :pointerToCBO(NULL), pointerToCBSF(pCBSF)
 {
  eventName = strdup(ename);
 }

 EventRecord::~EventRecord(void)
 {
  if(eventName) delete eventName;
 }

 void EventRecord::operator = (const EventRecord& er)
 {
  if(er.eventName)
   eventName = strdup(er.eventName);
  else
   eventName = NULL;
   pointerToCBO = er.pointerToCBO;
   pointerToCBF = er.pointerToCBF;
 }

 int EventRecord::operator == (char *ename) const
 {
  if((eventName == NULL)||ename == NULL)
   return eventName == ename;
  else
   return strcmp(eventName,ename) == 0;
 }

 int EventRecord::operator == (const EventRecord& er) const
 {
  return (er == eventName) /*er和eventname不能交换位置*/
     &&(pointerToCBO == er.pointerToCBO)
     &&(pointerToCBO ?
    (pointerToCBF == er.pointerToCBF):
    (pointerToCBSF == er.pointerToCBSF));
 }

 void EventRecord::Flush(void)
 {
  if(eventName){
   delete eventName;
   eventName = NULL;
  }
  pointerToCBO = NULL;
  pointerToCBF = NULL;
 }

 int EventRecord::IsEmpty(void) const
 {
  if(eventName == NULL)
   return 1;
  else
   return 0;
 }

 file://Callback类的实现
 CallBack::CallBack(void)
 {
  file://按初始尺寸为回调表分配内存空间

  callBackList = new EventRecord[CALLBACKLIST_INIT_SIZE];

  if(!callBackList){
   cerr<<"CallBack: memory allocation error."<<endl;
   exit(1);
  }
  size = CALLBACKLIST_INIT_SIZE;
  lastpos = 0;
  curpos = 0;
 }

 CallBack::CallBack(const CallBack& cb): curpos(cb.curpos),lastpos(cb.lastpos),size(cb.size)
 {
  callBackList = new EventRecord[size];
  if(!callBackList){
   cerr<<"CallBack: memory allocation error."<<endl;
   exit(1);
  }
  file://一一复制各条事件记录
  for(int i = 0; i < size; i++) callBackList[i] = cb.callBackList[i];
 }

 void CallBack::operator = (const CallBack& cb)
 {
  curpos = cb.curpos;
  lastpos = cb.lastpos;
  size = cb.size;
  delete [] callBackList;//删除旧的回调表
  callBackList = new EventRecord[size];//重新分配内存空间
  if(!callBackList){
   cerr<<"CallBack: memory allocation error."<<endl;
   exit(1);
  }

  file://一一复制各条事件记录

  for(int i = 0; i < size; i++) callBackList[i] = cb.callBackList[i];
 }

 CallBack::~CallBack(void)
 {
  delete [] callBackList;
 }

 void CallBack::AddCallBack(char *event, CallBackFunction pCBF, CallBack *pCBO)
 {
  file://如事件名为空,退出
  if( (event == NULL)?1:(strlen(event) == 0)) return;
  file://寻找因删除事件记录而产生的第一个空闲位置,并填写新事件记录
  for(int start=0;start<lastpos;start++)
   if(callBackList[start].IsEmpty()){
    callBackList[start] = EventRecord(event,pCBO,pCBF);
    break;
   }
   if(start < lastpos) return; file://确实存在空闲位置
   file://没有空闲位置,在回调表后追加新记录
   if(lastpos == size) file://回调表已满,需“伸长”
   {
    EventRecord *tempList = callBackList;//暂存旧回调表指针
    file://以一定的步长“伸长”回调表
    callBackList = new EventRecord[size + CALLBACKLIST_INCREMENT];
    if(!callBackList){
     cerr<<"CallBack: memory allocation error."<<endl;
     exit(1);
    }
    file://复制旧回调表中的记录
    for(int i = 0; i < size; i++) callBackList[i] = tempList[i];
    delete [] tempList;//删除旧回调表
    size += CALLBACKLIST_INCREMENT;//记下新回调表的尺寸
   }
   file://构造新的事件记录并将其填入回调表中
   callBackList[lastpos] = EventRecord(event,pCBO,pCBF);
   lastpos++;
  }
  void CallBack::AddCallBack(char *event,CallBackStaticFunction pCBSF)
  {
   if( (event == NULL)?1:(strlen(event) == 0)) return;
   for(int start=0;start<lastpos;start++)
    if(callBackList[start].IsEmpty()){
     callBackList[start] = EventRecord(event,pCBSF);
     break;
    }
   if(start < lastpos) return; file://a hole is found
   if(lastpos == size) file://event list is insufficient
   {
    EventRecord *tempList = callBackList;
    callBackList = new EventRecord[size + CALLBACKLIST_INCREMENT];

    if(!callBackList){
     cerr<<"CallBack: memory allocation error."<<endl;
     exit(1);
    }
    for(int i = 0; i < size; i++) callBackList[i] = tempList[i];
    delete [] tempList;
    size += CALLBACKLIST_INCREMENT;
   }

  callBackList[lastpos] = EventRecord(event,pCBSF);
  lastpos++;
 }

 file://删除注册在指定事件上的成员函数

 void CallBack::RemoveCallBack(char *event, CallBackFunction pCBF, CallBack *pCBO)
 {
  if( (event == NULL)?1:(strlen(event) == 0)) return;
  EventRecord er(event,pCBO,pCBF);

  for(int i = 0; i < lastpos; i++)
   if(callBackList[i] == er) callBackList[i].Flush();
 }

 file://删除注册在指定事件上的静态成员函数或普通函数

 void CallBack::RemoveCallBack(char *event,CallBackStaticFunction pCBSF)
 {
  if( (event == NULL)?1:(strlen(event) == 0)) return;
  EventRecord er(event,pCBSF);

  for(int i = 0; i < lastpos; i++)
   if(callBackList[i] == er) callBackList[i].Flush();
 }

 file://删除注册在指定事件上的所有回调函数

 void CallBack::RemoveCallBack(char *event)
 {
  if( (event == NULL)?1:(strlen(event) == 0)) return;
  for(int i = 0; i < lastpos; i++)
   if(callBackList[i] == event) callBackList[i].Flush();
 }

 void CallBack::CallCallBack(char *event, CallData callData)
 {
  if( (event == NULL)?1:(strlen(event) == 0)) return;
  CallBack *pCBO;
  CallBackFunction pCBF;
  CallBackStaticFunction pCBSF;
  MoveFirst();
  while(!EndOfList())
  {
   file://如当前事件记录和指定事件不匹配,转入下一条记录继续循环
   if(!(callBackList[curpos] == event))
   {
    MoveNext();
    continue;
   }
   file://如找到匹配记录
   pCBO = callBackList[curpos].pointerToCBO;
   file://如事件记录中回调对象指针为空,说明该记录中保存的是静态函数指针
   if(pCBO == NULL){
    pCBSF = callBackList[curpos].pointerToCBSF;
    pCBSF(callData);//调用该静态回调函数
   }
   else file://如事件记录中回调对象指针非空,说明该记录中保存的是成员函数指针
   {
    pCBF = callBackList[curpos].pointerToCBF;
    (pCBO->*pCBF)(callData);// 调用该回调对象的成员函数
   }
   MoveNext();
  }
 }

遗传病变异注释预测工具安装系列之------Exomiser 安装及bug处理 Exomiser是一个Java程序,它从全外显子组或全基因组测序数据中发现潜在的致病变异。 Java 版本必须为1.8以上。 Exomiser 最新版本下载 wget -c https://github.com/exomiser/Exomiser/releases/download/11.0.0/exomiser-cli-11.0.0-distribution.zip unzip ... 阅读详情

相关推荐

别再为SCI论文配图发愁了!手把手教你用PS+AI搞定从数据图到模式图的全流程

本文详细解析了如何利用Photoshop(PS)和Illustrator(AI)高效完成SCI论文配图的全流程,涵盖数据可视化、模式图设计及期刊适配性输出。通过实战案例,帮助科研人员掌握位图与矢量图的处理技巧,提升论文配图质量,满足不同期刊的出版要求。

weixin_28630185的博客 386

C++对象之间通信的几种方式

第一种:直接调用(强耦合、循环嵌套) #include <iostream> using namespace std; class CouplingB { public: void HandleMessage(int i) { cout << i << endl; } }; class CouplingA { public: void SendMessage(int i) { m_b.Handl

Y673582465的专栏 4367

Android SDK安装教程(超详细),从零基础入门到精通,从这篇开始_android sdk下载安装

Android SDK安装教程(超详细),从零基础入门到精通,从这篇开始_android sdk下载安装

Jinmindong 5022

C++解耦合的一种方法

以数据为中心,多模块之间使用全局变量来做消息通知,或者状态改变,这样模块之间没有直接的联系。各个模块都是直接使用全局变量而已。全局变量的问题这里不探讨。以我的实例讲解,游戏中的英雄(主角)在地图上自动奔跑到鼠标点击的地方,或者网络信令传过来的坐标位置上。主角的自动移动方法setAutoMovePos这里不细说原来的做法如下代码//Map.cpp文件 //鼠标按下事件 ...

weixin_34242658的博客 975

从VASP数据到LAMMPS模拟:手把手教你用DeePMD-kit搭建Cr-Si-Fe合金势函数

本文详细介绍了使用DeePMD-kit从VASP数据构建Cr-Si-Fe合金深度势能模型的全流程,包括数据准备、模型训练、优化及LAMMPS集成。通过实战教程,帮助研究者掌握DeePMD-kit训练技巧,实现高精度分子动力学模拟,提升材料计算效率。

weixin_33737134的博客 526

几何非线性-屈曲分析

结构系统的破坏分为两种,一类是因材料软化而引起的强度破坏,另一类是几何软化使得结构的几何形状发生极大变化,从而使结构丧失承载能力。在材料力学中是这样定义压杆失稳的:中心受压直杆(理想模型)在直线状态下平衡,由稳定平衡转化为不稳定平衡时所受的轴向压力的界限值,称为临界压力。中心受压直杆在临界压力的作用下,其直线形态的平衡开始丧失稳定性,简称为失稳。显然,这个定义只使用于理想的压杆模型,那么关于失稳和屈曲是否存在一般性定义呢?

YORU_NO_KUNI的博客 1万+

掌握C++解耦:使用设计模式优化代码结构

在软件工程中,设计模式是一套被反复使用、多数人知晓、经过分类编目、代码设计经验的总结。对于C++开发者而言,设计模式不仅是解决常见问题的工具,更是提升代码质量、确保代码可维护性和扩展性的关键策略。设计模式提供了一个已经被验证的方法论,可以帮助开发者避免某些常见的软件设计问题,减少代码间的不必要依赖,即实现解耦。

探索C++编程的奥秘,分享深入的技术见解和实践,旨在激发读者创造力与解决问题的思维。 1168

告别GIS软件!用R语言ggplot2+ggmapcn绘制出版级世界地图(附5种投影对比图)

本文提供了一份完整的实践指南,教你如何利用R语言及其强大的ggplot2生态系统,结合ggmapcn包,绘制出出版级的世界地图。文章详细对比了五种经典地图投影(如摩尔维德、罗宾森投影)的代码实现与视觉差异,并讲解了如何添加比例尺、指北针等专业元素,最终导出高清PDF,实现从数据分析到专业可视化的全流程代码化操作,彻底告别传统GIS软件。

p5l2m9n4o6q的博客 410

C++对象之间通信

<br />一直学习C++并使用C++完成了一个一个作 业和项目,然而对C++类对象之间的通信总有种不知所措就好像人吃了饭自然会消化那样只知其然,不知起所以然的感觉。人,活着,好多时候是在寻找真理,其 实说俗点就是在找一个自己能够容易接受的理由来说服自己。只是其会这样而不知为什么会这样有时会使人自己遭受心魔攻击。笔者就在写程序时总有股困扰在心中 挥之不去。于是,今天我决定狠下心驱除扰我已久心魔。<br />在将对象消息传递方法之前,我们先声明C++对象之间消息传递区别于windows消息传递。这是两个

耕耘——从菜鸟到高手的蜕变 4549

Cadence OrCAD: 层次化设计 Hierarchical Design

详细介绍OrCAD的原理图层次化设计方法。

Fantasy237的博客 1万+

带洞多边形如何分成凸多边形集合,对多边形进行凸分解?

摘要: 凸分解是计算几何中的经典问题,分为三角化和凸分解两种方法。三角化将带洞多边形转换为简单多边形并分割为三角形,常用算法包括耳剪法、单调多边形三角化等。凸分解则生成更少但更大的凸多边形,常用Hertel-Mehlhorn算法或基于凹点的递归切割。实际应用中建议使用CGAL、Poly2Tri等成熟库处理。三角化适合图形渲染,凸分解更适用于物理引擎和路径规划。关键步骤包括数据校验、选择合适的算法及后处理优化。

插件开发 356

C++对象之间通信的三种常见方式

经过这一年多对C++的使用,总结出了下边的三种常见对象之间的通信方式。这里就不上代码了。只作为一种设计思想,记录下来方便自已以后使用,和大家一起学习,这只是自已在工作中的总结,如果谁有更好的经验,请回复我,我再加进去。 1:使用一个全局单例对象作为交互对象的中介; 在这种交互方式中,有三个对象参加进来。 类1:ClassA;             //用来创建交互对象1:obj1 类2:Clas

Mage的专栏 1万+

0基础学习diffusion_model扩散模型【易理解的公式推导】Denoising Diffusion Probabilistic Models

去噪扩散概率模型。本文是笔者在学习扩散模型时的一些笔记与心得,在公式推导过程中能够保证自己是一步一步去推导并且理解了的。概述是我认为比较重要的部分能够帮助理解公式的推导,具体的公式推导在每一小节中进行。1、扩散过程:如上图所示,扩散过程为从右到左X0→XTX0​→XT​的过程,表示对图片逐渐加噪,且Xt1X_{t+1}Xt1​是在XtX_{t}Xt​加躁得到的,其只受XtX_{t}Xt​的影响,因此扩散过程是一个马尔科夫过程。X0X_0。

zik的博客 2404

C++中建立对象间消息连接的一种系统方法

C++中建立对象间消息连接的一种系统方法  项飞        用过C++进行过面向对象程序设计的用户都知道,程序中的对象很少单独存在。不考虑对象间的相互作用几乎是不可能的。所以,标识对象间的关系或建立对象间的消息连接是面向对象程序设计的一项重要任务。本文着重从C++程序设计的角度,提出一种建立对象间消息连接的实用方法。如果你想详细了解面向对象程序设计技术,请参阅有关专著。大家都知道对象是

iBreathe的专栏 1102

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

消息队列一直建立tcp连接_C++中建立对象间消息连接的一种系统方法

用过C++进行过面向对象程序设计的用户都知道,程序中的对象很少单独存在。不考虑对象间的相互作用几乎是不可能的。所以,标识对象间的关系或建立对象间的消息连接是面向对象程序设计的一项重要任务。本文着重从C++程序设计的角度,提出一种建立对象间消息连接的实用方法。如果你想详细了解面向对象程序设计技术,请参阅有关专著。大家都知道对象是数据和方法的封装体。在C++中,它们分别表现为数据成员和成员函数。程序设...

weixin_39895977的博客 164

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

C++中建立对象间消息连接的一种系统方法——回调函数

用过C++进行过面向对象程序设计的用户都知道,程序中的对象很少单独存在。不考虑对象间的相互作用几乎是不可能的。所以,标识对象间的关系或建立对象间的消息连接是面向对象程序设计的一项重要任务。本文着重从C++程序设计的角度,提出一种建立对象间消息连接的实用方法。如果你想详细了解面向对象程序设计技术,请参阅有关专著。大家都知道对象是数据和方法的封装体。在C++中,它们分别表现为数据成员和成员函数。程序设

静。。。。。。。。。 725

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

上一篇: 韦小宝适合做IT人的8大理由
下一篇: 谈跨平台C++动态连接库的实现
普通网友
博客等级 码龄22年 1万+粉丝 3156原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值