ActiveMQ-CPP - a JMS-like API for C++ for interfacing with Message Brokers

CMS (stands for C++ Messaging Service) is a JMS-like API for C++ for interfacing with Message Brokers such as Apache ActiveMQ. ActiveMQ-CPP is a client only library, a message broker such as Apache ActiveMQ is still needed for your clients to communicate.

This implementation of CMS is called ActiveMQ-CPP, which has an architecture that allows for pluggable transports and wire formats. The OpenWire and Stomp protocols are supported, both over TCP and SSL and a Failover Transport for more reliable client operation. In addition to CMS, ActiveMQ-CPP also provides a robust set of classes that support platform independent constructs such as threading, I/O, sockets, etc.

ActiveMQ-CPP is released under the Apache 2.0 License

Operating Systems

Platform-independent

Compilers

Visual C++

GCC

Any standard C++ compiler

Added : 2011-09-06 Amended: 2011-09-06 Licensing : Open Source

ActiveMQ-CPP - a JMS-like API for C++ for interfacing with Message Brokers

ADAPTIVE Communication Environment (ACE) - C++ IPC wrappers

This release contains contains the source code, documentation, and example test drivers for a number of C++ wrapper libraries and higher- level distributed application frameworks developed as part of the ADAPTIVE project at the University of Calfornia, Irvine.

The C++ wrappers encapsulate many of the user-level BSD and System V Release 4 IPC facilities such as sockets, TLI, select and poll, named pipes and STREAM pipes, the mmap family of memory-mapped file commands, System V IPC (i.e., shared memory, semaphores, message queues), and explicit dynamic linking (e.g., dlopen/dlsym/dlclose) using type-secure, object-oriented interfaces.

The higher-level distributed application frameworks integrate and enhance the lower-level C++ wrappers to support the configuration of concurrent network daemons composed of monolithic and/or stackable services

A relatively complete set of documentation and extensive examples are included in the release. A mailing list is available for discussing bug fixes, enhancements, and porting issues regarding ACE. Please send mail to ace-users-request@ics.uci.edu if you'd like to become part of the mailing list.

ADBLib - Database lib for Visual C 6

ADBLib.dll provides some classes and routines to develop DAO(r) database
applications quickly using Microsoft Visual C 6.0, the important feature
of this library is,besides the power and coding speed, you can still
access DAO derived objects from your programs allowing you to accomplish
complex tasks when needed. To simplify your task when creating modeless
form, a simple tool ADBWizard has been added - it will automate the
process of base class substitution, so that you can create forms and add
them to your application very quickly.

stlab.adobe.com is the home of the Adobe Source Libraries (ASL) and information about other Adobe open source projects.
ASL provides peer-reviewed and portable C++ source libraries. The libraries are intended to be widely useful, leveraging and extending both the C++ Standard Library and the Boost Libraries.

Alcatraz - Software copy protection C++ library

Alcatraz is a C++ library that can be used to provide copy protection
capabilities to an application. You can create and distribute
time-locked trial versions and hardware-locked full versions of your
software. Both applications and components can be copy protected. The
license file is signed and encrypted to prevent tampering. A license
file generation program is provided along with the library. Online help
is included with the software.

Comment from : JS on 2015-04-03

AML++ is a matrix library which mimics most Matlab/Octave features and functions. It offers many different matrix classes (both real and complex including generic dense and sparse matrices, upper/lower triangular, symmetric, Hermitian and band).

Features:

Library interface resembles Matlab/Octave language, which makes it a
perfect tool if you wish to translate Matlab or Octave code to C++.

Amulet - User Interface Development Environment

AMULET is a user interface development environment in C++. Code written using Amulet will work with little or no changes on all platforms.

More than just another free "virtual toolkit," Amulet includes many features specifically designed to make the creation of highly-interactive, graphical, direct manipulation user interfaces significantly easier. Based on a proven earlier system, called Garnet, that was in wide use in the Lisp community, Amulet adds a number of important innovations and refinements.

Important features of Amulet include:

a dynamic, prototype-instance object system that makes prototyping easier

automatic constraint solving integrated with the object system

