Swift has evolved to become a very versatile and powerful modern programming language. However, at times it may be necessary or beneficial to dig down into the lower layers and interoperate with C or C++ for a variety of reasons. These could include:

The most common case involving interoperation is for Swift to call C/C++ code, and there are two ways to do this. The first should be familiar to anyone who has had to interoperate with Objective-C: bridging headers. For projects that just need to import a few files of C or C++, this solution is likely to be sufficient. With larger projects that utilize a more complex set of C/C++ libraries and code, however, Clang Modules will result in a much better organization of the imported code and avoid piling many header files into the bridging header of the Xcode project. For example, the submodules feature of Clang Modules allows you to organize and import specific features from a library:

Another important consideration is that unlike with bridging headers that import code into the global scope, Clang Modules are imported at the file scope via the import statement just as you would do with import UIKit and others. Clang Modules that contain the C/C++ code are thus only visible to the files they are imported in, which also makes it far clearer where this code is used within a Swift project.

The key piece in creating a module from C/C++ code is a module map file, which maps one or more headers onto the structure of the module it defines. In the following test project, we can see that I've defined two modules: CLib and CppLib (to illustrate interoperation with both C and C++). Each one contains its own module map file, which Clang expects to be named "module.modulemap".

The module map files themselves are very straightforward.

Both module map files define the name of their respective module, the header file containing the interface, and declare that the module should export everything as part of its API.

I’ve written one simple function in each of the header files to illustrate calling them from Swift.

The C header can be used as-is by the module map file as we can see above, but the C++ header needs to be wrapped in a pure C interface:

One last thing is to tell Xcode where to find the modules for importing. In the project's Build Settings, directories containing module map files must be listed under Swift Compiler - Search Paths, Import Paths.

The modules are now ready to be imported into any Swift file that needs to call the C/C++ code.

For more information on Clang Modules, including the Module Map Language and all the various features it provides, see the documentation here.

In some cases, you may need to call Swift from C/C++ code. Usually this involves something UI or OS specific, such as logic in the C/C++ code needing to trigger something UI related (e.g., displaying an alert, file selector, etc.) or perform some OS related function (e.g., getting user/system paths, controlling the idle sleep timer on iOS, etc.). This is accomplished through function pointers in the C/C++ code that define what it needs to delegate to the platform.

Let's take an example of triggering an alert from within C/C++. First, we define a function pointer in C for showing an alert with a single message.

In Swift, we define a function called showAlert that will do the work of displaying an alert using the iOS SDK. This function is assigned to the showAlertFunc function pointer declared in CLib from within viewDidLoad. For this to work, the Swift function must be able to be converted to the C calling convention. In other words, it must be either a non-generic global function, a local function that doesn't capture any variables, or a closure that doesn't capture any local variables.

Furthermore, the Swift function's signature must match that of the function pointer in C, and this can sometimes be a bit tricky depending on the types involved. The show alert function pointer in our example returns nothing and takes a single parameter of type const char *. The way pointers are handled when mapping from C to Swift is by UnsafeMutablePointer <Type> for regular pointers or UnsafePointer <Type> for const-declared pointers. In our case, const char* maps to UnsafePointer <Int8>? Additionally, void pointers map to UnsafeMutableRawPointer, while incomplete or unknown types map to OpaquePointer. Primitive types are straightforward, with int mapping to Int32, float maps to Float, etc. For a more complete listing of type mappings, see Apple's documentation here.

For this example, the alert will be triggered by a button tap, so we define a function that will respond to the event in our View Controller, which then calls the C function that ends up triggering the alert.

Now, when we run the app and tap the button, the code in CLib triggers the alert we show from Swift:

Interoperation with C/C++ from Swift can open up powerful and flexible possibilities. C and C++ have been around for decades and have a myriad of valuable libraries available for use. They also provide the control and low-level access required for performance critical code and can be an alternative to higher level frameworks for certain ross-platform development needs.

Need help with custom app development in Vancouver? Then contact Atimi today.