#include <boost/circular_buffer.hpp>

boost::circular_buffer<int> cb(3);  // Create with capacity for 3 integers

cb.push_back(1);

cb.push_back(2);

cb.push_back(3);

// The buffer is full now

// pushing subsequent elements will overwrite front-most elements.

cb.push_back(4);  // Overwrite 1 with 4.

cb.push_back(5);  // Overwrite 2 with 5.

// The buffer now contains 3, 4 and 5.

// Elements can be popped from either the front or the back.

cb.pop_back();  // 5 is removed.

cb.pop_front(); // 3 is removed.

// Leaving only one element with value = 4.

assert(cb[0] == 4);

#include <boost/multi_array.hpp>

typedef boost::multi_array<double, 3> array_type;

typedef array_type::index index;

array_type A(boost::extents[3][4][2]);

int values = 0;

for(index i=0; i!=3; ++i)

    for(index j=0; j!=4; ++j)

        for(index k=0; k!=2; ++k)

            A[i][j][k] = values++;

#include <string>

#include <iostream>

#include <boost/foreach.hpp>

std::string test("Hello, world!");  // string 可以视为 char 的容器

BOOST_FOREACH(char ch, test)

{

    std::cout << ch;

}

#include <fstream>

#include <boost/locale.hpp>

using namespace boost::locale;

std::locale loc = generator().generate("he_IL.UTF-8");

std::wofstream file.

file.imbue(loc);

file.open("hello.txt");

file << L"שלום!";

#include <iostream>

#include <boost/format.hpp>

using std::cout;

using boost::format;

// 基于“位置指示符”的格式串语法

cout << format("%1% %2% %3% %2% %1%") % "11" % "22" % "333";

// 输出如下：

// 11 22 333 22 11

// 兼容 printf() 的格式串语法

cout << format("%s  %d") % "price" % 1234;

// 输出如下：

// price  1234

#include <string>

#include <fmt/format.h>

// 使用 Python 的格式化语法

fmt::print("Hello, {}!", "world");

// 使用 printf 的格式化语法

fmt::printf("Hello, %s!", "world");

// 使用序号参数，

std::string s = fmt::format("{0} {1} {0}", "Hello", "world");

// 使用命名参数

fmt::print("Hello, {name}! The answer is {number}. Goodbye, {name}.",

           fmt::arg("name", "World"), fmt::arg("number", 42));

#include <boost/regex.hpp>

using std::string;

using namespace boost;

// 正则式匹配的例子

bool validate_card_format(const string& s)

{

    const regex e("(\\d{4}[- ]){3}\\d{4}");

    return regex_match(s, e);

}

// 正则式替换的例子

const regex e("\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z");

const string machine_format("\\1\\2\\3\\4");

const string human_format("\\1-\\2-\\3-\\4");

string machine_readable_card_number(const string& s)

{

    return regex_replace(s, e, machine_format, match_default|format_sed);

}

string human_readable_card_number(const string& s)

{

    return regex_replace(s, e, human_format, match_default|format_sed);

}

#include <re2/re2.h>

int i;

string s;

assert(RE2::FullMatch("test:1234", "(\\w+):(\\d+)", &s, &i));

assert(s == "test");

assert(i == 1234);

#include <string>

#include <vector>

#include <iostream>

#include <boost/algorithm/string.hpp>

std::vector<std::string> v;

// 此处填充 v

std::cout << boost::algorithm::join(v, " ") << '\n';

#include <string>

#include <iostream>

#include <boost/lexical_cast.hpp>

std::string s = boost::lexical_cast<std::string>(123);

std::cout << s << '\n';

double d = boost::lexical_cast<double>(s);

std::cout << d << '\n';

#include <ctime>

#include <boost/random.hpp>

double SampleNormal(double mean, double sigma)

{

    using namespace boost;

    // 建立一个 Mersenne twister 随机数产生器，使用当前时间播种

    static mt19937 rng(static_cast<unsigned>(std::time(NULL)));

    // 选择高斯机率分布

    normal_distribution<double> norm_dist(mean, sigma);

    // 使用 function 的形式，生成随机数据产生器

    variate_generator<mt19937&, normal_distribution<double> >  normal_sampler(rng, norm_dist);

    // 传回样本分布结果

    return normal_sampler();

}

