Classes written in C # using C ++

Currently, vs. Net occupies the vast majority of application development in windows. Therefore, many people engaged in VC ++ development have switched to more powerful vs. net. In this case, many developers are faced with the issue of using C ++ developed classes in C. The following describes in detail how to encapsulate a C ++ class with managed C ++ to provide it to C.
For example, there is a project named nativecppdll compiled by C ++, which outputs a cperson class. The specific code is as follows:

1. // Nativecppdll. h
3. # Pragma once
5. # Ifndef lx_dll_class_exports
6. # Define lx_dll_class _ declspec (dllexport)
7. # Else
8. # Define lx_dll_class _ declspec (dllimport)
9. # Endif
11. Class lx_dll_class cperson
12. {
13. Public:
14. Cperson ();
15. Cperson (const wchar_t * pname, const wchar_t csex, int iage );
17. Void setname (const wchar_t * pname );
18. Wchar_t * getname ();
20. Void setsex (const wchar_t csex );
21. Wchar_t getsex ();
23. Void setage (INT iage );
24. Int getage ();
26. Wchar_t * getlasterror ();
28. PRIVATE:
29. Wchar_t m_szname [128];
30. Wchar_t m_csex;
31. Int m_iage;
32. Wchar_t m_szlasterror [128];
34. Void showerror ();
35. };
37. // Nativecppdll. cpp
39. # Include "stdafx. H"
41. # Include "nativecppdll. H"
42. # Include <iostream>
43. # Include <tchar. h>
45. Using namespace STD;
47. Cperson: cperson ()
48. {
49. Wcscpy_s (m_szname, _ T ("No Name "));
50. M_csex = 'n ';
51. M_iage = 0;
53. Wcscpy_s (m_szlasterror, _ T ("no error "));
54. }
56. Cperson: cperson (const wchar_t * pname, const wchar_t csex, int iage)
57. {
58. Wcscpy_s (m_szlasterror, _ T ("no error "));
60. Setname (pname );
61. Setsex (csex );
62. Setage (iage );
63. }
65. Void cperson: setname (const wchar_t * pname)
66. {
67. If (pname = NULL) | (wcslen (pname) = 0) | (wcslen (pname)> 127 ))
68. {
69. Wcscpy_s (m_szname, _ T ("No Name "));
71. Wcscpy_s (m_szlasterror, _ T ("the length of the input name is out of range ."));
73. Showerror ();
75. Return;
76. }
78. Wcscpy_s (m_szname, pname );
79. }
81. Wchar_t * cperson: getname ()
82. {
83. Return m_szname;
84. }
86. Void cperson: setsex (const wchar_t csex)
87. {
88. If (csex! = 'F') & (csex! = 'M') & (csex! = 'M') & (csex! = 'F '))
89. {
90. M_csex = 'n ';
92. Wcscpy_s (m_szlasterror, _ T ("the input sex is out of [F/M].");
94. Showerror ();
96. Return;
97. }
99. M_csex = csex;
100. }
102. Wchar_t cperson: getsex ()
103. {
104. Return m_csex;
105. }
107. Void cperson: setage (INT iage)
108. {
109. If (iage <0) | (iage> 150 ))
110. {
111. M_iage = 0;
113. Wcscpy_s (m_szlasterror, _ T ("the input age is out of range ."));
115. Showerror ();
117. Return;
118. }
120. M_iage = iage;
121. }
123. Int cperson: getage ()
124. {
125. Return m_iage;
126. }
128. Wchar_t * cperson: getlasterror ()
129. {
130. Return m_szlasterror;
131. }
133. Void cperson: showerror ()
134. {
135. Cerr <m_szlasterror <Endl;
136. }

This is a typical DLL developed by C ++ and outputs a complete C ++ class. What should I do if I want to develop a C # project and use the C ++ class cperson output from this DLL? For this example, cperson class is very small. You can use C # to re-write a class that is the same as the C ++ class. However, if the required C ++ class is large, or in many cases, the rewrite project will be very large. In this way, existing code is not reused, which wastes existing resources and is time-consuming and labor-intensive for development.
Of course, there are still ways to solve this problem. It is to encapsulate the C ++ class with managed C ++, and then provide it to C # for use. The following code is used to describe how to use hosted C ++ to encapsulate the above C ++ class.
First, create a DLL project managecppdll that hosts C ++, and add the following code to it:

