标准C++实现C#代理机制

最新推荐文章于 2020-11-25 23:16:09 发布
最新推荐文章于 2020-11-25 23:16:09 发布
阅读量711 收藏 1
点赞数
分类专栏： C/C++

原文地址：点击打开链接

说明

委托和事件绝对是 .NET/C#中很酷的特性，而在标准C++上已存在很多对其模拟的尝试。本文中基于标准C++的委托类试图提供一个完整并易于使用的解决方案。


设计目标

在CodeProject中已存在几个很好的委托类实现。然而，仍然没有足够完美的方案应对广泛的开始使用。比如，一些实现中并未支持多播委托，一些不支持函数对象，而还有一些实现在应用中难以使用。所以本文的委托类的设计目标为：

*支持所有C++可调用对象，包含静态函数，成员函数以及函数对象。

*在同一个委托类中支持单播和多播委托，使使用者不必自己实现多播代理。（多播委托其调用列表中可以拥有多个元素的委托）

*易于理解与使用。


例子

1、使用委托

#include "AcfDelegate.h"
using namespace Acf;

static void H() { ... }

class Foo {
public:
    void G() { ... }
};

class Foo2 {
public:
    void operator()(int n) { ... }
};

// Create delegate a which attaches to a static function
Delegate<void ()> a(&H);
assert(a == &H);