#include <boost/uuid/uuid.hpp>

#include <boost/uuid/uuid_generators.hpp>

// uuid 类以 POD 方式实现，可以直接用在 memcpy()

unsigned char uuid_data[16];

boost::uuids::uuid u;

memcpy(&u, uuid_data, 16);

#include <iostream>

#include <fruit/fruit.h>

using fruit::Component;

using fruit::Injector;

class Writer

{

public:

    virtual void write(std::string str) = 0;

};

class StdoutWriter : public Writer

{

public:

    // Like "StdoutWriter() = default;" but also marks this constructor as the

    // one to use for injection.

    INJECT(StdoutWriter()) = default;

    virtual void write(std::string str) override

    {

        std::cout << str;

    }

};

class Greeter

{

public:

    virtual void greet() = 0;

};

class GreeterImpl : public Greeter

{

private:

    Writer* writer;

public:

    // Like "GreeterImpl(Writer* writer) {...}"

    // but also marks this constructor as the one to use for injection.

    INJECT(GreeterImpl(Writer* writer))

        : writer(writer)

    {

    }

    virtual void greet() override

    {

        writer->write("Hello world!\n");

    }

};

Component<Greeter> getGreeterComponent()

{

    return fruit::createComponent()

        .bind<Writer, StdoutWriter>()

        .bind<Greeter, GreeterImpl>();

}

int main()

{

    Injector<Greeter> injector(getGreeterComponent());

    Greeter* greeter = injector.get<Greeter*>();

    greeter->greet();

    return 0;

}

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <boost/function.hpp>

boost::function<int(const char*)> f = std::atoi;

std::cout << f("42") << '\n';

f = std::strlen;

std::cout << f("42") << '\n';

#include <vector>

#include <algorithm>

#include <iostream>

#include <boost/lambda/lambda.hpp>

std::vector<int> v;

// 此处填充 v

std::for_each(v.begin(), v.end(),

    std::cout << boost::lambda::_1 << "\n");

#include <boost/log/trivial.hpp>

BOOST_LOG_TRIVIAL(debug) << "A debug severity message";

BOOST_LOG_TRIVIAL(info) << "An informational severity message";

#include <dlib/logger.h>

#include <dlib/misc_api.h>

using namespace dlib;

logger dlog("example");

dlog.set_level(LALL);

dlog << LINFO << "This is an informational message.";

int variable = 8;

dlog << LDEBUG << "The integer variable is set to " << variable;

#include <check.h>

/* The basic unit test looks as follows: */

START_TEST (test_name)

{

    /* unit test code */

}

END_TEST

/* The "START_TEST/END_TEST" pair are macros that setup basic structures to permit testing.

   It is a mistake to leave off the END_TEST marker;

   doing so produces all sorts of strange errors when the check is compiled. */

#include <iostream>

#include <boost/filesystem.hpp>

int main(int argc, char* argv[])

{

    using namespace boost::filesystem;

    if(argc != 2)

    {

        std::cout << "Usage: \n" << argv[0] << " path\n";

        return 1;

    }

    std::cout << argv[1] << " " << file_size(argv[1]) << '\n';

    return 0;

}

#include <iostream>

#include <boost/thread/thread.hpp>

void hello_world()

{

    std::cout << "Hello world, I'm a thread!\n";

}

int main()

{

    boost::thread my_thread(&hello_world);  // 启动一个线程

    my_thread.join();  // 等待该线程结束

    return 0;

}

#include <wx/wxprec.h>

#ifndef WX_PRECOMP

#    include <wx/wx.h>

#endif

class MyApp: public wxApp

{

public:

    virtual bool OnInit();

};

wxIMPLEMENT_APP(MyApp);

class MyFrame: public wxFrame

{

public:

    MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size);

private:

    void OnExit(wxCommandEvent& event);

    wxDECLARE_EVENT_TABLE();

};

wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)

    EVT_MENU(wxID_EXIT, MyFrame::OnExit)

wxEND_EVENT_TABLE()

bool MyApp::OnInit()

{

    MyFrame* frame = new MyFrame("Hello, World", wxPoint(50, 50), wxSize(450, 340));

    frame->Show(true);

    return true;

}