a "structured-graphics" model (also called a "display list") that handles automatic refresh of objects when the change

a high-level input model that makes it easy to add behaviors to objects and also supports undo and help for operations

a full set of flexible widgets implemented using the Amulet intrinsics, so you can easily experiment with your own widgets; and high-level interactive debugging tools. Widgets include:buttons, check boxes, radio buttons, menus, menu bars (pull-down menus), scroll bars, scrolling windows, and text input fields.

APE - Portable C++ threading and sockets framework

APE is the "APE Portable Environment" and class libraries for writing
portable threaded servers in C++, under UNIX (pthread) and Win32 API's.
APE provides portable class abstraction for threads and sockets, and
is used as a base framework for other projects. The goal of APE is to
make writing threaded servers in C++ both practical and convenient,
even for small and simple projects, and hence simplicity and low
runtime overhead are design goals.

The 1.0.0 release of APE is available at ftp://ftp.voxilla.org/pub/ape
with both source and pre-built binary packages. APE has been used
not only in server applications, but also in conjunction with client
class frameworks, such as QT/KDE, to offer threading and socket
services. APE is licensed under the GPL with additional priviledges
as annoted in the source under terms similar to Guile.

As of March 14th, 2000, the APE project was merged with the Common C++ project to form the newly introduced Common C++ portable application framework.

Arabica - SAX2 implementation

SAX is an event-based XML processing API. Arabica is a full SAX2 implementation, including the optional interfaces and helper classes. It provides uniform SAX2 wrappers for the Expat parser, Xerces, Libxml2 and, on Windows, for the Microsoft XML parser.

The DOM is a platform- and language-neutral interface which models an XML document as a tree of nodes, defined by the W3C. Arabica implements the DOM Level 2 Core on top of the SAX layer.

XPath is a language for addressing parts of an XML document. Arabica implements XPath 1.0 over its DOM implementation.

XSLT is a language for transforming XML documents into other XML documents. Arabica builds XSLT over its XPath engine.

Arabica is written in Standard C++ and should be portable to most platforms. It is parameterised on string type. Out of the box, it can provide UTF-8 encoded std::strings or UTF-16 encoded std::wstrings, but can easily be customised for arbitrary string types.

Arjuna - For writing fault-tolerant (distributed) applications

Arjuna provides a set of tools (C++ classes and libraries) for writing fault-tolerant distributed applications using persistent objects, atomic actions, and replication. Included in the system is a C++ stub generator (and associated RPC mechanism) which takes a C++ class definition for an object and generates client and server stub code. Using these stub classes occurs in a relatively transparent manner: the differences between a local and distributed application are typically only a single line.

The system has been ported to a wide range of architectures and C++ compilers, both by the authors and other users, and has been in use for several years.

A comprehensive manual is available with the distribution.

The system has been ported to a wide range of architectures and C++ compilers, both by the authors and other users, and has been in use for several years.

Armadillo - Armadillo linear algebra (matrix) library

The Armadillo C++ Library aims to provide an efficient base for linear algebra operations (matrix and vector maths), while at the same time having a straightforward and easy to use interface. To keep it relatively lean, it does not aim to provide a boilerplate of functionality, such as GNU Octave. Its intended target audience is scientists and engineers.
A delayed evaluation approach is employed (during compile time) in order to combine several operations into one and reduce (or eliminate) the need for temporaries. Where applicable, the order of operations is optimised. Delayed evaluation and optimisation are achieved through recursive templates and template meta-programming.

ATLAS - Automatically Tuned Linear Algebra Software

The ATLAS (Automatically Tuned Linear Algebra Software) project is an ongoing research effort focusing on applying empirical techniques in order to provide portable performance. At present, it provides C and Fortran77 interfaces to a portably efficient BLAS implementation, as well as a few routines from LAPACK.

b64 - base-64 Encoding and Decoding

Simple, lightweight, library for RFC-1113 compatible base-64 encoding and decoding. The core library is written in C, with a C-API. The C++ mapping offers a flexible facade over the C-API, and is 100 per cent header-only. All code is platform-independent.

Operating Systems

Compilers

BDE - Basic Development Environment - a set of foundational C++ libraries used at Bloo

