C++中调用OC代码

前言

　　最近项目中为了方便维护，底层统一使用C++编写。由于是项目是做屏幕共享sdk，所以只能底层的压缩、编解码使用C++，屏幕捕获部分Mac和win就自己实现了。那么问题就来了，因为是面向接口编程，所以项目的入口都是c++来写的，而屏幕捕获是需要oc部分的代码，就需要C++调用oc代码了。

准备

之前只做过OC调动C++，于是Google了一下，在Stack Overflow上找到了这个回答。要看具体描述的可以去链接看看，实现思路一共有两种，我在这里大概描述一下。第一种，由于C++是不能直接调用OC的，所以需要通过C语言作为中间层，即C++调用C，C调用OC，这样就达到了C++调用OC的目的。第二种OC是可以调用C++的，通过在外部声名C++类，然后类具体实现放在OC类中，这样C++类就能够调用OC类了，其他需要调用OC的类，只需要调用外部声名的类即可。

实现

具体的实现方式有两种，第一种是C语言方法接收oc对象指针和参数，然后把指针桥接为具体的oc对象。第二种是用C++进行包装，先声名一个C++类，这里称为A。然后在OC类中，这里称为B，对A进行实现，因为这个实现实在OC语言里的，所以在这里是可以直接调用OC代码的。接下来声名一个C++类C。类C通过持有类A来调用OC类B，即A（C++）->C（C++）->B(OC类)

实现方式一 by C

MyObject-C-Interface.h

int MyObjectDoSomethingWith (void *myObjectInstance, void *parameter);

MyObject.h

1. @interface MyObject : NSObject

2. {

3. int someVar;

4. }

6. - (int)doSomethingWith:(void *)aParameter;

7. @end

MyObject.mm

1. @implementation MyObject

3. int MyObjectDoSomethingWith (void *self, void *aParameter)

4. {

5. // 通过将self指针桥接为oc 对象来调用oc方法

6. return [(__bridge id)self doSomethingWith:aParameter];

7. }

9. - (int) doSomethingWith:(void *) aParameter

10. {

11. //将void *指针强转为对应的类型

12. int* param = (int *)aParameter;

13. return *param / 2 ;

14. }

16. - (void)dealloc

17. {

18. NSLog(@"%s", __func__);

19. }

21. @end

MyCPPClass.h

1. class MyCPPClass {

4. public:

5. MyCPPClass();

6. ~MyCPPClass();

7. int someMethod (void *objectiveCObject, void *aParameter);

8. void *self;

10. void setSelf(void *self);

11. };

MyCPPClass.cpp

1. #include "MyObject-C-Interface.h"

3. MyCPPClass::MyCPPClass()

4. {

6. }

8. MyCPPClass::~MyCPPClass()

9. {

11. }

14. int MyCPPClass::someMethod (void *objectiveCObject, void *aParameter)

15. {

16. // To invoke an Objective-C method from C++, use

17. // the C trampoline function

18. return MyObjectDoSomethingWith (objectiveCObject, aParameter);

19. }

21. void MyCPPClass::setSelf(void *aSelf)

22. {

23. self = aSelf;

24. }

main.mm

1. #include "MyCPPClass.hpp"

2. #import "MyObject.h"

4. int main(int argc, const char * argv[]) {

5. @autoreleasepool {

6. // insert code here...

7. NSLog(@"Hello, World!");

8. MyObject *object = [[MyObject alloc] init];

9. MyCPPClass *c = new MyCPPClass();

10. c->setSelf((__bridge void *)object);

11. int a = 12;

12. int result = c->someMethod((__bridge void *)object, &a);

13. NSLog(@"%d", result);

14. }

15. return 0;

16. }

运行结果如下：

存在的问题

在每次C++调用时都需要传递OC对象桥接为==void *==的指针，使用起来很不方便。

方式二 by C++ IMPL

MyObject-C-Interface.h

1. #ifndef MyObject_C_Interface_h__h

2. #define MyObject_C_Interface_h__h

4. class MyClassImpl

5. {

6. public:

7. MyClassImpl ( void );

8. ~MyClassImpl( void );

10. void init( void );

11. int doSomethingWith( void * aParameter );

12. void logMyMessage( char * aCStr );

14. private:

15. void * self;

16. };

18. #endif /* MyObject_C_Interface_h__h */

需要注意的是，==MyClassImpl==的实现是放在OC中的
MyObject.h

1. NS_ASSUME_NONNULL_BEGIN

3. @interface MyObject : NSObject

4. {

5. int someVar;

6. }

8. - (int) doSomethingWith:(void *) aParameter;

9. - (void) logMyMessage:(char *) aCStr;

12. @end

14. NS_ASSUME_NONNULL_END

MyObject.mm