MyFrame::MyFrame(const wxString& title, const wxPoint& pos, const wxSize& size)

    : wxFrame(NULL, wxID_ANY, title, pos, size)

{

    wxMenu* menuFile = new wxMenu();

    menuFile->Append(wxID_EXIT);

    wxMenuBar* menuBar = new wxMenuBar();

    menuBar->Append(menuFile, "&File");

    SetMenuBar(menuBar);

}

void MyFrame::OnExit(wxCommandEvent& event)

{

    Close(true);

}

#include <QtWidgets/QApplication>

#include <QtWidgets/QLabel>

int main(int argc, char* argv[])

{

    QApplication app(argc, argv);

    QLabel label("Hello, world!");

    label.show();

    return app.exec();

}

#include <gtk/gtk.h>

int main(int argc, char* argv[])

{

    gtk_init(&argc, &argv);

    GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

    gtk_window_set_title(GTK_WINDOW(window), "Hello, world!");

    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

    gtk_window_set_default_size(GTK_WINDOW(window), 200, 100);

    /*

    ** Map the destroy signal of the window to gtk_main_quit;

    ** When the window is about to be destroyed, we get a notification and

    ** stop the main GTK+ loop by returning 0

    */

    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(window);

    /* Start the main loop, do nothing until the application is closed */

    gtk_main();

    return 0;

}

#include <FL/Fl.H>

#include <FL/Fl_Window.H>

#include <FL/Fl_Box.H>

int main(int argc, char **argv)

{

    Fl_Window* window = new Fl_Window(300, 180);

    Fl_Box* box = new Fl_Box(20, 40, 260, 100, "Hello, World!");

    box->box(FL_UP_BOX);

    box->labelsize(36);

    box->labelfont(FL_BOLD+FL_ITALIC);

    box->labeltype(FL_SHADOW_LABEL);

    window->end();

    window->show(argc, argv);

    return Fl::run();

}

#include <QtWidgets/QApplication>

#include <QtWidgets/QMainWindow>

#include <QtCharts/QChartView>

#include <QtCharts/QPieSeries>

#include <QtCharts/QPieSlice>

QT_CHARTS_USE_NAMESPACE

int main(int argc, char* argv[])

{

    QApplication app(argc, argv);

    QPieSeries* series = new QPieSeries();

    series->append("Jane", 1);

    series->append("Joe", 2);

    series->append("Andy", 3);

    series->append("Barbara", 4);

    series->append("Axel", 5);

    QPieSlice* slice = series->slices().at(1);

    slice->setExploded();

    slice->setLabelVisible();

    slice->setPen(QPen(Qt::darkGreen, 2));

    slice->setBrush(Qt::green);

    QChart* chart = new QChart();

    chart->addSeries(series);

    chart->setTitle("Simple piechart example");

    chart->legend()->hide();

    QChartView* chartView = new QChartView(chart);

    chartView->setRenderHint(QPainter::Antialiasing);

    QMainWindow window;

    window.setCentralWidget(chartView);

    window.resize(400, 300);

    window.show();

    return app.exec();

}

#include <stdio.h>     /* for printf */

#include <stdlib.h>    /* for exit */

#include <unistd.h>    /* for getopt */

int main(int argc, char** argv)

{

    int digit_optind = 0;

    int aopt = 0, bopt = 0;

    char* copt = NULL;

    char* dopt = NULL;

    int c;

    while( (c = getopt(argc, argv, "abc:d:012")) != -1)

    {

        int this_option_optind = optind ? optind : 1;

        switch(c)

        {

            case '0':

            case '1':

            case '2':

                if(digit_optind != 0 && digit_optind != this_option_optind)

                {

                    printf("digits occur in two different argv-elements.\n");

                }

                digit_optind = this_option_optind;

                printf("option %c\n", c);

                break;

            case 'a':

                printf("option a\n");

                aopt = 1;

                break;

            case 'b':

                printf("option b\n");

                bopt = 1;

                break;

            case 'c':

                printf("option c with value '%s'\n", optarg);

                copt = optarg;

                break;

            case 'd':

                printf("option d with value '%s'\n", optarg);

                dopt = optarg;

                break;

            case '?':

                break;

            default:

                printf("?? getopt returned character code 0%o ??\n", c);

        }

    }

    if(optind < argc)

    {

        printf("non-option ARGV-elements: ");

        while(optind < argc)

        {

            printf("%s ", argv[optind++]);

        }

        printf("\n");

    }

    exit (0);

}

