Steve Lorimer

C++ in spacemacs

2020-06-29T00:00:00+00:00

Two new emacs packages, ‘lsp-mode’ and ‘dap-mode’, have brought the power of Microsoft’s Language Server Protocol and Debug Adapter Protocol to emacs.

This is a guide to getting lsp-mode and dap-mode working in spacemacs for C++.

Spacemacs’ C++ layer supports multiple backends for lsp-mode. We’ll be using clangd, a language server built on clang.

The distro I use in this post is Ubuntu 20.04.

Disclaimer

I wrote this after figuring out how to configure everything, so it’s highly likely I’ve forgotten something or missed a step. Please let me know if this doesn’t work for you.

Dependencies

clang tools

We will be installing our clang tools from the Ubuntu nightly repos provided by llvm.

Add the gpg key and repository config to apt:

$ wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
$ sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
$ sudo apt update

Install the clang tools

$ sudo apt install -y clang-format clang-tidy clang clangd libclang-dev liblldb-11-dev lldb

node

dap-mode leverages the vscode debug adapters which are written in javascript. As such we need to install node

$ sudo apt install nodejs

`lsp-mode`

lsp-mode will run clangd and communicate with it in order to get information about your C++ code.

You need to tell clangd where to find compile_commands.json, the compilation database which describes how your code is compiled, where to find includes etc.

You probably want to do this on a per-project basis, so that different projects with different settings don’t interfere with eachother.

In order to do this you need to add configuration for lsp-clients-clangd-args to your project’s .dir-locals.el

((c++-mode . ((lsp-clients-clangd-args . ("--compile-commands-dir=build"
                                          "--pch-storage=memory"
                                          "--background-index"
                                          "-j=4"
                                          ))
              )))

Here you can see that I’ve added a number of configuration arguments for clangd, the most important being --compile-commands-dir, here specified as a subdirectory build, which is relative to the source tree’s root dir.

The other options I’ve specified are performance related:

--pch-storage=<value> - Storing PCHs in memory increases memory usages, but may improve performance
--background-index    - Index project code in the background and persist index on disk.
-j=<uint>             - Number of async workers used by clangd. Background index also uses this many workers.

`dap-mode`

In order to communicate with gdb and/or lldb, we need to install the vscode debug adapter for gdb and lldb.

M-x dap-gdb-lldb-setup

spacemacs layers

Now we need to configure the lsp, dap and c-c++ layers in our spacemacs config.