What is BDE?

BDE (BDE Development Environment) is a set of C++ software libraries as well as development tools and methodology. Originally developed at Bloomberg L.P., BDE is intended to form the foundation for large scale C++ software products.

BSL (BDE Standard Library), the lowest level BDE library, provides implementations for portions of the C++ standard library, particularly the container types, as well as a suite of system utilities, meta-functions, and algorithms needed to build such containers.

BDL (BDE Development Library), the second BDE library currently provides concrete allocator implementations. This library is under active development and will eventually contain a collection of tools appropriate for a low-level library and application development.

Goals and Benefits of BDE

BDE aims to provide libraries that meet superior standards in terms of their design, documentation, and testing. Every component (i.e., .h/.cpp file pair) provides thorough component-, class-, and method-level documentation, including a compilable example for using that type. Every component also has a thorough test-driver that tests every public method of that component through a comprehensive range of input (see bslstl_map.t.cpp).

These libraries, along with the tools and methodology that accompany them, are meant to enable developers to create their own C++ software that meets similar standards of quality.

The BDE Standard Library (BSL)

BSL provides a finely factored collection of modules (or components) that form the foundation for cross-platform component-based development. The library culminates in the implementation of several standard containers that take advantage of the features of the rest of BSL. Some of the highlights of BSL include:

The BDE Development Library (BDL)

BDL is under active development, and will eventually contain a wide range of facilities needed for common development tasks. For example, date and time types, specialized containers, thread pools, event schedulers, and file system utilities. The current highlights of BDL include:

Value types and utilities for manipulating dates and times.

Of particular note bdlt::Date, bdlt::Datetime, bdlt::CurrentTime

See bdlt

Additional concrete implementations of the allocator interface defined in BSL

(see bdlma)

Value types and utilities that support decimal floating point arithmetic (IEEE754-2008) (see bdldfp and bdldfp_decimal)

These types are is useful where exact representations of decimal fractions are required (e.g., financial transactions).

Better Enums is a single header file that makes your compiler generate reflective enums. These support conversion to and from string, iteration, stream operators, and have other helpful properties.

Typically, maintenance effort or external tools are required to keep enum definitions synchronized with associated string tables and other "metadata." Better Enums eliminates these needs. In addition, the output of Better Enums can be further used in your own template metaprograms and constexpr functions.

Better Enums has no dependencies beyond the standard library. It requires either C++98 with the __VA_ARGS__ extension (long supported by most major compilers), or C++11. The library is tested automatically on many versions of Clang, GCC, and MSVC, optimized for compilation speed, and thoroughly documented.

Comment from : js on 2015-04-03

Blitz++ - Scientific computing in C++

Blitz++ is a C++ class library for scientific computing which provides performance on par with Fortran 77/90. It uses template techniques to achieve high performance. The current versions provide dense arrays and vectors, and small vectors and matrices.

Boost provides free peer-reviewed portable C++ source libraries.
Boost emphasizes libraries that work well with the C++ Standard Library. Boost libraries are intended to be widely useful, and usable across a broad spectrum of applications. The Boost license encourages both commercial and non-commercial use.
Boost aims to establish "existing practice" and provide reference implementations so that Boost libraries are suitable for eventual standardization. Ten Boost libraries are already included in the C++ Standards Committee's Library Technical Report (TR1) and will be in the new C++0x Standard now being finalized. C++0x will also include several more Boost libraries in addition to those from TR1. More Boost libraries are proposed for TR2.
Boost works on almost any modern operating system, including UNIX and Windows variants. Follow the Getting Started Guide to download and install Boost. Popular Linux and Unix distributions such as Fedora, Debian, and NetBSD include pre-built Boost packages. Boost may also already be available on your organization's internal web server.

Botan - crypto library for C++

Botan is a BSD-licensed crypto library for C++. It provides applications with most any cryptographic algorithm you might be looking for, along with Transport Layer Security (TLS), X.509 certificates and CRLs, a pipeline-style message processing system, and a wide variety of other features. A third party open source implementation of SSHv2 that uses botan is also available. In addition to C++ you can use botan from Python or Node.js or Perl, though the current bindings only wrap portions of the library.