#include <stdio.h>

#include <pcap.h>

int main(int argc, char* argv[])

{

    pcap_t* handle;            /* Session handle */

    char* dev;            /* The device to sniff on */

    char errbuf[PCAP_ERRBUF_SIZE];    /* Error string */

    struct bpf_program fp;        /* The compiled filter */

    char filter_exp[] = "port 23";    /* The filter expression */

    bpf_u_int32 mask;        /* Our netmask */

    bpf_u_int32 net;        /* Our IP */

    struct pcap_pkthdr header;    /* The header that pcap gives us */

    const u_char* packet;        /* The actual packet */

    /* Define the device */

    dev = pcap_lookupdev(errbuf);

    if(dev == NULL)

    {

        fprintf(stderr, "Couldn't find default device: %s\n", errbuf);

        return 2;

    }

    /* Find the properties for the device */

    if(pcap_lookupnet(dev, &net, &mask, errbuf) == -1)

    {

        fprintf(stderr, "Couldn't get netmask for device %s: %s\n", dev, errbuf);

        net = 0;

        mask = 0;

    }

    /* Open the session in promiscuous mode */

    handle = pcap_open_live(dev, BUFSIZ, 1, 1000, errbuf);

    if(handle == NULL)

    {

        fprintf(stderr, "Couldn't open device %s: %s\n", dev, errbuf);

        return 2;

    }

    /* Compile and apply the filter */

    if(pcap_compile(handle, &fp, filter_exp, 0, net) == -1)

    {

        fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));

        return 2;

    }

    if(pcap_setfilter(handle, &fp) == -1)

    {

        fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));

        return 2;

    }

    packet = pcap_next(handle, &header);  /* Grab a packet */

    printf("Jacked a packet with length of [%d]\n", header.len);

    pcap_close(handle);  /* Close the session */

    return 0;

}

#include <stdio.h>

#include <curl/curl.h>

int main()

{

    curl_global_init(CURL_GLOBAL_ALL);

    CURL* curl = curl_easy_init();

    if(curl)

    {

        curl_easy_setopt(curl, CURLOPT_USERNAME, "user");

        curl_easy_setopt(curl, CURLOPT_PASSWORD, "password");

        // This will list the folders within the user's mailbox. If you want to

        // list the folders within a specific folder, for example the inbox,

        // then specify the folder as a path in the URL such as /INBOX

        curl_easy_setopt(curl, CURLOPT_URL, "imap://imap.example.com");

        CURLcode res = curl_easy_perform(curl);

        if(res != CURLE_OK)  // Check for errors

        {

            fprintf(stderr, "curl_easy_perform() failed: %s\n",

                    curl_easy_strerror(res));

        }

        curl_easy_cleanup(curl);  // Always cleanup

    }

    curl_global_cleanup();

    return 0;

}

#include <string>

#include <iostream>

#include <boost/asio.hpp>

int main()

{

    using boost::asio::ip::tcp;

    try

    {

        boost::asio::io_service io_service;

        tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 13));

        while(true)

        {

            tcp::socket socket(io_service);

            acceptor.accept(socket);

            std::string msg = "Hello, world";

            boost::system::error_code ignored_err;

            boost::asio::write(socket, boost::asio::buffer(msg), ignored_err);

        }

    }

    catch(std::exception& err)

    {

        std::cerr << err.what() << std::endl;

    }

    return 0;

}

#include <zhelpers.hpp>

int main(int argc, char* argv[])

{

    zmq::context_t context(1);

    zmq::socket_t responder(context, ZMQ_REP);

    responder.connect("tcp://localhost:5560");

    while(true)

    {

        // Wait for next request from client

        std::string request = s_recv(responder);

        std::cout << "Received request: " << request << std::endl;

        // Do some 'work'

        sleep(1);

        // Send reply back to client

        s_send(responder, "Hello, world");

    }

}

#include <assert.h>

#include <libc.h>

#include <stdio.h>