1. // Managecppdll. h
3. # Pragma once
4. # Define lx_dll_class_exports
6. # Include "../nativecppdll. H"
8. Using namespace system;
10. Namespace managecppdll
11. {
12. Public ref class person
13. {
14. // Wrap all public member functions of cperson class
15. Public:
16. Person ();
17. Person (string ^ strname, char csex, int iage );
19. ~ Person ();
21. Property string ^ name
22. {
23. Void set (string ^ strname );
24. String ^ get ();
25. }
27. Property char sex
28. {
29. Void set (char csex );
30. Char get ();
31. }
33. Property int age
34. {
35. Void set (INT iage );
36. Int get ();
37. }
39. String ^ getlasterror ();
41. PRIVATE:
42. // The pointer of the class cperson, used to call the member functions of the class cperson
43. Cperson * m_pimp;
44. };
45. };

From this header file, we can see that this is the packaging of C ++ class cperson. All public member functions of the class person are the same as those of the C ++ class cperson, except that the parameters and return values of the member functions are changed to the type that hosts C ++, this is also the first condition for class person to be used in C. Of course, you only need to encapsulate public member functions, and do not need to encapsulate them to protect Member functions and private member functions.
Class person only has one private member variable: a pointer to class cperson. The implementation of all member functions of the person class relies on the cperson pointer to call the corresponding member functions of the cperson class.
The specific implementation code is as follows:

1. // Managecppdll. cpp
3. # Include "stdafx. H"
5. # Include "managecppdll. H"
6. # Include <vcclr. h>
8. Namespace managecppdll
9. {
10. // Create a cperson-like object in the constructor and destroy the object in the destructor
11. // All member functions are implemented by using the m_pimp pointer to call the corresponding member functions of the cperson class.
13. Person: Person ()
14. {
15. M_pimp = new cperson ();
16. }
18. Person: Person (string ^ strname, char csex, int iage)
19. {
20. // Convert string to a pointer that can be recognized by C ++
21. Pin_ptr <const wchar_t> wcname = ptrtostringchars (strname );
23. M_pimp = new cperson (wcname, csex, iage );
24. }
26. Person ::~ Person ()
27. {
28. // Delete the cperson object in the destructor
29. Delete m_pimp;
30. }
32. Void person: Name: Set (string ^ strname)
33. {
34. Pin_ptr <const wchar_t> wcname = ptrtostringchars (strname );
36. M_pimp-> setname (wcname );
37. }
39. String ^ person: Name: Get ()
40. {
41. Return gcnew string (m_pimp-> getname ());
42. }
44. Void person: Sex: Set (char csex)
45. {
46. M_pimp-> setsex (csex );
47. }
49. Char person: Sex: Get ()
50. {
51. Return m_pimp-> getsex ();
52. }
54. Void person: Age: Set (INT iage)
55. {
56. M_pimp-> setage (iage );
57. }
59. Int person: Age: Get ()
60. {
61. Return m_pimp-> getage ();
62. }
64. String ^ person: getlasterror ()
65. {
66. Return gcnew string (m_pimp-> getlasterror ());
67. }
68. };

If you want to use the class person in C #, first Add a reference to managecppdll. dll, and then you can use the class person like a common class C. For example, the following code:

1. Using managecppdll;
3. Person = new person ();
5. Person. Name = "starlee ";
6. Person. Sex = 'M ';
7. Person. Age = 28;

If you are familiar with the design pattern, you will surely find that such a design is exactly the same as the bridge pattern. In fact, the above method is also a bridge mode, where the hosted C ++ serves as a bridge between classes used for C # development. In addition, this form can also be understood as the adapter mode. Hosting a C ++ class person is an adapter of the C ++ class cperson. Through this bridge, you can easily reuse the classes previously developed using C ++, so that these C ++ classes can continue to play their role in C #, making development more efficient.