BRL10 - Binary Relations Library for C/C++

Binary relations are more directly based on semantic
concepts rather than on recordlike structures as traditional
(relational, hierarchies, networks, object-oriented) models are.

Binary Relations tend to be more functionally complete
in their information processing capability, and more precise in
their semantic modelling.

The Binary Relations Approach was implemented in Binary
Relations Library for C/C++. BRL is not a full featured DBMS.
It does not support all ideas of the Binary Relations Approach.
BRL is however a small, fast and reliable engine.

BRL provides basic tools for using binary relations in C and C++
programs.

The C++ Portable Components are a collection of class libraries for
developing network-centric, portable applications in C++. The classes
integrate perfectly with the C++ Standard Library and cover
functionality like threads, thread synchronization, filesystem access,
streams, shared libraries and class loading, sockets and network
protocols (HTTP, FTP, SMTP, etc.), including an HTTP server, as well as
an XML parser with SAX2 and DOM interfaces.

The C++ Portable Components are available on a variety of platforms.
All major desktop and server platforms are supported, including Windows
XP, Mac OS X, Linux, HP-UX, Tru64, Solaris and OpenVMS, in addition to
Windows CE and POSIX-compliant embedded operating systems.

For use in open-source projects, the C++ Portable Components are
available for free under an open-source license. Non open-source
commercial use requires a separate license.

C++ Sockets Library - Unix / Windows Socket programming made easy

When making this library, there were a few things I wanted to achieve. I did not want to end up with C++ code that had to be used in the same way as the berkeley socket C API are being used ( connect/bind/accept - check result, write - check result, read - check result, etc, etc ). Another thing was the ability to manage multiple sockets in the same thread; the library should be singlethreaded - but not limited to one thread. So.. I never wanted to manage a fd_set for a select() call ever again, no more writing code for accepting a connection - this has already been done again and again in every single networking project ever made.

One decision made early on was to treat one socket as one object. And so was the Socket class born. The socket class, by itself, has all the functions needed for address translation (hostname to ip, ip to hostname etc). It owns the file descriptor / SOCKET handle. But it can't do anything. Code for actually doing something with the socket is implemented in other, Socket derived classes.

C++/Tk - A complete interface to the Tk GUI toolkit.

C++/Tk is a complete C++ interface to the popular Tk GUI toolkit, known from many scripting languages, like Tcl, Python or Perl. The C++/Tk library uses templates and operator overloading to achieve syntactic similarity to Tcl/Tk code.

C++SIM 1.5.2 - A simulation package written in C++.

C++SIM provides discrete process based simulation similar to that provided by the simulation class and libraries of SIMULA. The linked list manipulation facilities provided by SIMSET are also included in the package, and there is support for a variety of statistics gathering classes.

The simulation package requires the use of a threads package and currently only works with the following:

Sun's lwp threads and Solaris threads

C++ task library

NT threads

Posix threads

cthreads

Rex threads

It has been build on a number of different architectures and C++ compilers, and porting to other systems should be relatively easy.

C/C++ cyclic logs - Record log information

Cyclic logs provide a platform-independent way for a server to record
stdout and stderr such that the most recent information can be
retained in a logfile without such logfiles growing in size such that
they might fill the disk up. A cyclic log has a fixed size upon
creation and a structure that allows older data to be overwritten on
the arrival of new data to be logged.

It consists of a C++ library, a C library, a set of commands and a user
manual.

CalcPlus - Interpreter of procedural language

The CalcPlus library is the C++ class library which provides an ability to use your own programming language built into C++ project. Any algorithm or any constant needed by application can be carried out into the special file, when process comes to the key point, it calls function or procedure stored in the text file. Interpreter runs the function and process returns back to C++ code. Library contains the interpreter which understands simple nameless procedural language. Bi-directional communication between C++ and the code for interpreter available.

Version of the language that comes with the library allows to use functions, procedures, blocks, preprocessor, global and local variables and constants, if/for/while statements. Each variable can have value of type: nil, bool, long, float, string, date. Type definitions and arrays are allowed. Functions and procedures may be recursive. New functions written in C++ may be easily added to the language. Syntax of the language can be modified by changing YACC rules. Interpreter is fast enough and may be helpful for many tasks.