#include <nanomsg/nn.h>

#include <nanomsg/pipeline.h>

int reply(const char* url)

{

    int sock = nn_socket(AF_SP, NN_PULL);

    assert(sock >= 0);

    assert(nn_bind(sock, url) >= 0);

    while(1)

    {

        char* msg = NULL;

        int bytes = nn_recv(sock, &msg, NN_MSG, 0);

        assert(bytes >= 0);

        printf("RECEIVED:\n%s\n", msg);

        nn_freemsg(msg);

    }

}

int request(const char* url, const char* msg)

{

    int sz_msg = strlen(msg) + 1; // '\0'

    int sock = nn_socket(AF_SP, NN_PUSH);

    assert(sock >= 0);

    assert(nn_connect(sock, url) >= 0);

    printf("SENDING:\n%s\n", msg);

    int bytes = nn_send(sock, msg, sz_msg, 0);

    assert(bytes == sz_msg);

    return nn_shutdown(sock, 0);

}

#include <sys/types.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <event.h>

#include <evhttp.h>

void generic_request_handler(struct evhttp_request* req, void* arg)

{

    struct evbuffer* return_buffer = evbuffer_new();

    evbuffer_add_printf(return_buffer, "Thanks for the request!");

    evhttp_send_reply(req, HTTP_OK, "Client", return_buffer);

    evbuffer_free(return_buffer);

}

int main(int argc, char** argv)

{

    short          http_port = 8080;

    char*          http_addr = "127.0.0.1";

    struct evhttp* http_server = NULL;

    event_init();

    http_server = evhttp_start(http_addr, http_port);

    evhttp_set_gencb(http_server, generic_request_handler, NULL);

    fprintf(stderr, "Server started on port %d\n", http_port);

    event_dispatch();

    return 0;

}

#include <memory>

#include <cstdint>

#include <iostream>

#include <evhttp.h>

int main()

{

    if(!event_init())

    {

        std::cerr << "Failed to init libevent." << std::endl;

        return -1;

    }

    char const SrvAddress[] = "127.0.0.1";

    std::uint16_t SrvPort = 8080;

    std::unique_ptr<evhttp, decltype(&evhttp_free)> Server(evhttp_start(SrvAddress, SrvPort), &evhttp_free);

    if(!Server)

    {

        std::cerr << "Failed to init http server." << std::endl;

        return -1;

    }

    void (*OnReq)(evhttp_request* req, void*) = [] (evhttp_request* req, void*)

    {

        auto* OutBuf = evhttp_request_get_output_buffer(req);

        if(!OutBuf)

        {

            return;

        }

        evbuffer_add_printf(OutBuf, "<html><body><h1>Hello, World!</h1></body></html>");

        evhttp_send_reply(req, HTTP_OK, "", OutBuf);

    };

    evhttp_set_gencb(Server.get(), OnReq, nullptr);

    if(event_dispatch() == -1)

    {

        std::cerr << "Failed to run messahe loop." << std::endl;

        return -1;

    }

    return 0;

}

#include <stdio.h>

#include <iostream>

#define OTL_ORA8  // Compile OTL 4.0/OCI8

#include <otlv4.h>  // include the OTL 4.0 header file

int main()

{

    otl_connect::otl_initialize();

    try

    {

        otl_connect db;

        db.rlogon("scott/tiger");  // connect to Oracle

        otl_cursor::direct_exec(

            db,

            "drop table test_tab",

            otl_exception::disabled  // disable OTL exceptions

        );

        otl_cursor::direct_exec(

            db,

            "create table test_tab(f1 number, f2 varchar2(30))"

        );

    }

    catch(otl_exception& err)

    {

        using namespace std;

        // intercept OTL exceptions

        cerr << err.msg << endl;  // print error message

        cerr << err.stm_text << endl;  // print SQL that caused the error

        cerr << err.var_info << endl;  // print variable that caused the error

    }

    db.logoff();  // disconnect from Oracle

    return 0;

}

sql::mysql::MySQL_Driver* driver = sql::mysql::MySQL_Driver::get_mysql_driver_instance();

sql::Connection* conn = driver->connect("tcp://127.0.0.1:3306", "user", "password");

sql::Statement* stmt = conn->createStatement();

