Detailed procedures for the definition and implementation of C + + interfaces

1. Definition and implementation of the interface

The so-called interface, which encapsulates the internal implementation details, allows external users to use the interface functionality without needing to know the specifics of the interior. C + +, through the class implementation of object-oriented programming, and in the base class only the declaration of pure virtual function, and then in the derived class implementation of the pure virtual function of the way to implement the interface, different derived classes implement the interface is not the same way to achieve polymorphism. A simple example is now available to illustrate the implementation step (⊙o⊙).

The definition of a class 1.1 interface usually completes the definition of the class interface in the header file/*interfacedefineandrealize.h*/

[CPP]View PlainCopy

2. #ifndef interface_define_and_realize
4. #define Interface_define_and_realize
6. #include <string>
8. Using Std::string;
10. Define Interface
12. Class Person
14. {
16. Public
18. Person (): M_strname ("# # #") //Member list initialization parameters
20. {};
22. Virtual ~person () {};
24. virtual void Eat () =0; People need to eat.
26. virtual void Sleep () =0; People need to sleep
28. virtual void SetName (const string strName) =0; Everyone has a name.
30. virtual String GetName () = 0; //Get name
32. virtual void work () =0; People may have to have a job
34. Private
36. String M_strname;
38. };
40. Implementing interfaces
42. Implementing interfaces is implemented through derived classes, each derived class can obtain different implementations of the same interface according to its own characteristics
44. The so-called polymorphic
46. Class Student: Public person
48. {
50. Public
52. Student (): M_strname ("* * *")
54. {};
56. ~student ()
58. {};
60. void Eat ();
62. void Sleep ();
64. void SetName (const string strName);
66. String GetName ();
68. void work ();
70. Private
72. String M_strname;
74. };
76. #endif

The implementation of the 1.2 interface is usually done in the source file to complete the interface/*interfacedefineandrealize.cpp*/

[CPP]View PlainCopy

2. #include "InterfaceDefineAndRealize.h"
4. #include <iostream>
6. #include <string>
8. Using Std::string;
10. Using Std::cout;
12. Using Std::endl;
16. External implementation of the interface
18. void Student::sleep ()
20. {
22. cout<<"Student sleep."  <<endl;
24. }
26. void Student::eat ()
28. {
30. cout<<"Student eat."  <<endl;
32. }
34. void Student::setname (const string strName)
36. {
38. M_strname=strname;
40. }
42. void Student::work ()
44. {
46. cout<<"student work."  <<endl;
48. }
50. String Student::getname ()
52. {
54. return m_strname;
56. }
58. Functions that need to be exported, that is, interfaces that the user can invoke externally
60. _declspec (dllexport)bool Getpersonobject (void** _rtobject)
62. {
64. person* Pman=null;
66. pman=new Student ();
68. *_rtobject= (void*) Pman;
70. return true;
72. }

The export of the 1.3 interface is usually done in the module definition file/*interfacedefineandrealize.def*/

[CPP]View PlainCopy

1. LIBRARY interfacedefineandrealize
2. Exports
3. Getpersonobject

Create a new project, load the above three files, set the project properties, configure properties--general---Configuration type, select "Dynamic Library. Dlll", generate the available dynamic libraries, If the project name is interfacedefineandrealize (note: The project name must be the same as the name defined in the module definition file after the library, otherwise it will cause an error that the dynamic library cannot be found.) ), the dynamic library and its import library are generated under the current working directory of the project.

2. Invocation of the interface

To be consistent with the usual way to invoke a dynamic library, here are some extra work. Create a new "include" folder and place InterfaceDefineAndRealize.h under this folder, create a new "Lib" folder and place the InterfaceDefineAndRealize.lib file under this folder. New Project Usinginterface, add the source file to implement the function of calling interface.

2.1 Adding an additional include directory for a project

Method 1: Project Properties--Configuration Properties-->c/c++--> general--The add-in directory adds the full path to the Include folder.

Method 2: Project Properties--Configuration Properties-->vc++ Directory--Include the full path of the Include folder in the included directory.

2.2 Adding additional libraries for a project

Method 1: Project Properties--Configuration Properties--linker--general--Additional library directories add the full path to the Lib folder.

Method 2: Project Properties--Configuration Properties-->vc++ Directory--The library directory adds the full path to the Lib folder.

Note: Method 1 in 2.1 corresponds to Method 1 in 2.2, method 2.1 in 2 corresponds to method 2.2 in 2, and cannot be used.

2.3 Adding an import library for a project

Item Properties--Configuration Properties--linker--add InterfaceDefineAndRealize.lib in an additional dependency

2.4 Providing dynamic libraries for projects

Put the generated. dll dynamic library into the debug directory under the project's current directory to prevent errors that are missing from the dynamic library.

2.5 Writing code to implement an interface invocation

[CPP]View PlainCopy

2. #include <iostream>
4. #include "InterfaceDefineAndRealize.h"
6. BOOL _declspec (dllimport) getpersonobject (void** _rtobject);
8. int main ()
10. {
12. person* Person=null;
14. void* Pobj=null;
16. if (Getpersonobject (&pobj))//Call interface
18. {
20. person= (person*) pObj;
22. Person->eat ();
24. Person->sleep ();
26. Person->setname ("Zhang Hui");
28. Std::cout<<person->getname () <<std::endl;
30. Person->work ();
34. if (person!=null)
36. {
38. Delete person;
40. Person=null;
42. }
44. }
46. System ("pause");
48. return 0;
50. }

Note: The above code is only for personal understanding, there may be errors or incorrect description of the place, I hope to give correct, thank you.

Detailed procedures for the definition and implementation of C + + interfaces