Adam Gladstone - C++ Software Interoperability for Windows Programmers: Connecting to C#, R, and Python Clients

At a general level, software interoperability deals with how software components written in one language may be connected to other components written in other languages. More concretely, in C++ Software Interoperability for Windows Programmers we have a specific software ecosystem in mind. We want to connect a C++ codebase (our starting point) to client software written in three different languages: C#, R, and Python. This book has been written for those interested in learning how to build components that connect C++ to these languages and environments.

C++ is the language of choice for developing robust, scalable, and high-performance software. It offers both high-level software design capabilities through object-oriented, generic, and functional features as well as facilities for low-level memory manipulation. However, C++ is often awkward to connect to other languages. In fact, it doesn't communicate particularly well with clients even if these are written in C++. Consider by contrast how easily components written in different .NET languages can be put together and interoperate in different hosting environments. This book deals in a practical way with how C++ software components, specifically static and dynamic-link libraries, can be connected to components written in other languages. The overall aim is to demonstrate how to make the functionality offered by C++ code available to other clients and thereby leverage the power of C++.

This book is about developing the components that connect C++ libraries to client software written in other languages. It is not a book about the most performant or most up-to-date C++ code. These components form a translation or bridging layer and therefore will always have a performance cost. This is not a book about developing new applications. This book is more about how to connect possibly legacy systems with new(er) codebases. It deals with the in-between pieces of software that are not widely covered directly elsewhere. In this book, we are less interested in the specifics of the code itself and more interested in how the code is put together. We use examples from statistics, but these could equally well be from game engine development or quantitative finance. Our focus is on the wrapper components and how they connect to the different client languages.

Broadly speaking, this book looks at two main areas: firstly, the practicalities of building C++ components that target different languages, specifically C#, R, and Python. The main focus here is on the setup and structure of these middle layer components. We cover project types, project setup, and configuration. Secondly, this book is about the usage of frameworks that support interfacing to other languages. We make use of several such frameworks: C++/CLI (C++ adapted for the Common Language Infrastructure) for connecting to C# and the .NET universe, Rcpp to connect to the R language and environment. And lastly, for connecting to Python, we use CPython, Boost.Python, and PyBind. In each case, we will see how the frameworks help in the translation of types between C++ and the target language. We look at the specifics of how types from the C++ universe are converted to and from C#, R, and Python. We also touch on other areas that are important when developing wrapper components. We look at exception handling in the wrapper layer, unit testing, and also debugging. The focus here is on demonstrating in a realistic way some of the fundamental facilities offered by the frameworks.

It is worth emphasizing that there are advantages to developing separate wrapper components that interface with other client languages. From one point of view, legacy systems can be made more available and more open. This in turn improves the lifetime of those systems. And it allows us to retain the original code without having a costly rewrite. From another point of view, we can continue to use high-performance C++ code while at the same time reaping the benefits of perhaps more specialized languages (like R for data analysis) or perhaps languages with a possibly gentler learning curve (like Python). Apart from the benefits of the languages themselves, both R and Python have extensive libraries that support many different types of software development. By writing wrapper components, we can leverage C++ while at the same time taking advantage of what these languages offer.

Chapter introduces the Software Interoperability project. Here, we cover some of the prerequisites. We describe the main features of the project and we give a high-level view of how the different components fit together.

Chapter lays the foundations for the chapters to come. We introduce a simple C++ library of statistical functions that serves as the point of departure for the functionality that we want to expose to other clients. The library is simple enough to be readily understandable. The main focus is not on the (limited) functionality it offers but rather, in a general way, on what we want to expose to clients: built-in types, Standard Library types, and user-defined types. The statistical library is built as both a static library and a dynamic-link library for convenience. Following this, we take a brief look at two C++ clients: a simple console application that uses the static library and a Windows GUI application that uses the dynamic-link library. We see how simple it is to make the functionality available to C++ clients, but at the same time we see that if we want to expose the functionality outside the C++ world, it requires another layer and some different approaches.