CBMT - Collaborative BioMolecular Tools

CBMT provides a number of easy-to-use fundamental classes for biologists, chemists and crystallographers. They include: Molecular Structure, Sequence, Standard Formats (PDB, CIF, GCG, etc), Geometry, Statistics, TextParsing, and a single container class (a dynamic Array). All documentation is in HTML, and member functions have *.c examples. I hope that the system can be extended as a communal effort and am piloting this idea in the C++ course at the Globewide Network Academy

Version 1.3 will be posted shortly including an experimental script language (generated automatically from the *.h files) providing support for persistent objects manipulatable by other languages such as tcl or csh.

CDBFile - C++ library to handle dBASE III files

CDBFile is a C++ object-oriented package for programmers who need to
manipulate dBASE III files in their programs. It enables you to perform
many operations on an existing DBF file: reading/writing to it, accessing
its values, sorting the records, adding/deleting records, etc. It comes
with full text and postscript documentation, and commented source code.
A demonstration program, TestDBF, shows the various possibilities of the
CDBFile library, and its source file, testdbf.cpp, demonstrates how to
implement CDBFile within a program. CDBFile was designed to be as
portable as possible: you should be able to compile it under "as is" any
DOS/Windows C++ compiler; porting it to Un*x/Linux should also require
little effort.

Since CDBFile is distributed under the GNU Public License for libraries,
I hope that programmers will like it and suggest or implement enhance-
ments and additional features to that piece of software.

Operating Systems

Compilers

Cgipp - Very Portable and powerful CGI-Library

Cgipp is a small class library which eases the creation of applications for the World Wide Web, and gives you an easy but powerful interface to the CGI interface which will increase your productivity when writing CGI-applications. The Cgipp also provides a class to ease your creation of HTML-pages which can be used as any ostream.

The library is highly portable, and can be used with no problems on any unix-system
using gcc/g++, and has also been tested with SGI C++ and Sun CC. The library
has also been succesfully ported to PCs (both 16-bit DOS and 32-bit DOS/Windows).

Comment from : JS on 2015-04-03

ClassBuilder - ClassBuilder 1.1 OOD C++ code generator

ClassBuilder is an Object Oriented C++ front end to your compiler. It
lets you create, manipulate and navigate classes, class relations, class
members and class methods at a high level of abstraction trough a
graphical user interface. Features include:

Full code generation for the defined relations and their associated
find methods.

Wizards to insert code, like iteration loops and navigation paths.

Code synchronization with compile environment.

Full code generation for serializing the complete data model when used
together with MFC. (The tool is build with itself and uses this
feature to save to and read from file).

Drag and drop support for many things. Adding a member to a class is
just drag with holding down the Ctrl-key and then drop it on the
desired class.

CLN - a Class Library for Numbers

CLN is a library for computations with all kinds of numbers. It has a
rich set of number classes, including integers (with unlimited precision),
reals with various precisions (including unlimited), rationals, complex
numbers and polynomials. The kernel is written in assembly language, in
addition it can easily be configured to use the superefficient GNU MP
low-level functions. CLN uses garbage collection (automatic, without
imposing any burden on the main application). Many extremely efficient
algorithms (i.e. for all transcendental functions) are implemented.

CMATH - Complex-number math library for Borland C/C++

CMATH is a comprehensive library for complex-number arithmetics and
mathematics. In contrast to C++-written complex class libraries, this
true Assembler implementation ensures superior computational efficiency,
mathematical accuracy and safety.
All functions exist in two alternative forms:

a C++ form with overloaded function names, like sin, exp, operator
/;

a plain-C form with data-type specific function names, like cf_sin,
cd_exp, ce_div, where the prefix determines the level of accuracy
(complex float, double, or extended).

Changes: The necessary adjustments have been made for CMATH to work with
the new version 4 of BCBuilder, while maintaining compatibility
with the older BC++ versions. Slight improvements with respect
to speed and accuracy have also been made for the forward and
inverse trigonometric functions.