stmt->execute("USE EXAMPLE_DB");

stmt->execute("DROP TABLE IF EXISTS test");

stmt->execute("CREATE TABLE test(id INT, label CHAR(1))");

stmt->execute("INSERT INTO test(id, label) VALUES (1, 'a')");

delete stmt;

stmt = NULL;

delete conn;

conn = NULL;

#include <iostream>

#include <mysql++.h>

void query(db_name, server_name, user, password)

{

    using namespace std;

    mysqlpp::Connection conn(false);

    if(!conn.connect(db_name, server_name, user, password))

    {

        cerr << "DB connection failed: " << conn.error() << endl;

        return;

    }

    mysqlpp::Query query = conn.query("select item from table1");

    mysqlpp::StoreQueryResult sqr = query.store()

    if(!sqr)

    {

        cerr << "Failed to get item list: " << query.error() << endl;

        return;

    }

    mysqlpp::StoreQueryResult::const_iterator iter;

    for(iter=sqr.begin(); iter!=sqr.end(); ++iter)

    {

        mysqlpp::Row row = *iter;

        cout << '\t' << row[0] << endl;

    }

}

#include <iostream>

#include <pqxx/pqxx>

void update(const std::string& name)

{

    pqxx::connection conn("dbname=company user=accounting");

    pqxx::work txn(conn);

    pqxx::result r = txn.exec("SELECT id FROM Employee WHERE name =" + name);

    if(r.size() != 1)

    {

        std::cerr << "Expected 1 employee with name " << name << ", "

                  << "but found " << r.size() << std::endl;

        return 1;

    }

    int employee_id = r[0][0].as<int>();

    std::cout << "Updating employee #" << employee_id << std::endl;

    txn.exec(

        "UPDATE EMPLOYEE SET salary = salary + 1 "

        "WHERE id = " + txn.quote(employee_id)

    );

    txn.commit();

}

#include <ocilib.hpp>

using namespace ocilib;

int main()

{

    try

    {

        Environment::Initialize();

        Connection conn("db", "user", "password");

        Statement stmt(conn);

        stmt.Execute("select intcol, strcol from table");

        Resultset rs = stmt.GetResultset();

        while(rs.Next())

        {

            std::cout << rs.Get<int>(1) << " - " << rs.Get<ostring>(2) << std::endl;

        }

    }

    catch(std::exception& err)

    {

        std::cout << err.what() << std::endl;

    }

    Environment::Cleanup();

    return 0;

}

#include <stdio.h>

#include <sqlite3.h>

static int callback(void* NotUsed, int argc, char** argv, char** azColName)

{

    for(int i=0; i<argc; i++)

    {

        printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");

    }

    printf("\n");

    return 0;

}

int main(int argc, char* argv[])

{

    if(argc != 3)

    {

        fprintf(stderr, "Usage: %s DATABASE SQL-STATEMENT\n", argv[0]);

        return 1;

    }

    sqlite3* db = NULL;

    int rc = sqlite3_open(argv[1], &db);

    if(rc)

    {

        fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));

        sqlite3_close(db);

        return 1;

    }

    char* szErrMsg = NULL;

    rc = sqlite3_exec(db, argv[2], callback, 0, &szErrMsg);

    if(rc != SQLITE_OK)

    {

        fprintf(stderr, "SQL error: %s\n", szErrMsg);

        sqlite3_free(szErrMsg);

    }

    sqlite3_close(db);

    return 0;

}

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <hiredis.h>

#include <async.h>

#include <adapters/libev.h>

void getCallback(redisAsyncContext* context, void* r, void* privdata)

{

    redisReply* reply = r;

    if(reply == NULL)

    {

        return;

    }

    printf("argv[%s]: %s\n", (char*)privdata, reply->str);

    redisAsyncDisconnect(context);  /* Disconnect after receiv reply */

}

void connectCallback(const redisAsyncContext* context, int status)

{

    if(status != REDIS_OK)

    {

        printf("Error: %s\n", context->errstr);

        return;

    }

    printf("Connected...\n");

}

void disconnectCallback(const redisAsyncContext* context, int status)

{

    if(status != REDIS_OK)

    {

        printf("Error: %s\n", context->errstr);

        return;

    }

    printf("Disconnected...\n");

}