dotspacemacs-configuration-layers
'(
  ....
  (lsp :variables
       lsp-restart 'auto-restart) ; if the server exits, just restart it without prompting
  (dap :variables
       dap-enable-ui-controls nil ; don't display the mouse buttons 
       dap-auto-configure-features '(sessions locals breakpoints expressions tooltip)) ; use the auto-configure layout, but no mouse buttons
  (c-c++ :variables
         c-c++-backend 'lsp-clangd)
  ....
  )

Debugging an app

You can add debug configurations for individual apps to your project’s .dir-locals-el file

Here is an example:

((c++-mode . ((dap-debug-template-configurations . (
                                                    ("my_app"
                                                    :type "gdb"
                                                    :target "/home/user/src/build/app/my_app"
                                                    )
                                                    )))))

With that added to your .dir-locals.el you can reload your project so that debug-template is added to dap-mode, and then start debugging:

`SPC d b a`: adds a breakpoint at the current source line
`SPC d d d`: opens a list of debug-templates, select `my_app` and it should start

Embedding python in C++ with pybind11

2016-12-08T00:00:00+00:00

I recently wrote a blog post about embedding python in C++ with boost::python.

In the reddit discussion, several people made reference to pybind11.

The last time I looked at pybind11 it didn’t support embedding, hence me not considering it for the proof of concept.

It was pointed out to me, however, that it is now possible to embed python with pybind11, so I decided to try it out.

I make use of the same C++ classes as in the previous example, with a few minor changes. For an overview of the class hierarchy, please see the previous blog post.

Changes required in the C++ hierarchy

The most notable change was my StrateyInstance class.

In the boost::python example the StrategyServer was taken by reference.

I found that my python springboard class (PyStrategyInstance) was using pass-by-value semantics, leaving me with a reference to garbage. I was unable to figure out how to pass-by-reference. If anyone knows how to do this, please let me know!

As a result I had to change the StrategyInstance constructor to take a StrategyServer pointer.

class StrategyInstance
{
public:
    StrategyInstance(StrategyServer*); // StrategyServer now passed as a pointer
    virtual ~StrategyInstance() = default;

    virtual void eval() = 0;
    virtual void onOrder(const Order&) = 0;

    void sendOrder(const std::string& symbol, Side, int size, double price);

private:
    StrategyServer& _server;
};

Python wrapper for our virtual StrategyInstance

Here the real meat of the changes starts.

As in boost::python, we need to make a springboard class which overrides the pure virtual base class functions, and calls through to the python overload.

The difference, however, is that instead of inheriting from bp::wrapper, we use the PYBIND11_OVERLOAD_XXX macros to call through to python

class PyStrategyInstance final
    : public StrategyInstance
{
    using StrategyInstance::StrategyInstance;

    void eval() override
    {
        PYBIND11_OVERLOAD_PURE(
            void,              // return type
            StrategyInstance,  // super class
            eval               // function name
            );
    }

    void onOrder(const Order& order) override
    {
        PYBIND11_OVERLOAD_PURE_NAME(
            void,              // return type
            StrategyInstance,  // super class
            "on_order",        // python function name
            onOrder,           // function name
            order              // args
            );
    }
};

Exposing the C++ types to python

Creating a module (or plugin in pybind11 parlance) is largely similar to boost::python.

A major difference is the requirement to create a module inside the plugin, and pass that to all the types defined in the plugin, and then we need to return the module’s PyObject* at the end of our plugin definition.

We use PYBIND11_PLUGIN to define our python plugin

PYBIND11_PLUGIN(StrategyFramework)
{
    // we need to create a module
    py::module m("StrategyFramework", "Example strategy framework");

    py::enum_<Side>(m, "Side")
        .value("BUY", BUY)
        .value("SELL", SELL)
        ;

    py::class_<Order>(m, "Order")
        .def_readonly ("symbol",   &Order::symbol)
        .def_readonly ("side",     &Order::side)
        .def_readwrite("size",     &Order::size)
        .def_readwrite("price",    &Order::price)
        .def_readonly ("order_id", &Order::order_id)
        ;

    py::class_<StrategyServer>(m, "StrategyServer")
        ;

    py::class_<StrategyInstance, PyStrategyInstance>(m, "StrategyInstance")
        .def(py::init<StrategyServer*>())
        .def("send_order", &StrategyInstance::sendOrder)
        ;

    // return the module's PyObject*
    return m.ptr();
}

Defining a function which imports a python file as a module

I used the same function I found in the python wiki on boost::python, from the tip on loading a module by path.

What it does is allow us to specify a python file and load it as if we called import module

A notable difference between boost::python and pybind11 is that boost::python dicts can be passed std::string directly in the assignment of a value. In pybind11 you have to use py::cast

You also gave to tell py::eval that you are passing it multiple statements (py::eval<py::eval_statements>(...))

py::object import(const std::string& module, const std::string& path, py::object& globals)
{
    py::dict locals;
    locals["module_name"] = py::cast(module); // have to cast the std::string first
    locals["path"]        = py::cast(path);

    py::eval<py::eval_statements>(            // tell eval we're passing multiple statements
        "import imp\n"
        "new_module = imp.load_module(module_name, open(path), path, ('py', 'U', imp.PY_SOURCE))\n",
        globals,
        locals);

    return locals["new_module"];
}

Initialising our plugin/module

As in the boost::python example, we need to import our module.

In boost::python the BOOST_PYTHON_MODULE macro defines a function void initModuleName() (where ModuleName is the name of the module passed to the macro). We are able to use the libpython C api to initialise our module:

boost::python way:

// this is how we register our python module when using boost::python
PyImport_AppendInittab("StrategyFramework", &initStrategyFramework);

pybind11 way:

In pybind11 the usage is slightly different. pybind11’s PYBIND11_PLUGIN macro defines a function PyObject* pybind11_init() which we can call to initialise our module.

The slightly unfortunate thing with the way pybind11 defines this function is that the name (pybind11_init) is the same for all plugins. This means that if you want to define and/or initialise more than one plugin, you need to define them in separate namespaces, otherwise you’ll violate ODR.

namespace plugin1 
{
    PYBIND11_PLUGIN(Foo)
    {
        static PyObject* pybind11_init(); // defined for us by the macro
    }
}
namespace plugin2
{
    PYBIND11_PLUGIN(Bar)
    {
        static PyObject* pybind11_init(); // defined for us by the macro
    }
}

// initialise both plugins
plugin1::pybind11_init();
plugin2::pybind11_init();

Since I’m only using one plugin I don’t need to do this in my code, so I haven’t bothered putting my plugin into a separate namespace.

Pulling it all together

Here we initialise the python runtime, initialise the python module with our C++ code in it, import the python file which contains our strategy, and then run it

int main()
try
{
    Py_Initialize();
    pybind11_init();

    StrategyServer server;

    py::object main     = py::module::import("__main__");
    py::object globals  = main.attr("__dict__");
    py::object module   = import("strategy", "strategy.py", globals);
    py::object Strategy = module.attr("Strategy");
    py::object strategy = Strategy(&server); // have to pass server as a pointer now

    strategy.attr("eval")();

    return 0;
}
catch(const py::error_already_set&)
{
    std::cerr << ">>> Error! Uncaught exception:\n";
    PyErr_Print();
    return 1;
}

Note here that, as in boost::python, I don’t call Py_Finalize(). In both frameworks, a call to Py_Finalise() results in a segmentation fault.

Define a python strategy

The sample strategy written in python requires no change.

from StrategyFramework import *

class Strategy(StrategyInstance):
    def __init__(self, server):
        StrategyInstance.__init__(self, server)

    def eval(self):
        print "strategy.eval"
        self.send_order("GOOG", Side.BUY, 100, 759.11)

    def on_order(self, o):
        print "order for {} {} {}@{} has order_id={}".format(
            o.symbol, "buy" if o.side == Side.BUY else "sell", o.size, o.price, o.order_id)

Run it!

$ ./strategy 
strategy.eval
sending order to market
order for GOOG buy 100@759.11 has order_id=1

Complete code listing:

Here is the complete code listing which you can use to test out the code yourself

`main.cpp`:

#include <iostream>
#include <pybind11/pybind11.h>
#include <pybind11/eval.h>

enum Side
{
    BUY,
    SELL
};

struct Order
{
    std::string symbol;
    Side        side;
    int         size;
    double      price;
    int         order_id;
};

class StrategyInstance;

class StrategyServer
{
public:
    void sendOrder(StrategyInstance&, const std::string& symbol, Side, int size, double price);
private:
    int _next_order_id = 0;
};

class StrategyInstance
{
public:
    StrategyInstance(StrategyServer*);
    virtual ~StrategyInstance() = default;

    virtual void eval() = 0;
    virtual void onOrder(const Order&) = 0;

    void sendOrder(const std::string& symbol, Side, int size, double price);

private:
    StrategyServer& _server;
};

///////////////////////////////////

void StrategyServer::sendOrder(StrategyInstance& instance, const std::string& symbol, Side side, int size, double price)
{
    // simulate sending an order, receiving an acknowledgement and calling back to the strategy instance

    std::cout << "sending order to market\n";

    Order order { symbol, side, size, price, ++_next_order_id };
    instance.onOrder(order);
}

///////////////////////////////////

StrategyInstance::StrategyInstance(StrategyServer* server)
    : _server(*server)
{
}

void StrategyInstance::sendOrder(const std::string& symbol, Side side, int size, double price)
{
    _server.sendOrder(*this, symbol, side, size, price);
}

////////////////////////////////////

namespace py = pybind11;

class PyStrategyInstance final
    : public StrategyInstance
{
    using StrategyInstance::StrategyInstance;

    void eval() override
    {
        PYBIND11_OVERLOAD_PURE(
            void,              // return type
            StrategyInstance,  // super class
            eval               // function name
            );
    }

    void onOrder(const Order& order) override
    {
        PYBIND11_OVERLOAD_PURE_NAME(
            void,              // return type
            StrategyInstance,  // super class
            "on_order",        // python function name
            onOrder,           // function name
            order              // args
            );
    }
};

PYBIND11_PLUGIN(StrategyFramework)
{
    py::module m("StrategyFramework", "Example strategy framework");

    py::enum_<Side>(m, "Side")
        .value("BUY", BUY)
        .value("SELL", SELL)
        ;

    py::class_<Order>(m, "Order")
        .def_readonly ("symbol",   &Order::symbol)
        .def_readonly ("side",     &Order::side)
        .def_readwrite("size",     &Order::size)
        .def_readwrite("price",    &Order::price)
        .def_readonly ("order_id", &Order::order_id)
        ;

    py::class_<StrategyServer>(m, "StrategyServer")
        ;

    py::class_<StrategyInstance, PyStrategyInstance>(m, "StrategyInstance")
        .def(py::init<StrategyServer*>())
        .def("send_order", &StrategyInstance::sendOrder)
        ;

    return m.ptr();
}

py::object import(const std::string& module, const std::string& path, py::object& globals)
{
    py::dict locals;
    locals["module_name"] = py::cast(module);
    locals["path"]        = py::cast(path);

    py::eval<py::eval_statements>(
        "import imp\n"
        "new_module = imp.load_module(module_name, open(path), path, ('py', 'U', imp.PY_SOURCE))\n",
        globals,
        locals);

    return locals["new_module"];
}

//////////////////////////////////

int main()
try
{
    Py_Initialize();
    pybind11_init();

    StrategyServer server;

    py::object main     = py::module::import("__main__");
    py::object globals  = main.attr("__dict__");
    py::object module   = import("strategy", "strategy.py", globals);
    py::object Strategy = module.attr("Strategy");
    py::object strategy = Strategy(&server);

    strategy.attr("eval")();
    return 0;
}
catch(const py::error_already_set&)
{
    std::cerr << ">>> Error! Uncaught exception:\n";
    PyErr_Print();
    return 1;
}

`strategy.py`:

from StrategyFramework import *

class Strategy(StrategyInstance):
    def __init__(self, server):
        StrategyInstance.__init__(self, server)

    def eval(self):
        print "strategy.eval"
        self.send_order("GOOG", Side.BUY, 100, 759.11)

    def on_order(self, o):
        print "order for {} {} {}@{} has order_id={}".format(
            o.symbol, "buy" if o.side == Side.BUY else "sell", o.size, o.price, o.order_id)

Embedding python in C++ with boost::python

2016-12-06T00:00:00+00:00

We have a low-latency C++ trading framework which allows us to deploy various trading strategies relatively easily.

Most of our traders, however, don’t know C++, which means they are often waiting on IT resource to develop and deploy a new strategy.

A lot of them do know python though, so I wanted to find a way to allow them to write the core logic of their strategies in python, whilst still leveraging our low-latency trading infrastructure

Here is my embedding python in C++ proof-of-concept.

There is nothing new here, but I found existing documentation and tutorials somewhat lacking, hence this blog post.

Step 1: Define the C++ types which represents the trading framework

Side

An enum to represent buying or selling an order

enum Side
{
    BUY,
    SELL
};

Order

A struct with the details of a single order

struct Order
{
    std::string symbol;
    Side        side;
    int         size;
    double      price;
    int         order_id;
};

StrategyServer

A class which provides the trading functionality, such as sending an order

class StrategyServer
{
public:
    void sendOrder(StrategyInstance&, const std::string& symbol, Side, int size, double price);
private:
    int _next_order_id = 0;
};

StrategyInstance

A pure virtual base class which represents a single strategy

Subclasses must override eval(), the entry-point into the strategy. This is where the strategy’s logic is evaluated and orders potentially sent to market.
Subclasses must also override onOrder(const Order&) which is the callback for the resulting order sent to market

class StrategyInstance
{
public:
    StrategyInstance(StrategyServer&);
    virtual ~StrategyInstance() = default;

    // evaluates the strategy's logic
    virtual void eval() = 0;
    
    // callback for an acknowledged order
    virtual void onOrder(const Order&) = 0;

    // asks the StrategyServer to send an order
    void sendOrder(const std::string& symbol, Side, int size, double price); 

private:
    StrategyServer& _server;
};

Step 2: Create a python wrapper for our virtual StrategyInstance

Use boost::python::wrapper to allow a python class to subclass StrategyInstance

The virtual overrides look up the python class’s implementation and call those

class PyStrategyInstance final
    : public StrategyInstance
    , public bp::wrapper<StrategyInstance>
{
    using StrategyInstance::StrategyInstance;

    void eval() override
    {
        // call through to the python class's `eval` method
        get_override("eval")();
    }

    void onOrder(const Order& order) override
    {
        // call through to the python class's `on_order` method
        get_override("on_order")(order);
    }
};

Step 3: Expose these types to python

We use BOOST_PYTHON_MODULE to define a python module containing all these types

BOOST_PYTHON_MODULE(StrategyFramework)
{
    bp::enum_<Side>("Side")
        .value("BUY", BUY)
        .value("SELL", SELL)
        ;

    bp::class_<Order>("Order")
        .def_readonly("symbol",   &Order::symbol)
        .def_readonly("side",     &Order::side)
        .def_readwrite("size",    &Order::size)
        .def_readwrite("price",   &Order::price)
        .def_readonly("order_id", &Order::order_id)
        ;

    bp::class_<StrategyServer>("StrategyServer")
        ;

    bp::class_<PyStrategyInstance, boost::noncopyable>("StrategyInstance", bp::init<StrategyServer&>())
        .def("send_order", &StrategyInstance::sendOrder)
        ;
}

Step 4: define a function which imports a python file as a module

This is taken from the python wiki on boost::python, from the tip on loading a module by path.

What is does is allow us to specify a python file and load it as if we called import module

bp::object import(const std::string& module, const std::string& path, bp::object& globals)
{
    bp::dict locals;
    locals["module_name"] = module;
    locals["path"]        = path;

    bp::exec("import imp\n"
             "new_module = imp.load_module(module_name, open(path), path, ('py', 'U', imp.PY_SOURCE))\n",
             globals,
             locals);
    return locals["new_module"];
}

Step 5: load a python file containing our strategy and execute it

This is where we pull it all together.

We initialise the python runtime, register the python module with our C++ code in it, import the python file which contains our strategy, and then run it

int main()
try
{
    Py_Initialize();
    
    // register the python module we created, so our script can import it
    PyImport_AppendInittab("StrategyFramework", &initStrategyFramework);

    StrategyServer server;

    // import the __main__ module and obtain the globals dict
    bp::object main     = bp::import("__main__");
    bp::object globals  = main.attr("__dict__");
    
    // import our strategy.py file
    bp::object module   = import("strategy", "strategy.py", globals);
    
    // obtain the strategy class and instantiate one
    bp::object Strategy = module.attr("Strategy");
    bp::object strategy = Strategy(server);

    // eval the strategy
    strategy.attr("eval")();

    return 0;
}
catch(const bp::error_already_set&)
{
    std::cerr << ">>> Error! Uncaught exception:\n";
    PyErr_Print();
    return 1;
}

Step 6: define a python strategy

This is the sample strategy written in python.

As a proof of concept, all it does is send an order when the strategy is evaluated.

We print the resulting order we receive in our callback

from StrategyFramework import *

class Strategy(StrategyInstance):
    def __init__(self, server):
        StrategyInstance.__init__(self, server)

    def eval(self):
        print "strategy.eval"
        self.send_order("GOOG", Side.BUY, 100, 759.11)

    def on_order(self, o):
        print "order for {} {} {}@{} has order_id={}".format(
            o.symbol, "buy" if o.side == Side.BUY else "sell", o.size, o.price, o.order_id)

Step 7: run it!

$ ./strategy 
strategy.eval
sending order to market
order for GOOG buy 100@759.11 has order_id=1

Complete code listing:

Here is the complete code listing which you can use to test out the code yourself

`main.cpp`:

#include <iostream>
#include <boost/python.hpp>

enum Side
{
    BUY,
    SELL
};

struct Order
{
    std::string symbol;
    Side        side;
    int         size;
    double      price;
    int         order_id;
};

// forward declaration
class StrategyInstance;

class StrategyServer
{
public:
    void sendOrder(StrategyInstance&, const std::string& symbol, Side, int size, double price);
private:
    int _next_order_id = 0;
};

class StrategyInstance
{
public:
    StrategyInstance(StrategyServer&);
    virtual ~StrategyInstance() = default;

    virtual void eval() = 0;
    virtual void onOrder(const Order&) = 0;

    void sendOrder(const std::string& symbol, Side, int size, double price);

private:
    StrategyServer& _server;
};

///////////////////////////////////

// implementation

void StrategyServer::sendOrder(StrategyInstance& instance, const std::string& symbol, Side side, int size, double price)
{
    // simulate sending an order, receiving an acknowledgement and calling back to the strategy instance

    std::cout << "sending order to market\n";

    Order order { symbol, side, size, price, ++_next_order_id };
    instance.onOrder(order);
}

///////////////////////////////////

StrategyInstance::StrategyInstance(StrategyServer& server)
    : _server(server)
{}

void StrategyInstance::sendOrder(const std::string& symbol, Side side, int size, double price)
{
    _server.sendOrder(*this, symbol, side, size, price);
}

////////////////////////////////////

// export to python 

namespace bp = boost::python;

class PyStrategyInstance final
    : public StrategyInstance
    , public bp::wrapper<StrategyInstance>
{
    using StrategyInstance::StrategyInstance;

    void eval() override
    {
        get_override("eval")();
    }

    void onOrder(const Order& order) override
    {
        get_override("on_order")(order);
    }
};

BOOST_PYTHON_MODULE(StrategyFramework)
{
    bp::enum_<Side>("Side")
        .value("BUY", BUY)
        .value("SELL", SELL)
        ;

    bp::class_<Order>("Order")
        .def_readonly("symbol",   &Order::symbol)
        .def_readonly("side",     &Order::side)
        .def_readwrite("size",    &Order::size)
        .def_readwrite("price",   &Order::price)
        .def_readonly("order_id", &Order::order_id)
        ;

    bp::class_<StrategyServer>("StrategyServer")
        ;

    bp::class_<PyStrategyInstance, boost::noncopyable>("StrategyInstance", bp::init<StrategyServer&>())
        .def("send_order", &StrategyInstance::sendOrder)
        ;
}

bp::object import(const std::string& module, const std::string& path, bp::object& globals)
{
    bp::dict locals;
    locals["module_name"] = module;
    locals["path"]        = path;

    bp::exec("import imp\n"
             "new_module = imp.load_module(module_name, open(path), path, ('py', 'U', imp.PY_SOURCE))\n",
             globals,
             locals);
    return locals["new_module"];
}

//////////////////////////////////

int main()
try
{
    Py_Initialize();
    PyImport_AppendInittab("StrategyFramework", &initStrategyFramework);

    StrategyServer server;

    bp::object main     = bp::import("__main__");
    bp::object globals  = main.attr("__dict__");
    bp::object module   = import("strategy", "strategy.py", globals);
    bp::object Strategy = module.attr("Strategy");
    bp::object strategy = Strategy(server);

    strategy.attr("eval")();

    return 0;
}
catch(const bp::error_already_set&)
{
    std::cerr << ">>> Error! Uncaught exception:\n";
    PyErr_Print();
    return 1;
}

`strategy.py`:

from StrategyFramework import *

class Strategy(StrategyInstance):
    def __init__(self, server):
        StrategyInstance.__init__(self, server)

    def eval(self):
        print "strategy.eval"
        self.send_order("GOOG", Side.BUY, 100, 759.11)

    def on_order(self, o):
        print "order for {} {} {}@{} has order_id={}".format(
            o.symbol, "buy" if o.side == Side.BUY else "sell", o.size, o.price, o.order_id)

C++17 string_view

2016-09-16T00:00:00+00:00

Introduced under proposal n3921, string_view gives us the ability to refer to an existing string in a non-owning way.

Rationale

std::string is the standard way of working with strings in C++, and offers a lot of convenient functionality for working with strings, such as comparison, searching for substrings, concatenating, slicing, etc.

There is a cost to working with strings though, and that is that they own the underlying buffer in which the string of characters is stored. In order to own this buffer, they often require dynamic memory. (Note if the string is small enough it won’t, due to the “small string optimization” or SSO. You can read more here if you are interested.) However, to all intents and purposes, and particularly in generic code, unless you are certain of the length of the input and the length of string your implementation can handle without a dynamic allocation, I would suggest it is good practice to assume the creation of a string will result in a dynamic allocation.

It is important to understand when dynamic memory allocations occur, and whether they are necessary or not. You should always strive not to be “wasteful” with dynamic allocations, and prefer stack allocations when possible. This holds true in particular for performance critical code, as dynamic memory allocations are orders of magnitude slower than stack allocations.

So if std::string is the standard way of working with strings in C++, then why does this matter?

The reason is that there are often times when we want to work with string-like data, and we don’t necessarily want to transform it into a standalone std::string.

For example, the arguments to a C++ application are passed to your main function as an array of c-style character arrays.

int main(int argc, char* argv[])
{
    // argv is an array of char*
}

Perhaps we want to write a function which takes two strings and compares them

bool compare(const std::string& s1, const std::string& s2)
{
    // do some comparisons between s1 and s2
}

What happens if we want to check a string we currently have, str, against a number of string literals?

bool r1 = compare(str, "this is the first test string");
bool r2 = compare(str, "this is the second test string");
bool r3 = compare(str, "this is the third test string");

For each of the calls to compare above, a std::string will be created, a buffer sufficiently large to hold the data will be created in dynamic memory, and the string literal copied into it.

Here we can see that dynamic allocations are occurring when we call compare with a string-literal by overloading the global operator new

#include <iostream>

void* operator new(std::size_t n)
{
    std::cout << "[allocating " << n << " bytes]\n";
    return malloc(n);
}

bool compare(const std::string& s1, const std::string& s2)
{
    if (s1 == s2)
        return true;
    std::cout << '\"' << s1 << "\" does not match \"" << s2 << "\"\n";
    return false;
}

int main()
{
    std::string str = "this is my input string";

    compare(str, "this is the first test string");
    compare(str, "this is the second test string");
    compare(str, "this is the third test string");

    return 0;
}

Build and run:

$ g++ -std=c++11 -Wall -Wextra -Werror main.cpp
$ ./a.out
[allocating 24 bytes]
[allocating 30 bytes]
"this is my input string" does not match "this is the first test string"
[allocating 31 bytes]
"this is my input string" does not match "this is the second test string"
[allocating 30 bytes]
"this is my input string" does not match "this is the third test string"

All of these allocations, just to compare a string?

Of course we could create a second overload which takes C-style strings, but then we lose the benefit of having an O(1) size function.

bool compare(const std::string& s1, const char* s2)
{
    size_t s2_len = strlen(s2); // O(N) complexity
}

Another downside to this is that we now have to manage multiple overloads which ostensibly do the same thing.

What happens if we have another string type, such as Qt’s QString. Do we create a third overload which compares against QStrings?

What happens if we want the first argument to be a C-style string or a QString, now we need multiple overloads for those too.

bool compare(const std::string& s1, const std::string& s2)
bool compare(const std::string& s1, const char* s2)
bool compare(const std::string& s1, const QString& s2)
bool compare(const char* s1, const std::string& s2)
bool compare(const char* s1, const char* s2)
bool compare(const char* s1, const QString& s2)
bool compare(const Qstring& s1, const std::string& s2)
bool compare(const Qstring& s1, const char* s2)
bool compare(const Qstring& s1, const QString& s2)

Clearly the number of overloads could quickly balloon if we decide to go down this path.

String views

Enter string_view, a way to wrap an existing string in a non-owning way.

The likely implementation will consist of just two data members, a pointer to the start of the string and a length.

They are cheap to construct and cheap to copy.

Example:

#include <iostream>
#include <experimental/string_view>

void* operator new(std::size_t n)
{
    std::cout << "[allocating " << n << " bytes]\n";
    return malloc(n);
}

bool compare(std::experimental::string_view s1, std::experimental::string_view s2)
{
    if (s1 == s2)
        return true;
    std::cout << '\"' << s1 << "\" does not match \"" << s2 << "\"\n";
    return false;
}

int main()
{
    std::string str = "this is my input string";

    compare(str, "this is the first test string");
    compare(str, "this is the second test string");
    compare(str, "this is the third test string");

    return 0;
}

Build and run:

$ g++ -std=c++1z -Wall -Wextra -Werror main.cpp
$ ./a.out
[allocating 24 bytes]
"this is my input string" does not match "this is the first test string"
"this is my input string" does not match "this is the second test string"
"this is my input string" does not match "this is the third test string"

You can see there is only a single allocation, when we create our str string. The creation of string_vew from the literals does not require a dynamic allocation.

Note: You can see I’m using string_view in the experimental namespace, as the version of gcc I’m using hasn’t yet moved string_view into its C++17 location (ie: out of experimental), which is where it will be in a C++17 compliant compiler.

Additional benefits

There are additional benefits to string_view, such as creating a string_view from a substring in an existing string. std::string::substr returns a new string, potentially involving a dynamic allocation. However, we can construct a string_view from the address of a position in our string, and that won’t involve a dynamic allocation.

Example:

#include <iostream>
#include <experimental/string_view>

void* operator new(std::size_t n)
{
    std::cout << "[allocating " << n << " bytes]\n";
    return malloc(n);
}

bool compare(std::experimental::string_view s1, std::experimental::string_view s2)
{
    if (s1 == s2)
        return true;
    std::cout << '\"' << s1 << "\" does not match \"" << s2 << "\"\n";
    return false;
}

int main()
{
    std::string str = "this is my input string";

    std::experimental::string_view sv(&str.at(str.find_first_of('m')));

    compare(str, sv);

    return 0;
}

Build and run:

$ g++ -std=c++1z -Wall -Wextra -Werror main.cpp
$ ./a.out
[allocating 24 bytes]
"this is my input string" does not match "my input string"

RTags

2016-08-26T00:00:00+00:00

This is a guide to installing RTags on linux, and then using it in spacemacs

The distro I use in this post is Ubuntu 16.04, but most of the information should be general in nature.

We will install RTags’ dependencies, build and install RTags itself, build an RTags tag database for our project, and then enable the rtags layer in spacemacs.

Dependencies

According to the Installing rtags section of the Readme, we need to have the following dependencies (starred ones are optional):

clang-3.3 or higher
cmake-2.8 or higher
pkg-config*
bash-completion*
lua*

I am using Ubuntu 16.04, so the default versions offered by the Ubuntu package manager are all sufficient

sudo apt install clang libclang-dev cmake pkg-config bash-completion lua

Download, build and install RTags

cd /tmp
git clone --recursive git@github.com:Andersbakken/rtags.git
cd rtags
mkdir build && cd build
cmake ..
make -j8
sudo make install

Configure a service in systemd

Create a systemd config directory for your user

mkdir -p ~/.config/systemd/user

Create the RTags daemon socket service config

$ vim ~/.config/systemd/user/rdm.socket

Add the following:

[Unit]
Description=RTags daemon socket

[Socket]
ListenStream=%h/.rdm

[Install]
WantedBy=multi-user.target

Create the RTags daemon service config

$ vim ~/.config/systemd/user/rdm.service

Add the following

[Unit]
Description=RTags daemon

Requires=rdm.socket

[Service]
Type=simple
ExecStart=/usr/local/bin/rdm --log-file=%h/.rtags/rdm.log --data-dir=%h/.rtags/rtags-cache --verbose --inactivity-timeout 300

Enable and start the socket service

systemctl --user enable rdm.socket
systemctl --user start rdm.socket

Build an RTags database for your project

Since RTags uses clang to parse your code, it needs to know the compiler flags your project uses.

There are multiple ways to tell RTags what flags you use.

My project uses cmake, so I will use that.

Using cmake we can generate a compile_commands.json file which RTags will use to index the project

cd ~/src/project
mkdir build && cd build
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ..

Now we can instruct RTags to index our code

rc -J ./compile_commands.json

This takes a while to complete, we can watch the progress by looking at the log file we configured in ~/.config/systemd/user/rdm.service

tail -f ~/.rtags/rdm.log

Enable RTags in spacemacs

We now need to set up RTags support in emacs, and configure some keybindings.

For this I’m using mineo-rtags

I copied the 2 files packages.el and keybindings.el into a folder in my spacemacs config directory

mkdir ~/.spacemacs.d/mineo-rtags && cd ~/.spacemacs.d/mineo-rtags
wget https://raw.githubusercontent.com/mineo/dotfiles/master/spacemacs/.emacs.d/private/layers/mineo-rtags/packages.el
wget https://raw.githubusercontent.com/mineo/dotfiles/master/spacemacs/.emacs.d/private/layers/mineo-rtags/keybindings.el

For posterity, here is the contents of these two files at the time of writing:

packages.el:

(defconst mineo-rtags-packages
  '(cmake-ide
    rtags))

(defun mineo-rtags/init-cmake-ide ()
  (use-package cmake-ide
    :config
    (cmake-ide-setup)))

(defun mineo-rtags/init-rtags ()
  (use-package rtags
    :config
    (setq rtags-autostart-diagnostics t
          rtags-completions-enabled t
          rtags-use-helm t)
    (push '(company-rtags)
          company-backends-c-mode-common)
    (rtags-enable-standard-keybindings)
    (add-hook 'c-mode-common-hook 'rtags-start-process-unless-running))
  (use-package flycheck-rtags
    :ensure rtags))

keybindings.el:

(defconst mineo-rtags-overrides
  '(("C-]" 'rtags-find-symbol-at-point)
    ("M-." 'rtags-find-symbol-at-point)))

(defun mineo-rtags-set-evil-keys ()
  (dolist (override mineo-rtags-overrides)
    (evil-local-set-key 'normal (car override) (cdr override))))

(add-hook 'c-mode-common-hook 'mineo-rtags-set-evil-keys)

;;; https://github.com/mheathr/spacemacs/blob/develop/contrib/!lang/c-c%2B%2B/packages.el

(dolist (mode '(c-mode c++-mode))
  (evil-leader/set-key-for-mode mode
    "g ." 'rtags-find-symbol-at-point
    "g ," 'rtags-find-references-at-point
    "g v" 'rtags-find-virtuals-at-point
    "g V" 'rtags-print-enum-value-at-point
    "g /" 'rtags-find-all-references-at-point
    "g Y" 'rtags-cycle-overlays-on-screen
    "g >" 'rtags-find-symbol
    "g <" 'rtags-find-references
    "g [" 'rtags-location-stack-back
    "g ]" 'rtags-location-stack-forward
    "g D" 'rtags-diagnostics
    "g G" 'rtags-guess-function-at-point
    "g p" 'rtags-set-current-project
    "g P" 'rtags-print-dependencies
    "g e" 'rtags-reparse-file
    "g E" 'rtags-preprocess-file
    "g R" 'rtags-rename-symbol
    "g M" 'rtags-symbol-info
    "g S" 'rtags-display-summary
    "g O" 'rtags-goto-offset
    "g ;" 'rtags-find-file
    "g F" 'rtags-fixit
    "g L" 'rtags-copy-and-print-current-location
    "g X" 'rtags-fix-fixit-at-point
    "g B" 'rtags-show-rtags-buffer
    "g I" 'rtags-imenu
    "g T" 'rtags-taglist
    "g h" 'rtags-print-class-hierarchy
    "g a" 'rtags-print-source-arguments))

(provide 'keybindings)

Enable mineo-rtags layer in spacemacs

dotspacemacs-configuration-layers
'(
  (c-c++
    :variables
    c-c++-enable-clang-support t
  )
 syntax-checking
 mineo-rtags
 )

Restart spacemacs and it should install rtags and its dependencies.

The keybindings are available under , g

C++17 If statement with initializer

2016-08-22T00:00:00+00:00

Introduced under proposal P00305r0, If statement with initializer give us the ability to initialize a variable within an if statement, and then, once initialized, perform the actual conditional check.

If statements

Pre C++17

When inserting into a map, if you want to check whether the element was inserted into the map or not, you need to perform the insertion, capture the return value, and then check for successful insertion

Example:

#include <iostream>
#include <map>

int main()
{
    std::map<std::string, int> map;
    map["hello"] = 1;
    map["world"] = 2;

    // first we have to perform the operation and capture the return value
    auto ret = map.insert({ "hello", 3 });

    // only then can we check the return value
    if (!ret.second)
        std::cout << "hello already exists with value " << ret.first->second << "\n";

    // ret has "leaked" into this scope, so we need to pick a different name, ret2
    auto ret2 = map.insert({ "foo", 4 });

    // now we can check the value of ret2
    if (!ret2.second)
        std::cout << "foo already exists with value " << ret2.first->second << "\n";

    return 0;
}

Build and run:

$ clang++ -std=c++14 main.cpp
$ ./a.out
hello already exists with value 1

There are 2 annoyances with this code (albeit fairly minor).

It is more verbose; we have to create the ret variable which we want to check for successful insertion, and then, only once the variable has been created, can we then perform the actual check.
Slightly more insidious, the ret variable “leaks” into the surrounding scope. Note for the 2nd insertion we have to call the result variable ret2, because ret already exists.

It is quite easy to fix the 2nd annoyance by putting each conditional check into its own scope. This, however, comes at the cost of making the code even more verbose, and results in these floating braces with no preceding statement.

#include <iostream>
#include <map>

int main()
{
    std::map<std::string, int> map;
    map["hello"] = 1;
    map["world"] = 2;

    // we create a scope to enclose ret, preventing it leaking into the surrounding scope
    {
        auto ret = map.insert({ "hello", 3 });
        if (!ret.second)
            std::cout << "hello already exists with value " << ret.first->second << "\n";
    }
    // we create another scope to enclose ret, again preventing it from leaking out
    {
        auto ret = map.insert({ "foo", 4 });
        if (!ret.second)
            std::cout << "foo already exists with value " << ret.first->second << "\n";
    }

    return 0;
}

Build and run:

$ clang++ -std=c++14 main.cpp
$ ./a.out
hello already exists with value 1

C++17

With the introduction of if statement with initializer, we can now create the variable inside the if statement.

if (init; condition)

This makes the code more succint and doesn’t leak the variable into the surrounding scope.

Example:

#include <iostream>
#include <map>

int main()
{
    std::map<std::string, int> map;
    map["hello"] = 1;
    map["world"] = 2;

    // initialize the condition we want to check from within the if statement
    if (auto ret = map.insert({ "hello", 3 }); !ret.second)
        std::cout << "hello already exists with value " << ret.first->second << "\n";

    // ret has not leaked, so we can use that for this conditional check too
    if (auto ret = map.insert({ "foo", 4 }); !ret.second)
        std::cout << "foo already exists with value " << ret.first->second << "\n";

    return 0;
}

Build and run:

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
hello already exists with value 1

std::unique_lock

Following comments on reddit by /u/holywhateverbatman, a perhaps more illustrative example would be the situation where you attempt to obtain a lock, but need to do something else if it is not currently available.

Here we attempt to lock a std::mutex with a std::unique_lock, specifying we should only try_to_lock.

We can initialize the std::unique_lock from within the if statement that then checks whether we were able to lock the mutex or not.

Example:

#include <iostream>
#include <mutex>

int main()
{
    std::mutex mtx;

    // create an RAII style lock guard, but don't block if we can't lock - check to
    //   see whether we were able to get the lock or not
    if (std::unique_lock<std::mutex> l(mtx, std::try_to_lock); l.owns_lock())
    {
        std::cout << "successfully locked the resource\n";

        //...
    }
    else
    {
        std::cout << "resource not currently available\n";
    }
    return 0;
}

Build and run:

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
successfully locked the resource

A slightly more contrived example showing the mutex being unavailable:

#include <iostream>
#include <mutex>
#include <thread>
#include <chrono>

int main()
{
    // a mutex which will protect a shared resource
    std::mutex mtx;

    // start a thread which obtains the mutex and then sleeps for 2 seconds
    //   (to give enough time for main thread to attempt to lock the mutex)
    std::thread t([&]()
        {
            std::lock_guard<std::mutex> l(mtx);
            std::this_thread::sleep_for(std::chrono::seconds(2));
        });

    // sleep for a short while to give thread t enough time to start and obtain the mutex
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // when we try to lock in our if-with-initializer it should fail, as t owns the lock
    if (std::unique_lock<std::mutex> l(mtx, std::try_to_lock); l.owns_lock())
    {
        std::cout << "successfully locked the resource\n";

        //...
    }
    else
    {
        std::cout << "resource not currently available\n";
    }

    // wait for t to finish before exiting
    if (t.joinable())
        t.join();
    return 0;
}

Build and run:

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
resource not currently available

Combining with structured bindings

The usefulness of if with initializer becomes more apparent when combined with structured bindings.

In the following example we use structured bindings to unwrap the std::pair return value of std::map::insert into two separate variables, it (the iterator) and inserted (a boolean indicating whether the insert succeeded).

We can then check whether the insert succeeded in the if statement by checking inserted.

Example:

#include <iostream>
#include <map>

int main()
{
    std::map<std::string, int> map;
    map["hello"] = 1;
    map["world"] = 2;

    // intitialize the condition we want to check from within the if statement
    if (auto [it, inserted] = map.insert({ "hello", 3 }); !inserted)
        std::cout << "hello already exists with value " << it->second << "\n";

    // ret has not leaked, so we can use that for this conditional check too
    if (auto [it, inserted] = map.insert({ "foo", 4 }); !inserted)
        std::cout << "foo already exists with value " << it->second << "\n";

    return 0;
}

Build and run:

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
hello already exists with value 1

Switch statements

Pre C++17

Similar annoyances exist with switch statements. The code is more verbose as the variable has to be initialized first, and then only can the switch occur. Similarly, the variable leaks into the surrounding scope.

Example:

#include <iostream>

enum Result
{
    SUCCESS,
    DEVICE_FULL,
    ABORTED
};

std::pair<size_t /* bytes */, Result> writePacket()
{
    return { 100, SUCCESS };
}

int main()
{
    // initialize the value we want to switch on (res ends up in surrounding scope)
    auto res = writePacket();

    // then switch on that value
    switch (res.second)
    {
        case SUCCESS:
            std::cout << "successfully wrote " << res.first << " bytes\n";
            break;
        case DEVICE_FULL:
            std::cout << "insufficient space on device\n";
            break;
        case ABORTED:
            std::cout << "operation aborted before completion\n";
            break;
    }
    return 0;
}

Build and run:

$ clang++ -std=c++14 main.cpp
$ ./a.out
successfully wrote 100 bytes

C++17

As with if statements, we can now create the variable inside the switch statement.

switch (init; var)

Example:

#include <iostream>

enum Result
{
    SUCCESS,
    DEVICE_FULL,
    ABORTED
};

std::pair<size_t /* bytes */, Result> writePacket()
{
    return { 100, SUCCESS };
}

int main()
{
    switch (auto res = writePacket(); res.second)
    {
        case SUCCESS:
            std::cout << "successfully wrote " << res.first << " bytes\n";
            break;
        case DEVICE_FULL:
            std::cout << "insufficient space on device\n";
            break;
        case ABORTED:
            std::cout << "operation aborted before completion\n";
            break;
    }
    return 0;
}

Note now that we can initialize res inside the switch statement, and then perform the switch.

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
successfully wrote 100 bytes

C++17 Structured Bindings

2016-08-19T00:00:00+00:00

Introduced under proposal http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0144r0.pdf, Structured Bindings give us the ability to declare multiple variables initialised from a tuple or struct.

Tuples

Pre C++17

When “unpacking” a tuple, for example, you had to first declare the variables, and then use std::tie to get the values back.

Example:

#include <iostream>
#include <tuple>

int main()
{
    auto tuple = std::make_tuple(1, 'a', 2.3);

    // first we have to declare the variables
    int i;
    char c;
    double d;

    // now we can unpack the tuple into its individual components
    std::tie(i, c, d) = tuple;

    std::cout << "i=" << i << " c=" << c << " d=" << d << '\n';
    
    return 0;
}

Build and run:

$ clang++ -std=c++14 main.cpp
$ ./a.out
i=1 c=a d=2.3

C++17

With the introduction of structured bindings, when unpacking our tuple we can declare the variables inline, at the call site, using the following syntax:

auto [ var1, var2 ] = tuple;

Example:

#include <iostream>
#include <tuple>

int main()
{
    auto tuple = std::make_tuple(1, 'a', 2.3);

    // unpack the tuple into individual variables declared at the call site
    auto [ i, c, d ] = tuple;

    std::cout << "i=" << i << " c=" << c << " d=" << d << '\n';

    return 0;
}

Build and run:

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
i=1 c=a d=2.3

Note:

I am using the llvm nightly clang++-4.0 snapshot for the C++17 examples.

I added the nightly package sources to apt:

$ grep llvm /etc/apt/sources.list
deb http://apt.llvm.org/xenial/ llvm-toolchain-xenial main
deb-src http://apt.llvm.org/xenial/ llvm-toolchain-xenial main

Then updated apt and installed

$ sudo apt update
$ sudo apt install clang-4.0

Obtaining references to tuple members

Pre C++17

A major disadvantage to unpacking with std::tie is that it is impossible to obtain a reference to a tuple member. This is because references can’t be reseated. Once a reference is created, it cannot be later made to reference another object.

To illustrate, see here an attempt to create a reference and assign it to a member of the tuple using std::tie:

#include <iostream>
#include <tuple>

int main()
{
    auto tuple = std::make_tuple(1, 'a', 2.3);

    // first we have to declare the variables
    int& i; // syntax error - can't declare a reference without initialising it
    char c; 
    double d;
    std::tie(i, c, d) = tuple;

    std::cout << "i=" << i << " c=" << c << " d=" << d << '\n';

    // change the value of i inside the tuple
    i = 2;

    // show that the value inside the tuple has changed
    std::cout << "tuple<0>=" << std::get<0>(tuple) << '\n';

    return 0;
}

Build:

$ clang++ -std=c++14 main.cpp
main.cpp:8:10: error: declaration of reference variable 'i' requires an initializer
    int& i; // syntax error - can't declare a reference without initialising it
        ^
1 error generated.

The only way in pre C++17 to obtain a reference to a tuple member was to explicitly use std::get<index>(tuple):

#include <iostream>
#include <tuple>

int main()
{
    auto tuple = std::make_tuple(1, 'a', 2.3);

    // unpack the tuple into its individual components
    auto& i = std::get<0>(tuple);
    auto& c = std::get<1>(tuple);
    auto& d = std::get<2>(tuple);

    std::cout << "i=" << i << ", c=" << c << ", d=" << d << '\n';

    // change the value of i inside the tuple
    i = 2;

    // show that the value inside the tuple has changed
    std::cout << "tuple<0>=" << std::get<0>(tuple) << '\n';

    return 0;
}

Build and run:

$ clang++ -std=c++14 main.cpp
$ ./a.out
i=1, c=a, d=2.3
tuple<0>=2

C++17

With the introduction of structured bindings, we can now obtain a reference to the tuple members using auto&:

#include <iostream>
#include <tuple>

int main()
{
    auto tuple = std::make_tuple(1, 'a', 2.3);

    // unpack the tuple into its individual components
    auto& [ i, c, d ] = tuple;

    std::cout << "i=" << i << ", c=" << c << ", d=" << d << '\n';

    // change the value of i inside the tuple
    i = 2;

    // show that the value inside the tuple has changed
    std::cout << "tuple<0>=" << std::get<0>(tuple) << '\n';

    return 0;
}

Build and run:

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
i=1, c=a, d=2.3
tuple<0>=2

Structs

Structured bindings also allow us to “unpack” the members of a struct into its individual components.

#include <iostream>

struct Foo
{
    int i;
    char c;
    double d;
};

int main()
{
    Foo f { 1, 'a', 2.3 };

    // unpack f's members into individual variables declared at the call site
    auto [ i, c, d ] = f;

    std::cout << "i=" << i << " c=" << c << " d=" << d << '\n';

    return 0;
}

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
i=1 c=a d=2.3

Similarly, we can obtain a reference to the members of a struct, and then change their value using our reference

#include <iostream>

struct Foo
{
    // unpack the struct into individual variables declared at the call site
    int i;
    char c;
    double d;
};

int main()
{
    Foo f { 1, 'a', 2.3 };

    // unpack the struct into individual variables declared at the call site
    auto& [ i, c, d ] = f;

    std::cout << "i=" << i << " c=" << c << " d=" << d << '\n';

    // change the member c
    c = 'b';

    // show the value changed in f
    std::cout << "f.c=" << f.c << '\n';

    return 0;
}

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
i=1 c=a d=2.3
f.c=b

We can also capture as a forwarding reference using auto&&.

That is, auto&& will resolve to auto& for lvalue references, and auto&& for rvalud references.

Here is an example of capturing the output from a range-based for loop over a temporary map

#include <iostream>
#include <map>

std::map<std::string, int> get_map()
{
    return {
        { "hello", 1 },
        { "world", 2 },
        { "it's",  3 },
        { "me",    4 },
    };
}

int main()
{
    for (auto&& [ k, v ] : get_map())
        std::cout << "k=" << k << " v=" << v << '\n';

    return 0;
}

$ clang++-4.0 -std=c++1z main.cpp
$ ./a.out
k=hello v=1
k=it's v=3
k=me v=4
k=world v=2

Steve Lorimer

C++ in spacemacs

Dependencies

clang tools

node

lsp-mode

dap-mode

spacemacs layers

Debugging an app

Embedding python in C++ with pybind11

Changes required in the C++ hierarchy

Python wrapper for our virtual StrategyInstance

Exposing the C++ types to python

Defining a function which imports a python file as a module

Initialising our plugin/module

Pulling it all together

Define a python strategy

Run it!

Complete code listing:

main.cpp:

strategy.py:

Embedding python in C++ with boost::python

Step 1: Define the C++ types which represents the trading framework

Side

Order

StrategyServer

StrategyInstance

Step 2: Create a python wrapper for our virtual StrategyInstance

Step 3: Expose these types to python

Step 4: define a function which imports a python file as a module

Step 5: load a python file containing our strategy and execute it

Step 6: define a python strategy

Step 7: run it!

Complete code listing:

main.cpp:

strategy.py:

C++17 string_view

Rationale

String views

Additional benefits

RTags

Dependencies

Download, build and install RTags

Configure a service in systemd

Create the RTags daemon socket service config

Create the RTags daemon service config

Build an RTags database for your project

Enable RTags in spacemacs

Enable mineo-rtags layer in spacemacs

C++17 If statement with initializer

If statements

Pre C++17

C++17

std::unique_lock

Combining with structured bindings

Switch statements

Pre C++17

C++17

C++17 Structured Bindings

Tuples

Pre C++17

C++17

Obtaining references to tuple members

Pre C++17

C++17

Structs

`lsp-mode`

`dap-mode`

`main.cpp`:

`strategy.py`:

`main.cpp`:

`strategy.py`: