如何：定义和使用委托 (C++/CLI)

最新推荐文章于 2026-05-22 11:18:38 发布
转载 最新推荐文章于 2026-05-22 11:18:38 发布 · 1.1w 阅读 · 0

https://technet.microsoft.com/zh-CN/library/c320cx3h.aspx/

如何：定义和使用委托 (C++/CLI)

Visual Studio 2015
 

本文演示如何定义和使用 C++/CLI中的委托。

尽管 .NET Framework 提供大量委托，有时可能需要定义的新委托。

下面的示例定义了名为 MyCallback 的事件委托。调用的事件处理代码函数，这在此新委托是触发时必须为 void 的返回类型并采用 String 引用。

主函数使用由 SomeClass 定义的 MyCallback 实例化委托的静态方法。委托来调用该函数成为重写方法，如下面通过发送“唯一”的字符串委托对象。MyCallback 下，将的附加实例一起链接由委托对象的调用来执行。

// use_delegate.cpp
// compile with: /clr
using namespace System;

ref class SomeClass
{
public:
   static void Func(String^ str)
   {
      Console::WriteLine("static SomeClass::Func - {0}", str);
   }
};

ref class OtherClass
{
public:
   OtherClass( Int32 n ) 
   {
      num = n;
   }

   void Method(String^ str) 
   {
      Console::WriteLine("OtherClass::Method - {0}, num = {1}", 
         str, num);
   }

   Int32 num;
};

delegate void MyCallback(String^ str);

int main( ) 
{
   MyCallback^ callback = gcnew MyCallback(SomeClass::Func);   
   callback("single"); 

   callback += gcnew MyCallback(SomeClass::Func);   

   OtherClass^ f = gcnew OtherClass(99);
   callback += gcnew MyCallback(f, &OtherClass::Method);

   f = gcnew OtherClass(100);
   callback += gcnew MyCallback(f, &OtherClass::Method);

   callback("chained");

   return 0;
}

Output

静态的 SomeClass::Func - 单
- 链接中的静态 SomeClass::Func
- 链接中的静态 SomeClass::Func
- 链接在一起的 OtherClass::Method，数字为 99
- 链接在一起的 OtherClass::Method，数字为 100

下面的代码示例演示如何将与关联委托的值类的成员。

// mcppv2_del_mem_value_class.cpp
// compile with: /clr
using namespace System;
public delegate void MyDel();

value class A {
public:
   void func1() {
      Console::WriteLine("test");
   }
};

int main() {
   A a;
   A^ ah = a;
   MyDel^ f = gcnew MyDel(a, &A::func1);   // implicit box of a
   f();
   MyDel^ f2 = gcnew MyDel(ah, &A::func1);
   f2();
}

Output

测试
测试

- 运算符可用于从多播委托中移除组件委托。

// mcppv2_compose_delegates.cpp
// compile with: /clr
using namespace System;

delegate void MyDelegate(String ^ s);

ref class MyClass {
public:
   static void Hello(String ^ s) {
      Console::WriteLine("Hello, {0}!", s);
   }

   static void Goodbye(String ^ s) {
      Console::WriteLine("  Goodbye, {0}!", s);
   }
};

int main() {

   MyDelegate ^ a = gcnew MyDelegate(MyClass::Hello);
   MyDelegate ^ b = gcnew MyDelegate(MyClass::Goodbye);
   MyDelegate ^ c = a + b;
   MyDelegate ^ d = c - a;

   Console::WriteLine("Invoking delegate a:");
   a("A");
   Console::WriteLine("Invoking delegate b:");
   b("B");
   Console::WriteLine("Invoking delegate c:");
   c("C");
   Console::WriteLine("Invoking delegate d:");
   d("D");
}

Output

调用委托 a:
Hello, A!
调用委托 b:
  Goodbye，B!
调用委托 c:
Hello, C!
  Goodbye，C!