CmdLine - command-line option and argument parsing framework

CmdLine is a full-featured C++ class framework for parsing options and arguments from the command line. Abstract and concrete classes are provided for the command-line, options, arguments, and argument iterators, and the user may add their own specialized argument/option types using subclasses.

Comet - A C++ template library for COM programming

Comet is a language binding between COM and C++. It allows you to do both COM client and COM server programming, without any dependency on either ATL or MFC. In other words Comet is a replacement for ATL.

Common C++ - A GNU Portable Application Framework

Common C++ is a C++ framework offering portable support for threading, sockets, file access, deamons, persistance, and system services, initially started by David Sugar and Daniel Silverstone. Common C++ is a GNU package and is licensed to the terms of the GNU GPL with specific privileges similar to Guile.
Common C++ offers support and portable classes for threading and sockets for both UNIX (Posix systems with "pthread" support) and the Windows "Win32" API. Common C++ uses extensive autoconf macro sets for automatic detection of various levels of "pthread compliance" in your target platform and attempts to adjust itself appropriately. Common C++ has been tested to date with GNU/Linux, FreeBSD, Solaris, and DEC Tru64 Unix. HP/UX has also been tried and found not to be successfully supported at this time.

While Common C++ is not directly related to GNU portable threading (GNU Pth), it should work with the Pth "pthread emulation" library at present. Common C++ will become usable as a class framework for GNU Pth directly in future releases.

The primary goal of Common C++ is to promote a very low overhead abstract C++ interface to common system services. Consistent with this goal, and the desire for broad portability with wide compiler support, specific aspects and practices in C++ programming were selected when writing code in this package, and other practices were discarded that seemed to detract from this goal.

Compilers

Complex class - Very complete complex generic class

The Complex Library gives you the possibility to do complex arithmetic as simply as real arithmetic in your C++ sources. The class Complex is designed with generic code, allowing you to do single or double floating point arithmetic (default is double). All the algorithms favour numerical stability first and speed secondly. You can download the postscript documentation complex.ps.gz [40 Ko] alone or dowload the complete package (including the documentation) complex.tgz. [47 Ko]

Conical - C++ classes for building neural networks

CONICAL is a cross-platform library of C++ classes for building biologically realistic simulations of neurons or small neural networks. Its capabilities are similar to large Unix-based packages such as GENESIS and NEURON, but produces simulations which are smaller, faster, and easily imbedded in other applications.

CONICAL is still under development, but documentation is fairly complete and includes both introductory material and demo programs.

This library is aimed at those who use C++11 language in any platform to write software which uses values provided of unit of measurement, like, for example, lengths measured in metres or inches, or angles measured in degrees or radians.

Specifically, it addresses software for CAD-CAM-CAE and 3D computer games.

Comment from : JS on 2015-04-03

Open source (Mozilla 2 licence) C++98 library that encapsulates memory-mapped files for all POSIX-compliant operating systems, and for Microsoft Windows operating systems starting from Windows 95.
It is similar in purpose and run-time speed to the "Memory-Mapped Files" library of Boost, but it is much faster to compile (about 5 times in Linux), and generates much smaller executable code (less than a third in Linux).

CSLIB - Database library for C++ developers

A series of C++ classes in combination with a program generator is used
to build databases with automatically updated indexes, access to fields,
support for DATE fields, exporting to dBASE and so on. It also contains
classes for variable-length records, virtual heaps, btrees etc. Some
helpful utilities are included as well. CSLIB produces stand-alone
executables. It is NOT just an interface to some central database
server.

Cvmath.cc - An include file to make complex math look like regular math.

The file uses a lot of operator overloading, so that if x=a+ib and y=c+id, the code for multiplying the two together looks like z = x*y; Also, the file includes nrutil from Numerical Recipes, and adds the complex versions for vectors and matrices.

Added : 1995-01-01 Amended: 1995-01-01 Licensing : Not known

Cvmath.cc - An include file to make complex math look like regular math.

Copyright (c) 2019 Nikki Locke, Trumphurst Ltd.
Permission is granted to distribute over the Internet without charge.
The author's permission is required (and usually given) to distribute
in any other way, including on CD.