// Create delegate b which attaches
// to an instance and a member function
Foo foo;
Delegate<void ()> b(&foo, &Foo::G);
assert(b == std::make_pair(&foo, &Foo::G);

// Create delegate c from a
Delegate<void ()> c = a;
assert(c == &H);

// Create delegate d which attaches to a function object
Delegate<void (int)> d(Foo2());

// Call delegates
a();
d(100);

// Combine/remove delegates
d += &H;
d += std::make_pair(&foo, &Foo::G);
d -= std::make_pair(&foo, &Foo::G);
d -= &H;

2、使用事件 

class Button {
public:
    Delegate<void ()> Click;
};

Button btn;
btn.Click += &F;
btn.Click += std::make_pair(&o, &MyObj::G);
btn.Click();
btn.Click -= std::make_pair(&o, &MyObj::G);

3、使用事件（高级）

当你需要更多的管理事件，比如你所关心的线程安全性。

class Button {
private:
    Delegate<void ()> click;
    Mutex mutex;

public:
    template <class T>
    void add_Click(const T& h) {
        ScopedLock lock(this->mutex);
        this->click += h;
    }
    template <class T>
    void remove_Click(const T& h) {
        ScopedLock lock(this->mutex);
        this->click -= h;
    }

protected:
    void OnClick() { if (this->click) this->click(); }
};

btn.add_Click(&F);
btn.add_Click(std::make_pair(&o, &MyObj::G));


委托类 

namespace Acf {

template <class TSignature>
class Delegate; // no body

template <class R, class T1, class T2, ..., class TN>
class Delegate<R (T1, T2, ..., TN)> {
// Constructor/Destructor
public:
    Delegate();
    template <class TFunctor>
    Delegate(const TFunctor& f);
    template <class TPtr, class TFunctionPtr>
    Delegate(const TPtr& obj, const TFunctionPtr& mfp);
    Delegate(const Delegate& d);
    ~Delegate();

// Properties
public:
    bool IsEmpty() const;
    bool IsMulticast() const;

// Methods
public:
    template <class TFunctor>
    void Add(const TFunctor& f);
    template <class TPtr, class TFunctionPtr>
    void Add(const TPtr& obj, const TFunctionPtr& mfp);

    template <class TFunctor>
    bool Remove(const TFunctor& f);
    template <class TPtr, class TFunctionPtr>
    bool Remove(const TPtr& obj, const TFunctionPtr& mfp);

    void Clear();

// Operators
public:
    operator bool() const;
    bool operator!() const;

    template <class TFunctor>
    Delegate& operator=(const TFunctor& f);
    Delegate& operator=(const Delegate& d);

    template <class TFunctor>
    Delegate& operator+=(const TFunctor& f);

    template <class TFunctor>
    friend Delegate operator+(const Delegate& d, const TFunctor& f);
    template <class TFunctor>
    friend Delegate operator+(const TFunctor& f, const Delegate& d);

    template <class TFunctor>
    Delegate& operator-=(const TFunctor& f);

    template <class TFunctor>
    Delegate operator-(const TFunctor& f) const;

    template <class TFunctor>
    friend bool operator==(const Delegate& d, const TFunctor& f);
    template <class TFunctor>
    friend bool operator==(const TFunctor& f, const Delegate& d);

    template <class TFunctor>
    friend bool operator!=(const Delegate& d, const TFunctor& f);
    template <class TFunctor>
    friend bool operator!=(const TFunctor& f, const Delegate& d);

    R operator()(T1, T2, ..., TN) const;
};

} // namespace Acf

委托类中，TFunctor模板参数支持静态函数，成员函数（通过std::pair）以及函数对象等可调用对象。
TPtr模板参数支持普通指针（如Foo*）和智能指针（如boost::shared_ptr<Foo>）.


注意

*在使用委托类的时，必须保证在你工程中支持RTTI

*委托类支持六个函数参数



源代码：

AcfDelegate.h

//-------------------------------------------------------------------------
//
// Copyright (C) 2004-2005 Yingle Jia
//
// Permission to copy, use, modify, sell and distribute this software is 
// granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied warranty, 
// and with no claim as to its suitability for any purpose.
//
// AcfDelegate.h
//

#ifndef __Acf_Delegate__
#define __Acf_Delegate__

#include <stdexcept> // for std::logic_error
#include <utility> // for std::pair

// Macros for template metaprogramming

#define ACF_JOIN(a, b)        ACF_DO_JOIN(a, b)
#define ACF_DO_JOIN(a, b)     ACF_DO_JOIN2(a, b)
#define ACF_DO_JOIN2(a, b)    a##b

#define ACF_MAKE_PARAMS1_0(t)
#define ACF_MAKE_PARAMS1_1(t)    t##1
#define ACF_MAKE_PARAMS1_2(t)    t##1, ##t##2
#define ACF_MAKE_PARAMS1_3(t)    t##1, ##t##2, ##t##3
#define ACF_MAKE_PARAMS1_4(t)    t##1, ##t##2, ##t##3, ##t##4
#define ACF_MAKE_PARAMS1_5(t)    t##1, ##t##2, ##t##3, ##t##4, ##t##5
#define ACF_MAKE_PARAMS1_6(t)    t##1, ##t##2, ##t##3, ##t##4, ##t##5, ##t##6

#define ACF_MAKE_PARAMS2_0(t1, t2)
#define ACF_MAKE_PARAMS2_1(t1, t2)   t1##1 t2##1
#define ACF_MAKE_PARAMS2_2(t1, t2)   t1##1 t2##1, t1##2 t2##2
#define ACF_MAKE_PARAMS2_3(t1, t2)   t1##1 t2##1, t1##2 t2##2, t1##3 t2##3
#define ACF_MAKE_PARAMS2_4(t1, t2)   t1##1 t2##1, t1##2 t2##2, t1##3 t2##3, t1##4 t2##4
#define ACF_MAKE_PARAMS2_5(t1, t2)   t1##1 t2##1, t1##2 t2##2, t1##3 t2##3, t1##4 t2##4, t1##5 t2##5
#define ACF_MAKE_PARAMS2_6(t1, t2)   t1##1 t2##1, t1##2 t2##2, t1##3 t2##3, t1##4 t2##4, t1##5 t2##5, t1##6 t2##6

#define ACF_MAKE_PARAMS1(n, t)         ACF_JOIN(ACF_MAKE_PARAMS1_, n) (t)
#define ACF_MAKE_PARAMS2(n, t1, t2)    ACF_JOIN(ACF_MAKE_PARAMS2_, n) (t1, t2)

namespace Acf {

class InvalidCallException : public std::logic_error
{
public:
    InvalidCallException() : std::logic_error("An empty delegate is called")
    {
    }
};

template <class T>
inline static T _HandleInvalidCall()
{
    throw InvalidCallException();
}

template <>
inline static void _HandleInvalidCall<void>()
{
}

template <class TSignature>
class Delegate; // no body

} // namespace Acf

// Specializations

#define ACF_DELEGATE_NUM_ARGS	0 // Delegate<R ()>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#define ACF_DELEGATE_NUM_ARGS	1 // Delegate<R (T1)>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#define ACF_DELEGATE_NUM_ARGS	2 // Delegate<R (T1, T2)>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#define ACF_DELEGATE_NUM_ARGS	3 // Delegate<R (T1, T2, T3)>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#define ACF_DELEGATE_NUM_ARGS	4 // Delegate<R (T1, T2, T3, T4)>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#define ACF_DELEGATE_NUM_ARGS	5 // Delegate<R (T1, T2, T3, T4, T5)>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#define ACF_DELEGATE_NUM_ARGS	6 // Delegate<R (T1, T2, T3, T4, T5, T6)>
#include "AcfDelegateTemplate.h"
#undef ACF_DELEGATE_NUM_ARGS

#endif // #ifndef __Acf_Delegate__

AcfDelegateTemplate.h 

//-------------------------------------------------------------------------
//
// Copyright (C) 2004-2005 Yingle Jia
//
// Permission to copy, use, modify, sell and distribute this software is 
// granted provided this copyright notice appears in all copies. 
// This software is provided "as is" without express or implied warranty, 
// and with no claim as to its suitability for any purpose.
//
// AcfDelegateTemplate.h
//

// Note: this header is a header template and must NOT have multiple-inclusion
// protection.

#define ACF_DELEGATE_TEMPLATE_PARAMS    ACF_MAKE_PARAMS1(ACF_DELEGATE_NUM_ARGS, class T)
	// class T0, class T1, class T2, ...
#define ACF_DELEGATE_TEMPLATE_ARGS      ACF_MAKE_PARAMS1(ACF_DELEGATE_NUM_ARGS, T)
	// T0, T1, T2, ...
#define ACF_DELEGATE_FUNCTION_PARAMS    ACF_MAKE_PARAMS2(ACF_DELEGATE_NUM_ARGS, T, a)
	// T0 a0, T1 a1, T2 a2, ...
#define ACF_DELEGATE_FUNCTION_ARGS      ACF_MAKE_PARAMS1(ACF_DELEGATE_NUM_ARGS, a)
	// a0, a1, a2, ...

// Comma if nonzero number of arguments
#if ACF_DELEGATE_NUM_ARGS == 0
#define ACF_DELEGATE_COMMA
#else
#define ACF_DELEGATE_COMMA    ,
#endif

namespace Acf {

//-------------------------------------------------------------------------
// class Delegate<R (T1, T2, ..., TN)>

template <class R ACF_DELEGATE_COMMA ACF_DELEGATE_TEMPLATE_PARAMS>
class Delegate<R (ACF_DELEGATE_TEMPLATE_ARGS)>
{
// Declaractions
private:
    class DelegateImplBase
    {
    // Fields
    public:
        DelegateImplBase* Previous; // singly-linked list

    // Constructor/Destructor
    protected:
        DelegateImplBase() : Previous(NULL) { }
        DelegateImplBase(const DelegateImplBase& other) : Previous(NULL) { }
    public:
        virtual ~DelegateImplBase() { }

    // Methods
    public:
        virtual DelegateImplBase* Clone() const = 0;
        virtual R Invoke(ACF_DELEGATE_FUNCTION_PARAMS) const = 0;
    };

    template <class TFunctor>
    struct Invoker
    {
        static R Invoke(const TFunctor& f ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_PARAMS)
        {
            return (const_cast<TFunctor&>(f))(ACF_DELEGATE_FUNCTION_ARGS);
        }
    };

    template <class TPtr, class TFunctionPtr>
    struct Invoker<std::pair<TPtr, TFunctionPtr> >
    {
        static R Invoke(const std::pair<TPtr, TFunctionPtr>& mf ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_PARAMS)
        {
            return ((*mf.first).*mf.second)(ACF_DELEGATE_FUNCTION_ARGS);
        }
    };

    template <class TFunctor>
    class DelegateImpl : public DelegateImplBase
    {
    // Fields
    public:
        TFunctor Functor;

    // Constructor
    public:
        DelegateImpl(const TFunctor& f) : Functor(f)
        {
        }
        DelegateImpl(const DelegateImpl& other) : Functor(other.Functor)
        {
        }

    // Methods
    public:
        virtual DelegateImplBase* Clone() const
        {
            return new DelegateImpl(*this);
        }
        virtual R Invoke(ACF_DELEGATE_FUNCTION_PARAMS) const
        {
            return Invoker<TFunctor>::Invoke(this->Functor ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_ARGS);
        }
    };

// Fields
private:
    DelegateImplBase* _last;

// Constructor/Destructor
public:
    Delegate()
    {
        this->_last = NULL;
    }

    template <class TFunctor>
    Delegate(const TFunctor& f)
    {
        this->_last = NULL;
        *this = f;
    }

	template<class TPtr, class TFunctionPtr>
    Delegate(const TPtr& obj, const TFunctionPtr& mfp)
    {
        this->_last = NULL;
        *this = std::make_pair(obj, mfp);
    }

    Delegate(const Delegate& d)
    {
        this->_last = NULL;
        *this = d;
    }

    ~Delegate()
    {
        Clear();
    }

// Properties
public:
    bool IsEmpty() const
    {
        return (this->_last == NULL);
    }

    bool IsMulticast() const
    {
        return (this->_last != NULL && this->_last->Previous != NULL);
    }

// Static Methods
private:
    static DelegateImplBase* CloneDelegateList(DelegateImplBase* list, /*out*/ DelegateImplBase** first)
    {
        DelegateImplBase* list2 = list;
        DelegateImplBase* newList = NULL;
        DelegateImplBase** pp = &newList;
        DelegateImplBase* temp = NULL;

        try
        {
            while (list2 != NULL)
            {
                temp = list2->Clone();
                *pp = temp;
                pp = &temp->Previous;
                list2 = list2->Previous;
            }
        }
        catch (...)
        {
            FreeDelegateList(newList);
            throw;
        }

        if (first != NULL)
            *first = temp;
        return newList;
    }

    static void FreeDelegateList(DelegateImplBase* list)
    {
        DelegateImplBase* temp = NULL;
        while (list != NULL)
        {
            temp = list->Previous;
            delete list;
            list = temp;
        }
    }

    static void InvokeDelegateList(DelegateImplBase* list ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_PARAMS)
    {
        if (list != NULL)
        {
            if (list->Previous != NULL)
                InvokeDelegateList(list->Previous ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_ARGS);
            list->Invoke(ACF_DELEGATE_FUNCTION_ARGS);
        }
    }

// Methods
public:
    template <class TFunctor>
    void Add(const TFunctor& f)
    {
        DelegateImplBase* d = new DelegateImpl<TFunctor>(f);
        d->Previous = this->_last;
        this->_last = d;
    }

	template<class TPtr, class TFunctionPtr>
    void Add(const TPtr& obj, const TFunctionPtr& mfp)
    {
        DelegateImplBase* d = new DelegateImpl<std::pair<TPtr, TFunctionPtr> >(std::make_pair(obj, mfp));
        d->Previous = this->_last;
        this->_last = d;
    }

    template <class TFunctor>
    bool Remove(const TFunctor& f)
    {
        DelegateImplBase* d = this->_last;
        DelegateImplBase** pp = &this->_last;
        DelegateImpl<TFunctor>* impl = NULL;

        while (d != NULL)
        {
            impl = dynamic_cast<DelegateImpl<TFunctor>*>(d);
            if (impl != NULL && impl->Functor == f)
            {
                *pp = d->Previous;
                delete impl;
                return true;
            }
            pp = &d->Previous;
            d = d->Previous;
        }
        return false;
    }

	template<class TPtr, class TFunctionPtr>
    bool Remove(const TPtr& obj, const TFunctionPtr& mfp)
    {
        return Remove(std::make_pair(obj, mfp));
    }

    void Clear()
    {
        FreeDelegateList(this->_last);
        this->_last = NULL;
    }

private:
    template <class TFunctor>
    bool Equals(const TFunctor& f) const
    {
        if (this->_last == NULL || this->_last->Previous != NULL)
            return false;

        DelegateImpl<TFunctor>* impl = 
            dynamic_cast<DelegateImpl<TFunctor>*>(this->_last);
        if (impl == NULL)
            return false;
        return (impl->Functor == f);
    }

// Operators
public:
    operator bool() const
    {
        return !IsEmpty();
    }

    bool operator!() const
    {
        return IsEmpty();
    }

    template <class TFunctor>
    Delegate& operator=(const TFunctor& f)
    {
        DelegateImplBase* d = new DelegateImpl<TFunctor>(f);
        FreeDelegateList(this->_last);
        this->_last = d;
        return *this;
    }

    Delegate& operator=(const Delegate& d)
    {
        if (this != &d)
        {
            DelegateImplBase* list = CloneDelegateList(d._last, NULL);
            FreeDelegateList(this->_last);
            this->_last = list;
        }
        return *this;
    }

    template <class TFunctor>
    Delegate& operator+=(const TFunctor& f)
    {
        Add(f);
        return *this;
    }

    template <class TFunctor>
    friend Delegate operator+(const Delegate& d, const TFunctor& f)
    {
        return (Delegate(d) += f);
    }

    template <class TFunctor>
    friend Delegate operator+(const TFunctor& f, const Delegate& d)
    {
        return (d + f);
    }

    template <class TFunctor>
    Delegate& operator-=(const TFunctor& f)
    {
        Remove(f);
        return *this;
    }

    template <class TFunctor>
    Delegate operator-(const TFunctor& f) const
    {
        return (Delegate(*this) -= f);
    }

    template <class TFunctor>
    friend bool operator==(const Delegate& d, const TFunctor& f)
    {
        return d.Equals(f);
    }

    template <class TFunctor>
    friend bool operator==(const TFunctor& f, const Delegate& d)
    {
        return (d == f);
    }

    template <class TFunctor>
    friend bool operator!=(const Delegate& d, const TFunctor& f)
    {
        return !(d == f);
    }

    template <class TFunctor>
    friend bool operator!=(const TFunctor& f, const Delegate& d)
    {
        return (d != f);
    }

    R operator()(ACF_DELEGATE_FUNCTION_PARAMS) const
    {
        if (this->_last == NULL)
            return _HandleInvalidCall<R>();

        if (this->_last->Previous != NULL)
            InvokeDelegateList(this->_last->Previous ACF_DELEGATE_COMMA ACF_DELEGATE_FUNCTION_ARGS);
        return this->_last->Invoke(ACF_DELEGATE_FUNCTION_ARGS);
    }
};

} // namespace Acf

#undef ACF_DELEGATE_TEMPLATE_PARAMS
#undef ACF_DELEGATE_TEMPLATE_ARGS
#undef ACF_DELEGATE_FUNCTION_PARAMS
#undef ACF_DELEGATE_FUNCTION_ARGS
#undef ACF_DELEGATE_COMMA

Delegate.cpp 

// Delegate.cpp : Defines the entry point for the console application.
//

#define CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#ifdef _MSC_VER
#include <crtdbg.h>
#endif // #ifdef _MSC_VER

#include "AcfDelegate.h"
using namespace Acf;

static void H(const char* s)
{
    printf("  Static function invoked by %s\n", s);
}

class MyObject
{
public:
    int count;
    MyObject(int n) : count(n) { }

    void G(const char* s)
    {
        printf("  Member function invoked by %s\n", s);
        this->count++;
    }
};

class MyFunctor
{
public:
    void operator()(const char* s)
    {
        printf("  Functor invoked by %s\n", s);
    }
};

int main(int argc, char* argv[])
{
#ifdef _MSC_VER
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif // #ifdef _MSC_VER

    // Create an empty delegate
    printf("Invoking delegate a0:\n");
    Delegate<void ()> a0;
    a0();
    printf("\n");

    // Create delegate a that references a static function:
    Delegate<void (const char*)> a(&H);
    assert(a == &H);

    printf("Invoking delegate a:\n");
    a("a");
    printf("\n");

    // Create delegate b that references an instance function:
    MyObject myObj(0);
    Delegate<void (const char*)> b(&myObj, &MyObject::G);
    assert(b == std::make_pair(&myObj, &MyObject::G));

    printf("Invoking delegate b:\n");
    b("b");
    assert(myObj.count == 1);
    printf("\n");

    // Create delegate c that references a function object:
    MyFunctor myFunctor;
    Delegate<void (const char*)> c(myFunctor);

    printf("Invoking delegate c:\n");
    c("c");
    printf("\n");

    // Add an instance function and a functor to delegate a
    a += std::make_pair(&myObj, &MyObject::G);
    a += MyFunctor();

    printf("Invoking delegate a:\n");
    a("a");
    assert(myObj.count == 2);
    printf("\n");

    // Remove the static function from delegate a
    a -= &H;

    printf("Invoking delegate a:\n");
    a("a");
    assert(myObj.count == 3);
    printf("\n");

    // Create delegate d from a
    Delegate<void (const char*)> d(a);

    // Add delegate b to delegate d
    d += Delegate<void (const char*)>(&H);

    printf("Invoking delegate d:\n");
    d("d");
    assert(myObj.count == 4);
    printf("\n");

    getchar();

    return 0;
}



pre_lc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式——代理模式（C++实现）
萧海的博客
09-03 119
#include <iostream> #include <string> using namespace std; class CSubject { public: virtual void Request() = 0; }; class CRealSubject: public CSubject { public: virtual void Request() { cout<<..
C#中delegate的机制原理
argpunk的专栏
12-24 7447
C#下的关键字delegate实际上是告诉编译器生成一个继承自MulticastDelegate的密封类。而该类的主要职责是创建函数的回调环境。 而生成的密封类定义如下： namespace DefineNameSpace{ public delegate string DefineDelegate(bool a, bool b, bool c); public class Ot
C#事件处理的代理机制
vccodefan1的专栏
11-25 144
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; public delegate void RingEvent(int ringKind); public class SchoolRing { public RingEvent OnBellSound; public void Jow(int ringKind)...
C++实现C#的事件委托功能
hshqing的博客
09-03 548
C++实现C#的事件委托功能 程序代码链接：https://download.csdn.net/download/hshqing/11652704 对于添加函数指针，则可以声明函数指针类型作为参数，定义全局函数，或者静态函数，可以作为委托，如： //静态函数 class ClaseA { public: static int test(int a) { printf("ClaseA...
C#面向对象设计模式纵横谈(13)：Proxy 代理模式(结构型模式)
04-01
C#面向对象设计模式纵横谈(13)：Proxy 代理模式(结构型模式)
C#实现调用C++的dll的工程文件
06-23
2. 创建C#的等效接口：在C#项目中，我们需要定义一个与C++接口匹配的委托类型，这将作为调用DLL函数的代理。同时，创建一个类来封装这些委托，以便在C#代码中更方便地使用。 3. 使用P/Invoke：P/Invoke（Platform ...
DesignPaterns.zip_C#编程_Visual_C++_
08-11
2. 智能指针：如`std::shared_ptr`和`std::unique_ptr`，实现资源的自动管理，符合"资源获取即初始化"（RAII）原则，体现了代理/委托模式。 3. 异常安全：C++通过异常处理机制支持异常安全编程，避免在异常发生时...
C#调用C++ Api或接口转换工具
02-28
这些工具通常会分析C++库的头文件，生成相应的C#代理类或委托，从而减少手动编写P/Invoke或C++/CLI代码的工作量。例如，`C#_API`可能就是一个这样的工具，它能解析C++ API的定义，自动生成C#的调用接口。 使用接口...
C++、C#写的WebService（gsoap）相互调用
03-09
C#开发者可以使用.NET框架提供的wsdl.exe工具，通过WSDL文件生成代理类，从而能够像调用本地服务一样调用C++的Web服务。 - 当复杂类型数据传递失败时，可能是由于gsoap生成的WSDL与.NET默认生成的WSDL格式不一致。...
C++与C#版的设计模式
04-21
在C++中，可以使用STL的信号与槽机制或者自定义事件机制，C#则提供了内置的`event`关键字和委托。观察者模式常用于事件驱动编程和实时系统。 六、装饰器模式 装饰器模式动态地给一个对象添加一些额外的职责，增加...
C#与C++之间DLL文件的创建与调用DEMO演示
05-18
本主题聚焦于如何在C#和C++之间创建和调用DLL（动态链接库）文件，以实现这种交互。DLL是一种共享库，它包含可由多个程序同时使用的函数和资源，有助于减少内存占用和代码重复。 首先，我们需要了解在C++中创建DLL...
c++实现委托
05-29
这个概念在其他语言，如C#和Java中更为常见，但在C++中实现起来需要利用函数指针、成员函数指针或者仿函数等机制。以下我们将详细讨论如何在C++中实现委托，以及给定文件中的相关知识点。 首先，`Hopter.cpp`可能是...
基于c++ muduo网络库的集群聊天服务器，使用nginx实现负载均衡，使用reids消息队列实现跨服务器通信.zip
最新发布
03-08
Nginx作为一款强大的反向代理和负载均衡服务器，能够将客户端请求智能地分发到不同的后端服务器，从而实现服务的负载均衡。Nginx的配置灵活，可以根据服务器的负载情况动态调整策略，确保服务的稳定性和响应速度。在...
C#的COM事件在C++和JAVA中触发和响应的实现
12-13
在C#中定义事件和接口，然后在C++或JAVA中实现这些接口，通过调用相应的方法触发事件，从而实现事件的订阅和响应。这种机制对于构建多语言互操作的系统非常有用，尤其是在需要整合不同开发环境的项目中。
C++、C#写的WebService相互调用
02-22
2. 使用.NET工具wsdl.exe：通过.WSDL文件生成C#代理类，这样C#客户端就能像调用本地方法一样调用C++服务。 3. 复杂类型问题：解决gsoap生成的WSDL与.NET生成的不兼容问题，可能需要手动调整WSDL或使用特定的gsoap...
C++中的delegate机制：现在网上可以找到的解决方案
lphbtm的专栏
08-04 502
C++中的delegate机制：现在网上可以找到的解决方案 (2011-12-28 13:15:51) 转载▼ 标签： 杂谈 分类： linux下编程 说道C++中的delegate机制，在网上已经有很多人给出了自己的实现，我觉得最值得借鉴的有两篇，第一个是Yingle Jiang（蒋迎乐）在CodeProject上面发表的Yet Ano
委派模式delegate
lucky的专栏
03-10 226
https://www.jianshu.com/p/38acf37b1e1f
C++中实现委托（Delegate）
huangwei.pro
11-17 1573
<br />http://blog.huang-wei.com/2010/08/09/c%E4%B8%AD%E5%AE%9E%E7%8E%B0%E5%A7%94%E6%89%98%EF%BC%88delegate%EF%BC%89/<br /> C++中实现委托（Delegate）<br />公司的项目里有用到Don Clugston的FastDelegate，当时只知道是类似boost::function的东西，UI上当watcher用的比较多，所以也没去关注。今天想写个事件触发器时，突然想起这茬子，看来
移动代理服务器MAS短信API 2.2开发指南：C/C++与C#应用详解
移动代理服务器MAS短信API 2.2开发手册是一份详细的技术文档，针对C/C++和C#开发者，由深圳市嘉讯软件有限公司编制于2007年11月。该手册主要介绍了如何利用MAS的短信接入功能在新的或现有系统中集成短信服务。 1. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值