int main(int argc, char* argv[])

{

    signal(SIGPIPE, SIG_IGN);

    redisAsyncContext* context = redisAsyncConnect("127.0.0.1", 6379);

    if(context->err)

    {

        printf("Error: %s\n", context->errstr);

        return 1;  /* Let *context leak for now... */

    }

    redisLibevAttach(EV_DEFAULT_ context);

    redisAsyncSetConnectCallback(context, connectCallback);

    redisAsyncSetDisconnectCallback(context, disconnectCallback);

    redisAsyncCommand(context, NULL, NULL,

                        "SET key %b", argv[argc-1], strlen(argv[argc-1]));

    redisAsyncCommand(context, getCallback, (char*)"end-1", "GET key");

    ev_loop(EV_DEFAULT_ 0);

    return 0;

}

#include <stdio.h>

#include <bson.h>

#include <mongoc.h>

int main(int argc, char* argv[])

{

    mongoc_init();

    mongoc_client_t* client = mongoc_client_new("mongodb://localhost:27017/");

    mongoc_collection_t* collection = mongoc_client_get_collection(client, "test", "test");

    bson_t* doc = bson_new();

    bson_oid_t oid;

    bson_oid_init(&oid, NULL);

    BSON_APPEND_OID(doc, "_id", &oid);

    BSON_APPEND_UTF8(doc, "hello", "world");

    bson_error_t error;

    if(!mongoc_collection_insert(collection, MONGOC_INSERT_NONE, doc, NULL, &error))

    {

        printf("%s\n", error.message);

    }

    bson_destroy(doc);

    mongoc_collection_destroy(collection);

    mongoc_client_destroy(client);

    return 0;

}

// 通过预处理语句“#pragma”来进行某些定制

#pragma db object table("people")

class person

{

public:

    // ......

private:

    friend class odb::access;

    person();

    #pragma db id auto

    unsigned long id_;

    string first_;

    string last_;

    #pragma type("INT UNSIGNED")

    unsigned short age_;

};

typedef odb::query<person> query;

typedef odb::result<person> result;

transaction trans(db.begin());

result r(db.query<person>(query::last == "Doe" && query::age < 30));

for(result::iterator i(r.begin()); i!=r.end(); ++i)

{

    cout << "Hello, " << i->first() << endl;

}

trans.commit();

#include <stdio.h>

#include <curl/curl.h>

int main()

{

    curl_global_init(CURL_GLOBAL_ALL);

    CURL* curl = curl_easy_init();

    if(curl)

    {

        curl_easy_setopt(curl, CURLOPT_URL, "http://post.example.com/foo.cgi");

        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "name=daniel&project=curl");

        CURLcode res = curl_easy_perform(curl);

        if(res != CURLE_OK)  // Check for errors

        {

            fprintf(stderr, "curl_easy_perform() failed: %s\n",

                    curl_easy_strerror(res));

        }

        curl_easy_cleanup(curl);  // always cleanup

    }

    curl_global_cleanup();

    return 0;

}

#include <cryptopp/sha.h>

using namespace CryptoPP;

const byte* pbData = ...;  // 要计算的数据的地址

unsigned int nDataLen = ...;  // 字节数

byte abDigest[SHA256::DIGESTSIZE];

SHA256().CalculateDigest(abDigest, pbData, nDataLen);

// 注：abDigest 中通常会包含不可见字符，要输出为可见字符串需要做一下 Hex 编码

#include <cassert>

#include <iostream>

#include <string>

#include <keyczar/keyczar.h>

void test(const std::string& key_location)

{

    keyczar::Keyczar* crypter = keyczar::Crypter::Read(key_location);

    if(!crypter)

    {

        return;

    }

    std::string plain = "Secret message";

    std::cout << "Plain text: " << plain << std::endl;

    std::string cipher;

    if(crypter->Encrypt(plain, &cipher))

    {

        std::cout << "Cipher text (Base64w): " << cipher << std::endl;

        std::string decrypted;

        if(crypter->Decrypt(cipher, &decrypted))

        {

            assert(plain == decrypted);

        }

    }

    delete crypter;

}

#include <sstream>

#include <boost/property_tree/ptree.hpp>

