Vous pouvez mélanger C ++ avec Objective-C si vous le faites soigneusement. Il y a quelques mises en garde, mais d'une manière générale, elles peuvent être mélangées. Si vous souhaitez les garder séparés, vous pouvez configurer une fonction d'encapsulation C standard qui donne à l'objet Objective-C une interface de style C utilisable à partir de code non-Objective-C (choisissez de meilleurs noms pour vos fichiers, j'ai choisi ces noms pour la verbosité):
MyObject-C-Interface.h
#ifndef __MYOBJECT_C_INTERFACE_H__
#define __MYOBJECT_C_INTERFACE_H__
// This is the C "trampoline" function that will be used
// to invoke a specific Objective-C method FROM C++
int MyObjectDoSomethingWith (void *myObjectInstance, void *parameter);
#endif
MyObject.h
#import "MyObject-C-Interface.h"
// An Objective-C class that needs to be accessed from C++
@interface MyObject : NSObject
{
int someVar;
}
// The Objective-C member function you want to call from C++
- (int) doSomethingWith:(void *) aParameter;
@end
MonObjet.mm
#import "MyObject.h"
@implementation MyObject
// C "trampoline" function to invoke Objective-C method
int MyObjectDoSomethingWith (void *self, void *aParameter)
{
// Call the Objective-C method using Objective-C syntax
return [(id) self doSomethingWith:aParameter];
}
- (int) doSomethingWith:(void *) aParameter
{
// The Objective-C function you wanted to call from C++.
// do work here..
return 21 ; // half of 42
}
@end
MyCPPClass.cpp
#include "MyCPPClass.h"
#include "MyObject-C-Interface.h"
int MyCPPClass::someMethod (void *objectiveCObject, void *aParameter)
{
// To invoke an Objective-C method from C++, use
// the C trampoline function
return MyObjectDoSomethingWith (objectiveCObject, aParameter);
}
La fonction wrapper n'a pas besoin d'être dans le même .mfichier que la classe Objective-C, mais le fichier dans lequel elle existe doit être compilé en tant que code Objective-C . L'en-tête qui déclare la fonction wrapper doit être inclus dans le code CPP et Objective-C.
(NOTE: si le fichier d'implémentation Objective-C est doté de l'extension ".m", il ne sera pas lié sous Xcode. L'extension ".mm" indique à Xcode d'attendre une combinaison d'Objective-C et de C ++, c'est-à-dire Objective-C ++. )
Vous pouvez implémenter ce qui précède d'une manière orientée objet en utilisant l' idiome PIMPL . La mise en œuvre n'est que légèrement différente. En bref, vous placez les fonctions wrapper (déclarées dans "MyObject-C-Interface.h") à l'intérieur d'une classe avec un pointeur void (privé) vers une instance de MyClass.
MyObject-C-Interface.h (PIMPL)
#ifndef __MYOBJECT_C_INTERFACE_H__
#define __MYOBJECT_C_INTERFACE_H__
class MyClassImpl
{
public:
MyClassImpl ( void );
~MyClassImpl( void );
void init( void );
int doSomethingWith( void * aParameter );
void logMyMessage( char * aCStr );
private:
void * self;
};
#endif
Notez que les méthodes wrapper ne nécessitent plus le pointeur void vers une instance de MyClass; c'est maintenant un membre privé de MyClassImpl. La méthode init est utilisée pour instancier une instance MyClass;
MonObjet.h (PIMPL)
#import "MyObject-C-Interface.h"
@interface MyObject : NSObject
{
int someVar;
}
- (int) doSomethingWith:(void *) aParameter;
- (void) logMyMessage:(char *) aCStr;
@end
MonObjet.mm (PIMPL)
#import "MyObject.h"
@implementation MyObject
MyClassImpl::MyClassImpl( void )
: self( NULL )
{ }
MyClassImpl::~MyClassImpl( void )
{
[(id)self dealloc];
}
void MyClassImpl::init( void )
{
self = [[MyObject alloc] init];
}
int MyClassImpl::doSomethingWith( void *aParameter )
{
return [(id)self doSomethingWith:aParameter];
}
void MyClassImpl::logMyMessage( char *aCStr )
{
[(id)self doLogMessage:aCStr];
}
- (int) doSomethingWith:(void *) aParameter
{
int result;
// ... some code to calculate the result
return result;
}
- (void) logMyMessage:(char *) aCStr
{
NSLog( aCStr );
}
@end
Notez que MyClass est instancié avec un appel à MyClassImpl :: init. Vous pouvez instancier MyClass dans le constructeur de MyClassImpl, mais ce n'est généralement pas une bonne idée. L'instance MyClass est détruite du destructeur de MyClassImpl. Comme pour l'implémentation de style C, les méthodes wrapper se réfèrent simplement aux méthodes respectives de MyClass.
MyCPPClass.h (PIMPL)
#ifndef __MYCPP_CLASS_H__
#define __MYCPP_CLASS_H__
class MyClassImpl;
class MyCPPClass
{
enum { cANSWER_TO_LIFE_THE_UNIVERSE_AND_EVERYTHING = 42 };
public:
MyCPPClass ( void );
~MyCPPClass( void );
void init( void );
void doSomethingWithMyClass( void );
private:
MyClassImpl * _impl;
int _myValue;
};
#endif
MyCPPClass.cpp (PIMPL)
#include "MyCPPClass.h"
#include "MyObject-C-Interface.h"
MyCPPClass::MyCPPClass( void )
: _impl ( NULL )
{ }
void MyCPPClass::init( void )
{
_impl = new MyClassImpl();
}
MyCPPClass::~MyCPPClass( void )
{
if ( _impl ) { delete _impl; _impl = NULL; }
}
void MyCPPClass::doSomethingWithMyClass( void )
{
int result = _impl->doSomethingWith( _myValue );
if ( result == cANSWER_TO_LIFE_THE_UNIVERSE_AND_EVERYTHING )
{
_impl->logMyMessage( "Hello, Arthur!" );
}
else
{
_impl->logMyMessage( "Don't worry." );
}
}
Vous accédez désormais aux appels vers MyClass via une implémentation privée de MyClassImpl. Cette approche peut être avantageuse si vous développiez une application portable; vous pouvez simplement échanger l'implémentation de MyClass avec une implémentation spécifique à l'autre plate-forme ... mais honnêtement, s'il s'agit d'une meilleure implémentation est plus une question de goût et de besoins.