调用委托 d:
  Goodbye，D!

在托管组件可以用函数调用本机函数然后可以调用托管组件委托的成员函数的指针参数的本机函数。

此示例创建将 .dll 的本机函数：

// delegate_to_native_function.cpp
// compile with: /LD
#include < windows.h >
extern "C" {
   __declspec(dllexport)
   void nativeFunction(void (CALLBACK *mgdFunc)(const char* str)) {
      mgdFunc("Call to Managed Function");
   }
}

下一示例使用 .dll 句柄并将委托传递给需要函数指针的本机函数。

// delegate_to_native_function_2.cpp
// compile with: /clr
using namespace System;
using namespace System::Runtime::InteropServices;

delegate void Del(String ^s);
public ref class A {
public:
   void delMember(String ^s) {
      Console::WriteLine(s);
   }
};

[DllImportAttribute("delegate_to_native_function", CharSet=CharSet::Ansi)]
extern "C" void nativeFunction(Del ^d);

int main() {
   A ^a = gcnew A;
   Del ^d = gcnew Del(a, &A::delMember);
   nativeFunction(d);   // Call to native function
}

Output

为托管函数的调用

若要关联委托与本机函数，必须包装在托管类型的本机函数 (通过声明和 PInvoke要调用的函数。

// mcppv2_del_to_umnangd_func.cpp
// compile with: /clr
#pragma unmanaged
extern "C" void printf(const char*, ...);
class A {
public:
   static void func(char* s) {
      printf(s);
   }
};

#pragma managed
public delegate void func(char*); 

ref class B {
   A* ap;

public:
   B(A* ap):ap(ap) {}
   void func(char* s) {
      ap->func(s); 
   }
};

int main() {
   A* a = new A;
   B^ b = gcnew B(a);
   func^ f = gcnew func(b, &B::func);
   f("hello");
   delete a;
}

Output

hello

可以使用无约束的委托传递函数要调用类型的委托实例时调用。

如果要在中的对象集合循环访问由使用 for each，in 关键字和对每个实例，的成员的委托函数未绑定尤其有用。

这是如何，声明、实例化和调用绑定的设置和未绑定的委托：

操作

未绑定的委托

未绑定的委托

Declare

委托签名必须匹配要通过委托调用的函数的签名。

委托签名的第一个参数是 this 类型要调用对象的。

在第一个参数后得到，委托签名必须匹配要通过委托调用的函数的签名。

instantiate

在实例化一限制的委托时，您可以指定该实例函数或全局或静态成员函数。

若要指定函数实例，第一个参数是一成员函数要调用，第二个参数为要调用函数地址类型的实例。

如果要调用全局或静态成员函数中，请将全局函数的名称或静态成员函数的名称。

在实例化一个无约束的委托时，请将传递要调用的函数的地址。

Call

当您调用绑定的一个委托时，请将传递委托签名需要的参数。

和一个绑定的委托相同，但应记住，第一个参数必须为函数包含要调用对象的实例。

此示例演示如何，声明、实例化和调用无约束的委托：

// unbound_delegates.cpp
// compile with: /clr
ref struct A {
   A(){}
   A(int i) : m_i(i) {}
   void Print(int i) { System::Console::WriteLine(m_i + i);}

private:
   int m_i;
};

value struct V {
   void Print() { System::Console::WriteLine(m_i);}
   int m_i;
};

delegate void Delegate1(A^, int i);
delegate void Delegate2(A%, int i);

delegate void Delegate3(interior_ptr<V>);
delegate void Delegate4(V%);

delegate void Delegate5(int i);
delegate void Delegate6();

int main() {
   A^ a1 = gcnew A(1);
   A% a2 = *gcnew A(2);

   Delegate1 ^ Unbound_Delegate1 = gcnew Delegate1(&A::Print);
   // delegate takes a handle
   Unbound_Delegate1(a1, 1);
   Unbound_Delegate1(%a2, 1);

   Delegate2 ^ Unbound_Delegate2 = gcnew Delegate2(&A::Print);
   // delegate takes a tracking reference (must deference the handle)
   Unbound_Delegate2(*a1, 1);
   Unbound_Delegate2(a2, 1);

   // instantiate a bound delegate to an instance member function
   Delegate5 ^ Bound_Del = gcnew Delegate5(a1, &A::Print);
   Bound_Del(1);

   // instantiate value types
   V v1 = {7};
   V v2 = {8};

   Delegate3 ^ Unbound_Delegate3 = gcnew Delegate3(&V::Print);
   Unbound_Delegate3(&v1);
   Unbound_Delegate3(&v2);

   Delegate4 ^ Unbound_Delegate4 = gcnew Delegate4(&V::Print);
   Unbound_Delegate4(v1);
   Unbound_Delegate4(v2);

   Delegate6 ^ Bound_Delegate3 = gcnew Delegate6(v1, &V::Print);
   Bound_Delegate3();
}

Output

2
3
2
3
2
7
8
7
8
7

下一个示例显示如何使用未约束的委托和 for each，in 关键字通过循环访问集合中的对象并对每个实例的成员函数。

// unbound_delegates_2.cpp
// compile with: /clr
using namespace System;

ref class RefClass {
   String^ _Str;

public:
   RefClass( String^ str ) : _Str( str ) {}
   void Print() { Console::Write( _Str ); }
};

delegate void PrintDelegate( RefClass^ );

int main() {
   PrintDelegate^ d = gcnew PrintDelegate( &RefClass::Print );

   array< RefClass^ >^ a = gcnew array<RefClass^>( 10 );

   for ( int i = 0; i < a->Length; ++i )
      a[i] = gcnew RefClass( i.ToString() );

   for each ( RefClass^ R in a )
      d( R );

   Console::WriteLine();
}

此示例创建未约束的委托给属性的访问器函数：

// unbound_delegates_3.cpp
// compile with: /clr
ref struct B {
   property int P1 {
      int get() { return m_i; }
      void set(int i) { m_i = i; }
   }

private:
   int m_i;
};

delegate void DelBSet(B^, int);
delegate int DelBGet(B^);

int main() {
   B^ b = gcnew B;

   DelBSet^ delBSet = gcnew DelBSet(&B::P1::set);
   delBSet(b, 11);

   DelBGet^ delBGet = gcnew DelBGet(&B::P1::get);   
   System::Console::WriteLine(delBGet(b));
}

Output

11

下面的示例演示如何调用多播委托，一个实例限制的，并且的示例是未绑定的。

// unbound_delegates_4.cpp
// compile with: /clr
ref class R {
public:
   R(int i) : m_i(i) {}

   void f(R ^ r) {
      System::Console::WriteLine("in f(R ^ r)");
   }

   void f() {
      System::Console::WriteLine("in f()");
   }

private:
   int m_i;
};

delegate void Del(R ^);

int main() {
   R ^r1 = gcnew R(11);
   R ^r2 = gcnew R(12);

   Del^ d = gcnew Del(r1, &R::f);
   d += gcnew Del(&R::f);
   d(r2);
};

Output

in f(R ^ r) 中
f() 中

下一个示例演示如何创建并调用一个不受约束的泛型委托。

// unbound_delegates_5.cpp
// compile with: /clr
ref struct R {
   R(int i) : m_i(i) {}

   int f(R ^) { return 999; }
   int f() { return m_i + 5; }

   int m_i;
};

value struct V {
   int f(V%) { return 999; }
   int f() { return m_i + 5; } 

   int m_i;
};

generic <typename T>
delegate int Del(T t);

generic <typename T>
delegate int DelV(T% t);


int main() {   
   R^ hr = gcnew R(7);
   System::Console::WriteLine((gcnew Del<R^>(&R::f))(hr));

   V v;
   v.m_i = 9;
   System::Console::WriteLine((gcnew DelV<V >(&V::f))(v) );
}

Output

12
14
潘李亮
关注
C++中实现委托（delegate）
05-06
网上有很多关于C++ delegate机制的文章，但都讲的是函数指针的内容，上周就C++中实现C#的delegate机制的问题研究了好几天，查看了很多相关资料，才解决了问题，现将我写的C++ delegate测试程序贴出来，希望能帮到有需要的人。
自定义委托
09-25
自定义委托类，重写QItemDelegate中的5个函数并用于模型实例.
C++/CLI委托回调
黄腾霄的博客
02-21 1288
我们都习惯了在c#中使用事件，但是c++中没有默认的事件机制，所以在编写c++/cli时，这将是一个令人困扰的问题 在c++中常见的方式是传入一个回调，在特定的时机，通过调用回调函数，执行上层的代码。 这种方式能够解决一部分场景的问题，但是另外一些场景，比如事件的invok列表，责任链模式都不能实现。 另外常见的回调对象，要求一次实现多个回调函数，这样容易将各个业务的处理都聚集在同一个回调对象中...
Windows远程连接神器MobaXterm的SSH密钥登录配置指南（告别密码保存风险）
最新发布
weixin_30879833的博客
05-22 691
本文详细介绍了如何在Windows平台使用MobaXterm配置SSH密钥登录，替代传统的密码保存方式，提升远程连接安全性。内容涵盖密钥生成、服务器部署、MobaXterm会话配置以及故障排除等关键步骤，帮助用户实现免密登录的同时规避安全风险。
c++设计一个委托
qq_33945243的博客
03-24 401
c++设计一个委托
C++ 之 委托模式
wjjontheway的专栏
01-17 838
文章目录成员函数指针使用模板类使用多态 原文地址 成员函数指针 class A{ public: void Func(int){ std::cout << "I am in A" << std::endl; } }; void (A::*pFunc)(int) = &A::Func; 使用模板类 template &
22、C++/CLI中的委托和事件
year5的博客
05-12 646
本文深入探讨了C++/CLI中委托和事件的定义、作用及实际应用场景，包括用户界面交互和异步操作。同时介绍了泛型委托（如Action和Func）、异常处理、多播委托以及异步事件处理等高级用法，并提供了性能优化技巧，帮助开发者构建更加高效和可靠的C++/CLI应用程序。
C++/CLI实例：CLI封装与跨语言互操作实战
weixin_35671843的博客
08-26 1328
本文还有配套的精品资源，点击获取 简介：C++/CLI是微软.NET框架下的编程语言，它提供了C++与.NET Framework的交互能力。本"C++/CLI实例.zip"文件包含了一系列关于C++/CLI的实践案例，旨在帮助初学者理解如何使用C++/CLI进行.NET开发，以及如何进行CLI封装，使得C++代码能够被C#等其他.NET语言调用。通过实践任务，学生将掌握C...
基于C++/CLI实现C#与C++互调过程中的注意事项
HeyLoong的博客
04-27 3990
C++/CLI 是一种特殊的 C++ 语言，它支持在 .NET 平台上进行开发和编译。C++/CLI 可以让开发人员使用 C++ 语言来编写 .NET 应用程序，并且可以直接访问和使用 .NET 框架中的类库。其支持托管代码和非托管代码：C++/CLI 中既可以编写非托管代码，也可以编写托管代码。通过C++/CLI 的委托代码调用C++应用程序（非委托代码），从而生成.NET应用，实现基于C#的访问。其中，每个环节都是利用动态链接库（.dll）交互实现。
【C++】C++/CLI语法大纲，使用 C++ 编写和操作托管代码
weixin_44939430的博客
11-20 1380
C++/CLI 是一种用于在 C++ 和 .NET 环境之间进行互操作的语言扩展，允许开发者使用 C++ 编写和操作托管代码（Managed Code）。
2、C++/CLI与CLI特性深度解析
year5的博客
04-20 557
本文深入解析了C++/CLI中的CLI特性，包括属性、委托和事件、CLI数组、CLI指针、堆栈语义、函数重写、泛型和托管模板等，并详细介绍了混合模式编程的应用场景，如MFC与WinForms的混合、WPF与原生代码的互操作等。通过这些特性和应用场景的讲解，帮助读者更好地掌握C++/CLI在实际开发中的应用。
【精华帖】托管C++/CLI编程：第2部分
Coding life, Coding world, Coding feature.
12-10 1049
本文概述了C++/CLI面向对象编程的其余特性，如继承、接口和多态性。我们将通过在 CLR 执行模型下应用 C++/CLI 语义，详细了解各种控制语句，例如 if、while 和 do-while 构造以及其他不同的循环构造，例如 for 循环和开关构造。除此之外，我们还将面临其他重要概念，例如异常处理、内存管理、委托和泛型。最后，本文演示如何在 CLR 上下文中将本机 C++ 代码的实现与托管 C++/CLI 代码混合使用。
[C++/CLI编程宝典][4]第一个C++/CLI程序
MyHell
04-15 887
一 本次通过一个简单的C++/CLI控制台程序，能使学习者有对C++/CLI程序有个个大概的印象，同时引出一些基本的概念和关键字。下面是程序代码：#include #include // 1 ISOC++public class NativeClass{public: NativeClass(std::string str) { m
C++/CLI
09-04 3478
简介 C++/CLI代表 ISO-C++标准语言的一个动态编程泛型扩展 (dynamic programming paradigm extension)。在原版语言设计 (V1) 中有许多显著的弱点，我们觉得在修订版语言设计 (V2) 中已经修正了这些弱点。本文列举了 V1
把C++/CLI委托传入本地代码
逍遥剑客
10-13 5033
<br />参考: http://resnikb.wordpress.com/2009/05/18/passing-ccli-delegate-to-native-code/<br /> <br />C++/CLI可以直接执行C++, 这个没有问题, 那么反过来呢?<br />比如底层C++进行一项任务, 完成了需要通知上层的C++/CLI, 总不能在上面不停地查询吧?<br />通常这是通过回调来实现的, 说漂亮点就是观察者模式, 说成.net的就是委托.<br />而委托, 本质是就是函数指针. 以前也
C++/CLI问题集锦 FAQ
caowei880123的专栏
01-05 834
C++/CLI中的const literal initonly 友元 C++/CLI中的const Visual C++并不允许在const对象上调用成员函数，除非该成员函数也被声明为const。          C++/CLI托管代码中，无法把任何类型的函数声明为const；但可以把一个对象声明为const；然而由于无法编写const函数，这种const对象也几乎没有办法进行操作。   ...
学习C++/CLI
Star_Mei的专栏
12-02 1122
转自：http://blog.csdn.net/accesine960/article/details/135803 C++/CLI简介如下： 托管的C++(MC++)饱受诟病的一个地方就是语法格式和普通的编程语言差别很大,很多人都评价为: ugly 和  twisted 语法。 因为.net 的基础之一Common Language Infrastructure CLI是提交给了ECM
C#调用C++ DLL方法之C++/CLI(托管C++)
qq_36651243的博客
11-23 998
C++/CLI (C++/Common Language Infrastructure) 是一种用于编写托管代码的语言扩展，它是为了与 .NET Framework 进行互操作而设计的。C++/CLI 是 C++ 的一种方言，它引入了一些新的语法和关键字，以便更好地支持 .NET 类型和垃圾回收。托管C++ (Managed Extensions for C++) 是早期的一种用于编写托管代码的语言扩展，它也是为了与 .NET Framework 进行互操作而设计的。托管C++ 已经被弃用，不再推荐使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值