1. #include "MyObject-C-Interface.h"

3. typedef void(^RetainSelfBlock)(void);

5. @implementation MyObject

6. {

7. RetainSelfBlock _retainBlock;//通过这个block持有对象，造成循环引用，避免被释放

8. }

9. MyClassImpl::MyClassImpl( void )

10. : self( NULL )

11. {

13. }

15. MyClassImpl::~MyClassImpl( void )

16. {

17. [(__bridge id) self breakRetainCycly];

18. }

20. void MyClassImpl::init( void )

21. {

22. MyObject *object = [[MyObject alloc] init];

23. object->_retainBlock = ^{//循环引用

24. [object class];

25. };

27. self = (__bridge void *)object;

29. NSLog(@"%p", self);

30. }

32. int MyClassImpl::doSomethingWith( void *aParameter )

33. {

34. NSLog(@"%p", self);

35. return [(__bridge id)self doSomethingWith:aParameter];

36. }

38. void MyClassImpl::logMyMessage( char *aCStr )

39. {

40. [(__bridge id)self logMyMessage:aCStr];

41. }

43. - (int) doSomethingWith:(void *) aParameter

44. {

45. int result = 0;

47. // ... some code to calculate the result

49. return result;

50. }

52. - (void) logMyMessage:(char *) aCStr

53. {

54. NSLog( @"%s", aCStr );

55. }

57. //打破循环引用，释放对象

58. - (void) breakRetainCycly

59. {

60. _retainBlock = nil;

61. }

63. - (void)dealloc

64. {

65. NSLog(@"%s", __func__);

66. }

67. @end

在==MyObject.mm==中需要注意的是，由于OC是使用ARC来进行内存管理的，C++不能够管理OC对象的生命周期。在默认的情况下，临时变量会在autorelease pool每一次pop后被释放，所以在oc实现中要想对象不被释放，那就需要循环引用来帮忙了。

具体代码如下,在MyClassImpl初始化时，利用循环引用保证object不被释放，在MyClassImpl调用析构函数时，将block置空，打破循环引用，以此来释放oc对象

1. void MyClassImpl::init( void )

2. {

3. MyObject *object = [[MyObject alloc] init];

4. object->_retainBlock = ^{//循环引用

5. [object class];

6. };

8. self = (__bridge void *)object;

10. NSLog(@"%p", self);

11. }

13. MyClassImpl::~MyClassImpl( void )

14. {

15. [(__bridge id) self breakRetainCycly];

16. }

18. //打破循环引用，释放对象

19. - (void) breakRetainCycly

20. {

21. _retainBlock = nil;

22. }

MyCPPClass.hpp

1. #ifndef MyCPPClass_hpp

2. #define MyCPPClass_hpp

4. #include <stdio.h>

6. class MyClassImpl;

8. class MyCPPClass

9. {

10. enum { cANSWER_TO_LIFE_THE_UNIVERSE_AND_EVERYTHING = 42 };

11. public:

12. MyCPPClass ( void );

13. ~MyCPPClass( void );

15. void init( void );

16. void doSomethingWithMyClass( void );

18. private:

19. MyClassImpl * _impl;

20. int _myValue;

21. };

24. #endif /* MyCPPClass_hpp */

MyCPPClass.cpp

1. #include "MyCPPClass.hpp"

2. #include "MyObject-C-Interface.h"

4. MyCPPClass::MyCPPClass( void )

5. : _impl ( NULL )

6. { }

8. void MyCPPClass::init( void )

9. {

10. _impl = new MyClassImpl();

11. _impl->init();

12. }

14. MyCPPClass::~MyCPPClass( void )

15. {

16. if ( _impl ) { delete _impl; _impl = NULL; }

17. }

19. void MyCPPClass::doSomethingWithMyClass( void )

20. {

21. int result = _impl->doSomethingWith(&_myValue);

22. if ( result == cANSWER_TO_LIFE_THE_UNIVERSE_AND_EVERYTHING )

23. {

24. _impl->logMyMessage("Hello, Arthur!");

25. }

26. else

27. {

28. _impl->logMyMessage("Don't worry.");

29. }

30. }

main.mm

1. #include "MyCPPClass.hpp"

3. int main(int argc, const char * argv[]) {

4. @autoreleasepool {

5. MyCPPClass *temp = new MyCPPClass();

6. temp->init();

7. temp->doSomethingWithMyClass();

8. delete temp;

9. }

10. return 0;

11. }

运行结果

总结

第一种通过C语言的方式来调用，使用起来更复杂，所以建议使用C++的方式来实现。需要注意的问题是C++不能管理OC对象的释放，所以需要利用循环引用。

你可以在这里下载demo

参考：Calling Objective-C method from C++ member function? - Stack Overflow