#include <boost/property_tree/json_parser.hpp>

using boost::property_tree::ptree;

using boost::property_tree::read_json;

using boost::property_tree::write_json;

// Write json

ptree pt1;

pt1.put("foo", "bar");

std::ostringstream oss;

write_json(oss, pt1, false);

std::string json = oss.str(); // {"foo":"bar"}

// Read json

std::istringstream iss(json);

ptree pt2;

read_json(iss, pt2);

std::string value = pt2.get<std::string>("foo");

#include <hpdf.h>

// 创建文档对象

HPDF_Doc doc = HPDF_New(error_handler, NULL);

if(!doc)

{

    printf("ERROR: cannot create pdf object.\n");

    return 1;

}

// 设置文档属性

HPDF_SetCompressionMode(doc, HPDF_COMP_ALL);

HPDF_SetPageMode(doc, HPDF_PAGE_MODE_USE_OUTLINE);

HPDF_SetPassword(doc, "owner pwd", "user pwd");

// 添加一页

HPDF_Page page_1 = HPDF_AddPage(doc);

// 设置页属性

HPDF_Page_SetSize(page_1, HPDF_PAGE_SIZE_B5, HPDF_PAGE_LANDSCAPE);

// 保存到文件

HPDF_SaveToFile(doc, "test.pdf");

// 结束

HPDF_Free(doc);

#include <boost/gil/image.hpp>

#include <boost/gil/typedefs.hpp>

#include <boost/gil/extension/io/jpeg_io.hpp>

#include <boost/gil/extension/numeric/sampler.hpp>

#include <boost/gil/extension/numeric/resample.hpp>

using namespace boost::gil;

rgb8_image_t img;

jpeg_read_image("input.jpg", img);

// Scale the image to 100x100 pixels using bilinear resampling

rgb8_image_t square(100, 100);

resize_view(const_view(img), view(square), bilinear_sampler());

jpeg_write_view("output.jpg", const_view(square));

#include <stdio.h>

#include <gsl/gsl_sf_bessel.h>

double x = 5.0;

double y = gsl_sf_bessel_J0(x);

printf("J0(%g) = %.18e\n", x, y);

#include <stdio.h>

#include <gmp.h>

mpz_t x,y,result;

mpz_init_set_str(x, "7612058254738945", 10);

mpz_init_set_str(y, "9263591128439081", 10);

mpz_init(result);

mpz_mul(result, x, y);

gmp_printf("%Zd\n", result);

/* free used memory */

mpz_clear(x);

mpz_clear(y);

mpz_clear(result);

#include <boost/numeric/ublas/matrix.hpp>

#include <boost/numeric/ublas/io.hpp>

using namespace boost::numeric::ublas;

matrix<double> m(3, 3);

for(unsigned i=0; i<m.size1(); i++)

    for(unsigned j=0; j<m.size2(); j++)

        m(i, j) = 3 * i + j;

std::cout << m << std::endl;

#include <iostream>

#include <boost/numeric/ublas/vector.hpp>

#include <boost/numeric/ublas/matrix.hpp>

#include <boost/numeric/ublas/io.hpp>

using namespace boost::numeric::ublas;

vector<double> v(2);

v(0) = 1; v(1) = 2;

matrix<double> m(2,2);

m(0,0) = 0; m(0,1) = 1;

m(1,0) = 2; m(1,1) = 3;

vector<double> v2 = prod(m, v);

std::cout << v2 << std::endl;

#include <iostream>

#include <armadillo>

using namespace std;

using namespace arma;

vec v;

v << 2.0 << 5.0 << 2.0;

// endr represents the end of a row in a matrix

mat m;

m << 1.0 << 2.0 << endr

  << 2.0 << 3.0 << endr

  << 1.0 << 3.0 << endr;

cout << "Least squares solution:" << endl << solve(m,v) << endl;

// 这是一个标准的 C 函数

const char* greet()

{

    return "Hello, world";

}

// 使用如下代码对上述函数进行包装

#include <boost/python.hpp>

BOOST_PYTHON_MODULE(hello_ext)

{

    using namespace boost::python;

    def("greet", greet);

}

// 以下是调用该模块的 Python 代码

// import hello_ext

// print(hello_ext.greet())