Available C++ Libraries FAQ

Libraries available to download (D-L)

DaoLib - Static library for C++ DAO database access

DaoLib v2.0 provides a communication layer between user interface elements and underlying database objects. It consists of a complete COM proxy wrapper, a set of DAO/GUI classes and a list control dialog component. The Visual C++ developer can take advantage of its simple interface for building dialog-intensive and property sheet-intensive database applications, without the burden and overhead of the MFC DAO implementation. In addition, it provides automatic recordset listing with sorting facilities and complete printing support.

Operating Systems

  • PC 32-bit Windows

Compilers

  • Visual C++

Added : 1999-06-04 Amended: 1999-06-04 Licensing : Shareware

Add a comment

Database Template Library Programmer's Guide - The DTL makes ODBC recordsets look just like an STL container.

The goal of this library is to make ODBC recordsets look just like an STL container. What is more, we do this portably so the abstraction can run on multiple platforms and C++ compilers. As a user, you can move through our containers using standard STL iterators; and if you insert(), erase() or replace() records in our containers changes can be automatically migrated to the database for you. The library's compliance with the STL iterator and container standards means you can plug our abstractions into a wide variety of STL algorithms for data storage, searching and manipulation. In addition, the C++ reflection mechanism used by our library to bind to database tables allows us to add generic indexing and lookup properties to our containers with no special code required from the end-user. Because our code takes full advantage of the template mechanism, our library adds minimal overhead compared with using raw ODBC calls to access a database.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Any standard C++ compiler

Added : 2009-09-28 Amended: 2009-09-28 Licensing : Open Source

    Database Template Library Programmer's Guide - The DTL makes ODBC recordsets look just like an STL container.
  • DTL Homapage
  • Submitted by:Kizza George Mbidde
Add a comment

dbstreams - database interface library modelled on std::iostreams

dbstreams is C++ class library modelled on std::iostreams in the C++ standard library. It treats a database connection as a source or sink for data. The basic operations are the same as for iostreams: open, close, read, and write (but not seek). State information similarly borrows from std::ios: a stream has a state word with enumerated values: goodbit, badbit, failbit, eofbit. And the notation is largely the same, with operator<< and operator>> serving the purpose of sending data to and reading data from the database. In general, the design mimics iostreams, permitting the same kind of terse, economical code.

Operating Systems

  • Any after making small changes...

Compilers

  • Any Unix C++ compiler

Added : 2012-02-05 Amended: 2012-02-05 Licensing : BSD style

    dbstreams - database interface library modelled on std::iostreams
  • home page
  • Submitted by:James K. Lowden
Add a comment

Depression Glass Debug Library - DGD

Depression Glass Debug (DGD) is simple, easy to use C++ ostream extension for debugging output. DGD is created with a goal to produce nice, readable and easy to understand trace logs.

Operating Systems

  • Linux
  • PC 32-bit Windows

Compilers

  • Visual C++
  • GCC

Added : 2003-04-09 Amended: 2008-07-22 Licensing : GNU copyleft

Add a comment

Developer - Smart Pointers

smart_ptr is a smart pointer policy class that can use different ownership logic and semantic polices, which allows the developer to get the best performance and/or interface for a particular requirement.

The smart_ptr class can be used with STL containers to create containers of smart pointers, moreover it can be used to create a container of abstract based objects via smart_ptr. In general, smart_ptr is faster than boost::shared_ptr. When used with STL containers, the smart pointer is faster than the boost pointer containers, and more generic.

Operating Systems

  • PC DOS
  • Linux
  • PC 32-bit Windows
  • Sun
  • IBM AIX
  • Solaris
  • HP UX
  • OS/2
  • Unix
  • Dec Alpha
  • PC Windows
  • Dec OSF/1

Compilers

  • Visual C++
  • GCC
  • Dec CC
  • IBM xlC
  • Borland C++
  • HP C++

Added : 2006-03-14 Amended: 2006-03-14 Licensing : Public Domain

Add a comment

Developer - EzLogger

EzLogger is a C++ logging library that can easily be added to an implementation. It can be used with both C++ style stream operators and C style printf functions.

Operating Systems

  • PC DOS
  • Linux
  • PC 32-bit Windows
  • Sun
  • IBM AIX
  • Solaris
  • HP UX
  • OS/2
  • Unix
  • Dec Alpha
  • PC Windows
  • Dec OSF/1

Compilers

  • Visual C++
  • GCC
  • Dec CC
  • IBM xlC
  • Borland C++
  • HP C++

Added : 2006-03-14 Amended: 2006-03-14 Licensing : Public Domain

Add a comment

DiamondBase - Add Relational Database functionality to your C++ programs

DiamondBase is a library of C++ routines and utilities that allow you to add Relational Database functionality to your C++ programs. It is written entirely in C++, and great pains have been taken to ensure it compiles under a variety of compilers. It comes with a 47 page manual.

Operating Systems

  • OS/2
  • Unix

Compilers

  • GCC
  • Cfront
  • Borland C++

Added : 1995-01-01 Amended: 2008-07-22 Licensing : Not known

Add a comment

die-xml - C++11 xml sax parser based on finite automata

a simple XML SAX parser that uses finite automata as backend.

http://code.google.com/p/die-xml/wiki/FiniteAutomaton has the automaton definitions

Features:

  • parse all kinds of XML tags
  • C++11 API
  • SAX event based interface generating the following events:
    • start document
    • end document
    • start tag
    • end tag
    • characters (including CDATA)
    • processing instruction
    • notation/element definition
  • AttributeIterator class for start document and start tag events. This allows the application to pull attribute values during the event and avoids unnecessary buffering for undesired tags
  • CharIterator class for characters event. This allows the application to pull chars during the event and avoids unnecessary buffering for undesired text nodes
Bonus Track
  • FiniteAutomata class template that can be extended to a Mealy Machine
  • a lightweight implementation of boost::optional<> with storage policy support
TBD
  • entities decoding
  • UTF-8 support (and other encodings too)
  • support configuration for ignorable white space on text nodes
Missing
  • DOM parser (can be easily built over SAX)
  • DOCTYPE validation
  • namespaces
  • text nodes outside tags
  • does not check duplicate notation and element definitions. These are handled by application events only

Operating Systems

  • Platform-independent

Compilers

  • Any standard C++ compiler

Added : 2014-10-06 Amended: 2014-10-06 Licensing : MIT

    die-xml - C++11 xml sax parser based on finite automata
  • project repository
  • Submitted by:Jose Diego Ferreira Martins
Add a comment

Dinkum Compleat Library - Standard C++, C99, and Embedded C++

The Dinkum Compleat Library combines our popular C/C++ libraries in one highly portable and flexible package. You get: -- the Dinkum C++ Library, the only library that fully conforms to ISO 14882:1998, as corrected through 2003, including support for export templates -- the Dinkum C99 Library, conforming to ISO 9899:1998, as corrected through 2003, even on compilers that don't fully support C99 -- C++ library TR1, the only complete implementation of C++ TR19768 -- the libraries mandated by all other C and C++ TRs, including C TR18037 (fixed-point arithmetic for DSPs) and C TR19768 (UTF-16 and UTF-32 data types) -- the Dinkum EC++ Library, the only add-on library that conforms to the EC++ Technical Committee specification -- the Dinkum Abridged Library, which combines EC++ with the STL portion of our C++ library -- a portable multithreading library compatible with boost.threads in C++ and with Posix pthreads in C -- a number of memory allocators for STL node-based containers, offering a variety of memory-management strategies and multithreading options -- dozens of conversions between Unicode and popular multibyte character encodings, including Chinese, Japanese, and Korean large character sets -- common extensions to the Standard C and C++ libraries to simplify adapting code written for Linux, Unix, Windows, and pre-standard dialects -- dozens of C locales to adapt to all major American and European cultures The library can be built from source code for use with a native C library, with ``safe iterator'' debugging enabled, and with exceptions disabled. It has been tested extensively on most popular compilers. It is available in both source, with ongoing support, and binary packages, for all current versions of Microsoft VC++, eVC++, and GCC. Each package includes online references in HTML. You can browse the references, and compile test programs against the library, at our web site. Compilers Current versions of Microsoft VC++ and eVC++ (V6 through V8) Current versions of GCC (V3.x and V4.x) Compilers with Edison Design Group front end

Compilers

  • Visual C++
  • GCC
  • Visual C++ 6
  • Visual C++ .NET

Added : 2006-07-03 Amended: 2006-07-03 Licensing : Commercial

Add a comment

dlib C++ library - A portable C++ toolkit

This is a C++ library of portable sockets, threading, GUI, and directory browsing APIs as well as many container classes and other items such as a big integer, a log4j style logger, arithmetic coder, other compression related classes and much more.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Solaris
  • Unix
  • X Windows
  • PC Windows
  • Mac

Compilers

  • Visual C++
  • GCC
  • Borland C++

Added : 2006-12-21 Amended: 2006-12-21 Licensing : Copyright (other)

Add a comment

Doctor Matrix - Matrix and vector algebra package for C++

Doctor Matrix is a matrix and vector algebra package for C++. It allows the C++ programmer to perform calculations on matrices and vectors within C++ programs. Over 50 functions are supported, including ranking, determinant calculation, matrix addition and multiplication, inversion, and more. Comprehensive documentation provides instructions for use of all functions and mathematical definitions of their purpose. Shareware version is limited to DOS programming in Borland C++ and for Tiny or Small memory models.

Special requirements: The Shareware version supports compilation only under Tiny or Small memory models. Borland C++ compiler recommended.

Operating Systems

  • PC DOS

Compilers

  • Borland C++

Added : 1997-03-19 Amended: 1997-03-19 Licensing : Shareware

Add a comment

DOSTmUit - DOS Text Mode User Interface Toolkit

Enables C++ programmers to add a CUA-compliant user interface to their DOS programs without getting involved in screen coordinates and other messy details. The programmer merely states which interface objects are required, and how they are to be placed on the screen in relation to each other. Those familiar with the ET++ toolkit for the X windows system under Unix will get the general idea.

Includes a class documentation facility (DocClass) which will generate a large text file from the source code giving details of every class, structure, enum and extern in the toolkit. This program will also work on your own C++ source code. Source is provided.

Operating Systems

  • PC DOS

Compilers

  • Borland C++
  • Zortech C++

Added : 1995-01-01 Amended: 2008-07-22 Licensing : Non commercial

Add a comment

Drat - A C++ interface to the curses library

Drat contains several classes for interfacing with the UNIX curses library, including menus with callback's, and other common forms.

Added : 1996-02-05 Amended: 2006-12-02 Licensing : Not known

Comment from : Matthew Chaplain on 2009-07-02

Dead link.

Add a comment

dxflib - dxflib is an open source C++ library mainly for parsing DXF files.

dxflib is a C++ library for reading and writing DXF files. When reading DXF files, dxflib parses the file and calls functions that you define in your own C++ class for adding entities, layers, ...

Please note that dxflib does not store any entities or other information for you. It only passes the supported entities and other objects found in the DXF file to your C++ class.

Using dxflib to read DXF files doesn't require any knowlege of the DXF format. However, it's still an advantage to know the basics about entities, attributes, layers and blocks. To write DXF files with dxflib you definitely need an idea of how a DXF file is organized.

dxflib does not depend on any exotic other libraries, just the standard C / C++ libraries.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Unix
  • Mac
  • POSIX

Compilers

  • could be compiled, but not tested

Added : 2010-11-09 Amended: 2010-11-09 Licensing : GNU copyleft

    dxflib - dxflib is an open source C++ library mainly for parsing DXF files.
  • Homepage
  • Programmer's guide
  • Submitted by:Domenic Laritz
Add a comment

DynaMix - A New Take on Polymorphism in C++

DynaMix [ˈdainəˌmiks] (Dynamic Mixins) is a library that allows composition and modification of polymorphic types at run time.

The library is a means to create a project's architecture rather than achieve its purpose. It focuses on maximum performance and minimal memory overhead.

DynaMix is great for the software architecture of systems with very complex objects including, but not limited to:

  • Games (especially role-playing ones or strategies)
  • CAD systems
  • Enterprise systems
  • UI libraries

The library uses the type dynamix::object as a placeholder, whose instances can be extended with existing classes (mixins), thus providing a particular instance with the functionality of all those types. Accessing the newly formed type's interface is made through messages – stand-alone functions generated by the library, which can be thought of as methods.

Here is a small example of what your code may look like if you use the library:

    // assuming my_objects.get_ally(0); is a way to get an ally to the
    // main character in a game

    dynamix::object& obj = my_objects.get_ally(0);

    // now let's make the object think some positive thoughts about the
    // main character

    think(obj); // C++ doesn't allow us to have obj.think()
                // DynaMix's messages are standalone functions

    // type composition
    dynamix::mutate(obj)
        .add();

    // object can now respond to fly()

    fly(obj); // ...instead of obj.fly()

    // type mutation
    dynamix::mutate(obj)
        .remove()
        .add();

    think(obj); // the same object now thinks negative thoughts about the main
                // character, since it's no longer an ally, but an enemy

Key features of the library:

  • Compose types from mixins at run time
  • Physically separate interface and implementation
  • Fast polymorphic calls – comparable to std::function
  • No external dependencies other than the standard library
  • Non-intrusive mixins don't need to have a common parent or any special code inside
  • Mutate "live" objects by changing their composition at run time
  • Have multicast messages, which are handled by many mixins within an object
  • Possibility to have custom allocators to finely tune the memory and aim for cache-locality for critical parts of the code
  • Ability to have dynamic libraries that can enrich or modify objects, without modifying, or even rebuilding, the executable
  • Thread safe message calls – as thread safe as the underlying methods.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Unix
  • PC Windows

Compilers

  • Visual C++
  • GCC
  • Any Unix C++ compiler
  • Any standard C++ compiler

Added : 2017-03-10 Amended: 2017-03-10 Licensing : MIT

Add a comment

eigen - C++ template library for linear algebra: vectors, matrices & related algorithms

Eigen is a C++ template library for linear algebra: vectors, matrices, and related algorithms. It is:
  • Versatile. (See modules and tutorial). Eigen handles, without code duplication, and in a completely integrated way:
    • both fixed-size and dynamic-size matrices and vectors.
    • both dense and sparse (the latter is still experimental) matrices and vectors.
    • both plain matrices/vectors and abstract expressions.
    • both column-major (the default) and row-major matrix storage.
    • both basic matrix/vector manipulation and many more advanced,
    • specialized modules providing algorithms for linear algebra, geometry, quaternions, or advanced array manipulation. various numeric types out of the box, including std::complex numbers, while being easy to extend to custom numeric types.
  • Fast. (See benchmark).
    • Expression templates allow to intelligently remove temporaries and enable lazy evaluation, when that is appropriate -- Eigen takes care of this automatically and handles aliasing too in most cases.
    • Explicit vectorization is performed for the SSE (2 and later) and AltiVec instruction sets, with graceful fallback to non-vectorized code. Expression templates allow to perform these optimizations globally for whole expressions.
    • With fixed-size objects, dynamic memory allocation is avoided, and the loops are unrolled when that makes sense.
    • For large matrices, special attention is paid to cache-friendliness.
  • Elegant. (See API showcase). The API is extremely clean and expressive, thanks to expression templates. Implementing an algorithm on top of Eigen feels like just copying pseudocode. You can use complex expressions and still rely on Eigen to produce optimized code: there is no need for you to manually decompose expressions into small steps.
  • Compiler-friendy. Eigen has very reasonable compilation times at least with GCC, compared to other C++ libraries based on expression templates and heavy metaprogramming. Eigen is also standard C++ and supports various compilers.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Visual C++
  • GCC
  • Sun CC
  • Intel C++

Added : 2009-11-25 Amended: 2009-11-25 Licensing : Open Source

    eigen - C++ template library for linear algebra: vectors, matrices & related algorithms
  • Homepage
  • Submitted by:Anonymous
Add a comment

EO - Evolutionary computation library

EO (Evolvable|Evolutionary objects) is a C++ toolbox for evolutionary computation which defines interfaces for many classes of algorithms used in evolutionary computation, and, at the same time, provides some examples that use those interfaces. The client/user can include those objects in his or her programs, or create their own. If new objects are created, the GeNeura team commit themselves to test them, and make them available to the Evolutionary Computation community. In this way, no changes have to be made to the library design or to a program that implements an EC algorithm: just new classes added. Our intention would be that, in the future, somebody implementing an EC algorithm would say "I am using EO, plus a class that hs been made publicly available", improving repeatability of EC results and easing its availability.

It contains classes for any kind of evolutionary computation you might come up to, except maybe genetic programming. Here are its features

  • Chromosomes: Can be defined by the user; binary, floating point and string are provided. All algorithms defined work on all kind of chromosomes.
  • Genetic operators: Can be defined by the user. Several floating point, bitstring, and generic operators are defined, like mutation, crossover, and things like that.
  • Selection/elimination procedure: Can be defined by the user. Steady-State and rank-based are provided.
  • Reproduction procedure: Can be user defined (I'll skip that from now on, but everything can be user-defined). Random and rank-based are provided.
  • Termination conditions: (user-definable) fitness and generation-based.
  • Algorithms: Easy Ga, SimpleGA and simulated annealing with user-definable cooling schedule.
  • Some utilities: command-line parsing, random-number generations
  • Examples: examples that test all features, plus genetic mastermind.
  • User interface: an example that uses gtk is provided
  • Documentation in html.

RELEASES:

New releases are made almost every day. Check at the site. Probably, cvs access will be provided in the future.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Solaris
  • Irix

Compilers

  • Visual C++
  • GCC
  • CygWin

Added : 1998-07-24 Amended: 2008-07-22 Licensing : Copyrighted freeware

Add a comment

Fast Light Toolkit - GNU LGPL GUI toolkit for X11 and Windows

FLTK (pronounced "fulltick") is a LGPL C++ graphical user interface toolkit for X (UNIX&reg;), OpenGL, and WIN32 (Microsoft&reg; Windows&reg; NT 4.0, 95, or 98). It is currently maintained by a small group of developers across the world with a central repository in the US.

FLTK was originally created to build in-house applications at Digital Domain for image processing and 3D graphics. The original author, Bill Spitzak, received permission from Digital Domain to release it to the public domain in the hopes that it could be used to make better, faster, and nicer-looking UNIX programs. Digital Domain has since withdrawn support for FLTK, but Bill is still able to work o!n it from time to time. FLTK was designed to be small and modular enough to be statically linked. FLTK also works fine as a shared library and has started being included on Linux distributions.

Here are some of the core features unique to FLTK:

  • sizeof(Fl_Widget) == 40 to 48
  • The "core" (the "hello" program compiled & linked with a static FLTK library using gcc on a 486 and then stripped) is 110k.
  • The FLUID program (which includes every widget) is 372k.
  • Does not use macros, templates, multiple inheritance, or exceptions.
  • Written directly atop Xlib (or the WIN32 API) for maximum speed, and carefully optimized for code size and performance.
  • Precise low-level compatibility between the X and Windows version (only about 10% of the code is different).
  • Interactive user interface builder program. Output is human-readable and editable C++ source code.
  • Support for overlay hardware (emulation if none and under Windows)
  • Very small & fast portable 2-D drawing library to hide Xlib and WIN32
  • OpenGL/Mesa drawing area widget
  • Support for OpenGL overlay hardware on both X and Windows. Emulation if none.
  • Text input fields with Emacs key bindings, cut & paste, and foreign letter compose!
  • Compatability header file for the GLUT library
  • Compatability header file for the XForms library

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Sparc
  • SGI Irix
  • IBM AIX
  • Solaris
  • HP UX
  • OS/2
  • Unix
  • X Windows
  • SYSV
  • Dec Alpha
  • SCO Open Desktop
  • Unisys Unixware
  • Dec OSF/1

Compilers

  • Visual C++
  • GCC
  • Sun CC
  • IBM xlC
  • SGI NCC
  • MetroWerks CodeWarrior
  • Borland C++
  • HP C++
  • Any standard C++ compiler

Added : 2000-04-26 Amended: 2000-04-26 Licensing : GNU copyleft

    Fast Light Toolkit - GNU LGPL GUI toolkit for X11 and Windows
  • FLTK Home Page
  • Submitted by:mike@easysw.com
Add a comment

FastFormat - 100% type-safe, infinitely extensible, very high performance C++ format library

FastFormat is an open source C++ formatting library, whose design parameters are 100% type-safety, efficiency, and flexibility. It is simple to use, highly-portable (platform and compiler-independent), and is infinitely extensible.

FastFormat supports output/formatting of statements of arbitrary complexity, consisting of heterogeneous types. It provides two APIs:

  • Format: provides replacement-based formatting, like Streams (printf()-family), Boost.Format()
  • Write: provides concatenation-based formatting, like IOStreams

FastFormat writes to output "sinks", which can be of arbitrary type. It implicitly supports any type that is structurally conformant with the standard library's string, and the library includes adaptors to allow writing to:

  • std::ostream
  • FILE*
  • STLSoft's auto_buffer
  • C-style string buffers and character buffers
  • ACE's ACE_String
  • ATL's CComBSTR
  • MFC's CString
  • std::stringstream
  • speech (currently Windows-only)
  • Windows' OutputDebugString()
  • Windows' MessageBox()
Adaptation to a new type requires the definition of a single function.

FastFormat is robust. Both APIs are 100% type-safe - something no other C/C++ widely-used formatting library can claim - and with the Write API it is impossible to compile defective code.

FastFormat is fast. The processing of each statement involves at most one memory allocation to hold the entire statement, and each statement element is measured and copied exactly once. As a consequence, the library is on a par with (the type-unsafe) C's Streams (printf()-family) of functions, faster than C++'s IOStreams (by 2-10x) and Loki.SafeFormat (by 1-5x), and considerably faster than Boost.Format (by 5-17x).

FastFormat supports I18N/L10N by using numbered arguments, enabling reordering of arguments by exchanging format strings. The library comes with a number of resource bundles, classes whose instances can load sets of localised resource strings for use as format strings.

FastFormat does not contain any compiler-specific or platform-specific constructs. It supports UNIX (including Linux and Mac OS-X), and Windows, and should work with any operating system. It is known to be compatible with Comeau (4.3.3+), GCC (3.4+), Intel (8+), Metrowerks (8+), Microsoft Visual C++ (6.0+), and should work with any reasonably modern C++ compiler.

FastFormat is completely free and includes source released under a BSD-style license. Commercial customisations and related consultancy are provided by Synesis Software.

FastFormat features in a series of articles in ACCU's peer-reviewed Overload magazine:

  • An Introduction to FastFormat, part 1: The State of the Art, Matthew Wilson, Overload #89, February 2009
  • An Introduction to FastFormat, part 2: Custom Argument and Sink Types, Matthew Wilson, Overload #90, April 2009
  • An Introduction to FastFormat, part 3: Solving Real Problems, Quickly, Matthew Wilson, Overload #91, June 2009

Examples:

  • Emulate Streams' ability to specify widths:

      printf("[%-10d, %10d]\n", 123, -456);

      fastformat::fmtln(std::cout, "[{0,10,,<}, {1,10}]", 123, -456);

    Both produce the output:

      [123       ,       -456]

  • Handle heterogeneous types:

      struct connection_t
      {
        std::string     connectionId;
        struct in_addr  remoteAddress;
        struct in_addr  localAddress;
        unsigned short  port;
        unsigned long   numBytesTransferred;
        struct tm       completionTime;
      };

      void log_connection(connection_t const& conn)
      {
        fastformat::fmtln(
          std::cout
        , "{0} {5} {1} {2} {3} {4}"
        , conn.connectionId
        , conn.remoteAddress
        , conn.localAddress
        , conn.port
        , conn.numBytesTransferred
        , conn.completionTime
      );
      }

    Produces output like:

      channel-1 May 03 03:50:41 2009 192.168.160.247 127.0.0.1 5651 102401

  • Emulate Boost.Format's absolute tabulations (with a little indirection):

      std::cout
          << boost::format("%1% %2%, %|20t|lives at %3%\n")
              % "Mr"
              % "Smith"
              % "the Smith residence"
          << std::endl;


      std::string scratch;

      fastformat::fmtln(
          std::cout
      ,   "{0,20,,<}lives at {1}"
      ,   fastformat::fmt(
              scratch
          ,   "{0} {1}, "
          ,   "Mr"
          ,   "Smith"
          )
      ,   "the Smith residence"
      );


    Both produce the output:

      Mr Smith,           lives at the Smith residence

Performance:

FastFormat's performance has been extensively tested, and in every case it has superior performance to the C++ standard library's IOStreams, Boost.Format and Loki.SafeFormat. In most cases it has equivalent performance to the (type-unsafe) C standard library's Streams (printf()-family). Test results are included on the project website, and in the first in the Overload article series; the third article in the series has a further set of four performance tests, based on real-world uses of FastFormat in commercial projects.

Features:

  • 100% type-safe
  • Presents a natural syntax
  • Infinitely extensible
  • Highly-efficient:
    • no intermediate memory allocations
    • no intermediate string copying
    • no repetition of any string-length calculations
    • at most one allocation required to produce the resultant string
  • Verified with Borland, Metrowerks' CodeWarrior, Digital Mars, GCC, Intel, and Visual C++ compilers
  • Verified on Linux, Mac OS-X, and Windows

Requirements:

    STLSoft libraries (1.9.1 beta 81 or later); 100% header-only open-source.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Visual C++
  • GCC
  • Borland C++
  • Any after making small changes...
  • Intel C++
  • Comeau
  • Digital Mars

Added : 2009-05-11 Amended: 2009-05-11

Add a comment

FCE - Ftp Client Engine Library for C/C++

FTP Client Engine (FCE) Library for C/C++ Win16 & Win32 DLLs v1.1, [ASP]. The FCE can connect to any FTP server and navigate its directory structure, list files, download files, delete files, and upload files all from within your application. Requires Windows C/C++ compiler. By MarshallSoft Computing.

Operating Systems

  • PC Windows

Added : 1999-06-21 Amended: 1999-06-21 Licensing : Shareware

Add a comment

FEMTown - Open-Source Multi-Physics Finite Element Framework

FEMTown is designed to solve partial differential equations (PDE) using spatial finite-element discretizations. FEMTown provides

  1. an extensive library of elements,
  2. variable interpolation schemes (p-adaptivity),
  3. shape-function calculations,
  4. numerical integration,
  5. sparse and dense matrix manipulations,
  6. assembly routines,
  7. numerical solvers,
  8. exchange of common file formats

<h4>Applications</h4> FEMTown also includes open-source end-user applications:

  1. contribution calculations for acoustics and
  2. visco-elastic materials.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Sparc
  • SGI Irix
  • Sun
  • Cray
  • IBM AIX
  • Solaris
  • HP UX
  • Unix
  • Convex
  • Dec Alpha
  • PC Windows
  • NEC, Fujitsu, Hitachi

Compilers

  • Visual C++
  • GCC
  • Dec CC
  • SGI CC
  • Sun CC
  • IBM xlC
  • SGI NCC
  • HP C++

Added : 2001-09-28 Amended: 2001-09-28 Licensing : Public Domain

Add a comment

FFLL - Free Fuzzy Logic Library

The Free Fuzzy Logic Library (FFLL) is an open source fuzzy logic class library and API that is optimized for speed critical applications, such as video games. FFLL is able to load files that adhere to the IEC 61131-7 standard.

Operating Systems

  • could run on any OS, but not tested

Compilers

  • could be compiled, but not tested

Added : 2010-11-16 Amended: 2010-11-16 Licensing : BSD style

Add a comment

FFTPACK++ - C++ version of FFTPACK

FFT_Pack is a C++ wrapper for FFTPACK complex routines using LAPACK++ Matrix and Vector classes. FFTPACK routines were converted to C using f2c and also modified to use double precision complex using -r8 to f2c.

Most of this code was lifted directly from GNU OCTAVE v1.1.0, hence the copyright notice at the top.

The forward FFT takes you to freq domain (ala direction == -1), and backward the other way.

Passing LaVectorComplex/Double or LaGenMatComplex/Double with one dimension set to 1 will implicitly perform 1D FFT on the data.

The members of the FFT_Pack class are declared static, since they really need no private member storage. There are two types of transform routines: ones that return a new complex matrix and the ones that change the matrix in place.

The original FFTPACK does not appear to be available any more, but I found the link below to a different (possibly improved) version.

Compilers

  • GCC
  • Cfront

Added : 1995-01-01 Amended: 2008-07-22 Licensing : GNU copyleft

Comment from : js on 2015-04-03

Dead link (Apr/2015)

Add a comment

FFTW - Fast C library for computing the Fast Fourier Transform (FFT)

FFTW is a C library for performing the FFT in one or more dimensions. It also includes real-complex and parallel transforms. In our benchmarks, FFTW compares favorably to other portable codes for most platforms and transform sizes, and is often competitive with vendor-tuned libraries for specific machines.

Operating Systems

  • Platform-independent

Added : 1997-11-27 Amended: 1999-06-21 Licensing : GNU copyleft

Add a comment

Field3D - A file format and data structures for storing 3D voxel and simulation data

Field3D is an open source library for storing voxel data. It provides C++ classes that handle in-memory storage and a file format based on HDF5 that allows the C++ objects to be written to and read from disk.

The library and file format is both flexible and extendable. The flexibility comes from supporting heterogeneous storage of data structures, bit depths, transformations/mappings and metadata in a single file. When functionality needs to be extended, the plugin and class factory architecture allows new data structures, mappings and file I/O routines to be added.

Field3D was developed with the needs and scale of visual effects production in mind. Dense and MAC-fields handle the basic tasks in fluid simulation and volume rendering, and where memory becomes a limiting factor optimization of used/unused space is provided by the sparse fields, which include an out-of-core/dynamic loading mechanism. Procedural fields are also supported, which may be used interchangeably with voxel-based fields.

The code was initially developed at Sony Pictures Imageworks as a replacement for the three different in-house file formats previously used to store voxel data. It is currently used in several contexts: both our volume rendering and fluid simulation frameworks use it as their native data structures and file format, and in Houdini it serves as the base for our voxel and levelset editing toolsets.

Operating Systems

  • could run on any OS, but not tested

Compilers

  • could be compiled, but not tested

Added : 2010-11-16 Amended: 2010-11-16 Licensing : BSD style

    Field3D - A file format and data structures for storing 3D voxel and simulation data
  • Project home page
  • Submitted by:Domenic Laritz
Add a comment

FireBreath - Cross-browser, cross-platform browser-plugin framework.

FireBreath makes it easy to develop browser-plugins that target Internet Explorer and browsers with NPAPI support (Firefox, Chrome, Safari, Opera, etc.) on Windows, Mac OS X and Linux. It is licensed under a dual license structure, which means you can choose which of two licenses to use it under. FireBreath can be used under the New BSD license or the GNU Lesser General Public License v2.1.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • PC Windows
  • Mac

Compilers

  • Visual C++
  • GCC

Added : 2012-02-20 Amended: 2012-02-20 Licensing : BSD style

Add a comment

FLENS - C++ Library for High-Performance Numerical Linear Algebra

FLENS is short for "Flexible Library for Efficient Numerical Solutions"

FLENS extends C++ for matrix/vector types that are ideally suited for numerical linear algebra. That's it ...

...but the consequences are immense. The simplicity of its design makes the combination FLENS/C++ a powerful tool for the development of high performance applications and libraries in scientific computing.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • GCC
  • Any standard C++ compiler
  • Intel C++

Added : 2012-10-02 Amended: 2012-10-02 Licensing : BSD style

    FLENS - C++ Library for High-Performance Numerical Linear Algebra
  • FLENS
  • Submitted by:Michael Lehn
Add a comment

FRUCTOSE - Andrew Marlow's C++ Unit Testing Framework

C++ unit testing framework, very cutdown compared to CppUnit but very simple and implemented entirely using header files.

Operating Systems

  • Any after making small changes...

Compilers

  • Any standard C++ compiler

Added : 2008-07-29 Amended: 2008-07-29

Add a comment

G3Log - Asynchronous logger, cross-platform and "crash safe"

G3log is an asynchronous "crash safe" logger used on at least the following platforms:
  • Linux/g++ 4.7.4 and higher
  • OSX/g++ and Clang
  • Windows/g++ and VS2013
All slow I/O and logging sink processing is done in background threads. At shutdown all buffered log entries are flushed to the sinks before exiting.

Fatal events such as segmentation fault (SIGSEGV) are caught And a stackdump is added to the buffered log entries. This ensures the same reliability as if using a slower synchronous logger.

Logging sink receivers are easy to add in runtime.

Operating Systems

  • Linux
  • PC Windows
  • Mac
  • Platform-independent

Compilers

  • GCC

Added : 2014-10-06 Amended: 2014-10-06 Licensing : Public Domain

Add a comment

GAGS - C++ class library for Genetic algorithms

It includes classes for chromosomes and populations.

Library:binary chromosome representation. Genetic operators: mutation, xOver (n-pt and uniform), remove/reinsert. Selection operator: steady state, tournament, roulette wheel. Perl and/or tcl/tk graphic front-end. Graphics through gnuplot. Training from file.

Application generator: it needs only an ANSI-C definition of the fitness function. It's parsed, and a program that runs a GA on it is generated.

Operating Systems

  • Unix

Compilers

  • GCC
  • SGI CC
  • Sun CC

Added : 1996-02-08 Amended: 1996-02-08 Licensing : Copyrighted freeware

Add a comment

GAME - Parallel Genetic Algorithms Theory and Applications

Edited by: J. Stender
Publisher: IOS Press
Frontiers in Artificial Intelligence and Applications series
1993, 225 pp; hard cover; w/ disk
ISBN: 90 5199 087 1
Price: $85, 59 pounds sterling

The first version of the GAME Virtual Machine software and two examples that come with the book can be obtained also by ftp.

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

Add a comment

GECOOL 2.1 - A reworking and enhancement of Texas Instrument's "C++ Object Oriented Library"

By some programmers at General Electric.

Also available is JCOOL. Its main difference from COOL and GECOOL is that it uses real C++ templates instead of a similar syntax that is preprocessed by a special 'cpp' distributed with COOL and GECOOL.

Some users behind "firewalls" have had difficulty accessing the ftp site.

Added : 1995-01-01 Amended: 1996-02-05 Licensing : Not known

Add a comment

Generic Linked List Package

A package to define, create, update query and delete one or more (nodes of) linked lists, to sort linked lists, and so on. The user doesn't have to take care of allocating a number of bytes for a node, inserting on the right place, deleting and freeing a node and so on.

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

Add a comment

GiNaC - Symbolic computation embedded in C++

GiNaC is an iterated and recursive acronym for GiNaC is Not a CAS, with CAS standing for Computer Algebra System. It is designed to allow the creation of integrated systems that embed symbolic manipulations together with more established areas of compute r science (like computation- intense numeric applications, graphical interfaces, etc.) under one roof. It is distributed under the terms and conditions of the GNU general public license GPL.

It implements a class hierarchy with the basic classes needed to create symbolic expressions, including abritrary length/precision numbers (drawing from the CLN library). The classes provide basic symbolic manipulations as well as memory management through reference counting, disk-I/O, etc. Using the Cint C/C++ interpreter it is even possible to use it in an interactive manner.

It is written in standard C++ and should compile on any compliant compiler. Since it has to be linked with CLN, however, it is somewhat tricky (but not impossible) to do so on other compilers than GCC.

Operating Systems

  • Linux
  • Solaris
  • Unix
  • Irix

Compilers

  • GCC

Added : 2001-01-31 Amended: 2001-01-31 Licensing : GNU copyleft

Add a comment

gleem - OpenGL Extremely Easy to use Manipulators

A C++ library of Open Inventor-style manipulators (3D widgets) for direct interaction with a 3D scene. Written using OpenGL and GLUT and very easy to incorporate into an existing OpenGL/GLUT application. Developed on Irix, but should be easily portable.

NOTE: this version of gleem is no longer being maintained. The current sources are in the jogl-demos workspace at the url below and are covered under the BSD license.

Operating Systems

  • SGI Irix

Compilers

  • SGI CC

Added : 1998-12-03 Amended: 2008-07-29 Licensing : GNU copyleft

Add a comment

GNU Plotutils - A library for exporting 2-D vector graphics in many file formats.

The GNU plotutils package contains software for both programmers and technically oriented users. Its centerpiece is the libplot/libplotter, a C/C++ function lib for exporting 2-D vector graphics in many file formats (including WebCGM format, recommended by the graphics Activity of the W3 Consortium). It can also do vector graphics animations, has thread-safe APIs, and supports the use of Posix threads (if available). The program also contains the following command-line programs for plotting scientific data:
  • graph- plots 2-D datasets or data streams in real time
  • plot- translates metafile formats to any of the other formats
  • tek2plot- translates legacy Tektronix data to any of the above formats
  • pic2plot- translates the pic language to any of the other formats
  • plotfont- displays character maps of the fonts available in the above formats.
  • spline- spline interpolation of data
  • ode- numerically integrates ordinary differential equations

Operating Systems

  • Linux
  • Sparc
  • Sun
  • IBM AIX
  • Solaris
  • HP UX
  • Unix
  • X Windows
  • OSF
  • SYSV
  • Convex
  • Dec OSF/1

Compilers

  • GCC
  • Dec CC
  • SGI CC
  • Sun CC
  • IBM xlC

Added : 1999-07-01 Amended: 2008-07-22 Licensing : GNU copyleft

Add a comment

Grail - Symbolic computation with finite-state machines and regular expressions

Supports conversion of FSM to RE and back and also conversion to and from finite languages. Supports many algebraic operations on FSM and RE. All objects are templates, so you can parameterize FSM or RE to use any C++ class or base type as its alphabet type (hence, Mealy machines are supported by using ordered pairs as the alphabet type).

Compilers

  • IBM xlC
  • Cfront
  • Watcom C++
  • IBM Cset++

Added : 1996-05-22 Amended: 2008-07-29 Licensing : Education

Add a comment

Grayscale Image Processing

Enhanced grayscale image processing class library and verification code, source code

Keywords: image arithmetics, median filtration, morphological filtration, convolution, lazy image, TIFF, plasma fractals, nondeterministic filter, class library

Operating Systems

  • PC 32-bit Windows
  • rs6000-aix-3.2
  • Solaris
  • Dec Alpha
  • Mac
  • HP 9000
  • FreeBSD
  • Concurrent Maxion 8000/RTU
  • BeOS

Compilers

  • GCC
  • Sun CC
  • MetroWerks CodeWarrior
  • Borland C++

Added : 1996-05-22 Amended: 1997-03-19 Licensing : Public Domain

Add a comment

GRETA Regular Expression Template Archive - Fast, Perl 5-compliant regular expression template library for C++

GRETA is a (yet another) C++ template library for regular expression pattern matching. It was developed in Microsoft Research. GRETA's distinguishing features are: high performance, Perl compatibility, and clean STL integration. You can perform matches with any bidirectional iterator type, or on a std::basic_string, or on a C-style NULL-terminated string. It supports wide and narrow character types (wchar_t and char) and respects the C locale setting (as specified by setlocale()). GRETA lets you customize regular expression syntax via a syntax module template parameter. Perl 5 and Basic POSIX syntax modules are included.

Operating Systems

  • Linux
  • PC 32-bit Windows

Compilers

  • Visual C++
  • GCC

Added : 2002-06-21 Amended: 2004-06-15 Licensing : Non commercial

Comment from : js on 2015-04-03

Dead link

Add a comment

GTAD - Graph Toolkit for Algorithms and Drawings

The GTAD (Graph Toolkit for Algorithms and Drawings) is an attempt to construct a set of flexible, reusable, and efficient C++ implementations of graph representations and algorithms (including drawing/layout). It is developed with the generic programming paradigm and under the same principles of the BGL (Boost Graph Library).

Operating Systems

  • Platform-independent

Compilers

  • GCC
  • Visual C++ .NET

Added : 2008-09-16 Amended: 2008-09-16 Licensing : Open Source

    GTAD - Graph Toolkit for Algorithms and Drawings
  • Main website
  • Submitted by:Leandro Melo
Add a comment

GTL - The Graph Template Library

The Standard Template Library (STL) is supposed to become a part of the C++ standard library and therefore is an ideal basis when writing portable programs.

Unfortunately, STL has no support for graphs and graph algorithms. However, graphs are widely used to model complex relational structures.

Since we are intensively working with graph algorithms and Graphlet, we decided to implement GTL, a graph library based on STL. For the design of GTL's API the API of LEDA has served as a basis. GTL contains the classes needed to work with graphs, nodes and edges and some basic algorithms as building blocks for more complex graph algorithms. Further algorithms are under work.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Solaris
  • HP UX

Compilers

  • Visual C++
  • GCC

Added : 2000-04-26 Amended: 2000-04-26 Licensing : Copyright (other)

Add a comment

GzipFile - MFC C++ objects compressed to disk.

Gzipfile compresses MFC serialized document data. The only code changes required are a few include statements and macro instantiations in a CDocument derived class. Uncompressed documents can still be loaded and all saved documents are compressed.

The compression engine is mature, widely used and extremely fast.

Operating Systems

  • PC 32-bit Windows

Compilers

  • Visual C++
  • Borland C++

Added : 1998-07-24 Amended: 2003-07-29 Licensing : Shareware

Add a comment

Hans Boehms GC - Hans Boehms free Garbage Collector

Conservative garbage collector for C/C++. Several interfaces are provided. Can be used as a transparent malloc replacement, or implements much of the Detlefs/Ellis C++ GC proposal, or can be used as an allocator for SGI's STL.

Can be used with the large majority of operating systems that support 32- or 64-bit flat addressing, i.e. almost all UNIX variants, win32, and a few others.

Operating Systems

  • PC 32-bit Windows
  • Unix

Added : 1995-01-01 Amended: 2008-07-29 Licensing : Copyrighted freeware

Add a comment

High level vector operations

Contains the Aitken-Lagrange interpolation over the table of uniform or arbitrary mesh, and the Hook-Jeevse multidimensional minimizer. Precision single/double.

Obsolete - now part of the Lin-alg package.

Added : 1995-01-01 Amended: 2008-11-04 Licensing : Not known

Add a comment

HugeCalc - Arbitrary accuracy large integer calculations

HugeCalc is a package for performing long integer calculations with up to 300 digits of accuracy. The package allows C++ programmers to define objects of type HugeInt and use them just like ordinary integers to perform addition, subtraction and multiplication operations. Most of the ordinary mathematical operators are supported in the ordinary fashion. Includes object modules for Borland C++, example programs and complete documentation. Shareware version contains object modules for tiny, small and medium memory models only.

Operating Systems

  • PC DOS

Compilers

  • Visual C++
  • Borland C++

Added : 1997-11-27 Amended: 1997-11-27 Licensing : Shareware

Add a comment

ICU - Unicode Support Library

Provide Unicode Support for C++, C and Java Short list of features: Character set conversions, Unicode Strings, collation, Unicode character properties access, locale management, resource management, calendars, date/time, message formatting, language transliteration, text layout, regular expressions. Separate APIs for C++ and C.

Licence restrictions: Open Source, X license, http://www.x.org/terms.htm

Operating Systems

  • Linux
  • PC 32-bit Windows
  • IBM AIX
  • Solaris
  • HP UX
  • Dec Alpha
  • Mac
  • FreeBSD
  • IBM OS390, OS400
  • IA64 Windows XP

Compilers

  • Visual C++
  • GCC
  • Sun CC
  • IBM xlC
  • HP C++
  • Sparcworks

Added : 2002-03-08 Amended: 2008-07-29 Licensing : Copyrighted freeware

Add a comment

Image Magick - Image manipulation application and libraries

Jeff Donner writes :-
It isn't C++ but C, but it's so cross-platform and comprehensive an image package, I thought you should know about it. If you look at their page you don't see anything about the libs, but they (and all source) are included with the app. They're free, (commercial use OK, copyright only) and useful.

ImageMagick does a pretty thorough job of reading & writing most image formats.

Added : 1998-12-03 Amended: 2003-03-13 Licensing : Copyrighted freeware

Add a comment

ImageLib - An Image Processing C++ Class Library

ImageLib is a C++ class library providing image processing and related facilities.

The main set of classes provides a variety of image and vector types, with additional modules supporting scalar and vector quantisation, wavelet transforms, DCT transforms, and simple histogram operations.

Tested on Solaris and FreeBSD, but should work with most other UNIX versions. Most features are not operating system specific.

Operating Systems

  • Linux
  • Solaris
  • FreeBSD

Compilers

  • GCC
  • Sun CC
  • KAI C++

Added : 1998-07-27 Amended: 2000-04-26 Licensing : GNU copyleft

Add a comment

iMatrix - Matrix classes implementation

Keywords: matrix, matrix operation, C++, class template .

Implementation of a matrix and some matrix operation based on class-template concept. The key different from others is the implemenation of the separate matrix operation as separate class-template. A few small particularities would be effective.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • PC Windows

Compilers

  • Visual C++
  • GCC
  • Borland C++

Added : 2000-05-25 Amended: 2000-05-25 Licensing : Public Domain

Comment from : F. Beekhof on 2008-09-10

Link is dead.

Add a comment

IMP, the Integrative Modeling Platform - IMP is a platform for modeling the structure and dynamics of protein assemblies

IMP's broad goal is to contribute to a comprehensive structural characterization of biomolecules ranging in size and complexity from small peptides to large macromolecular assemblies. Detailed structural characterization of assemblies is generally impossible by any single existing experimental or computational method. This barrier can be overcome by hybrid approaches that integrate data from diverse biochemical and biophysical experiments (eg, x-ray crystallography, NMR spectroscopy, electron microscopy, immuno-electron microscopy, footprinting, chemical cross-linking, FRET spectroscopy, small angle X-ray scattering, immunoprecipitation, genetic interactions, etc...). We formulate the hybrid approach to structure determination as an optimization problem, the solution of which requires three main components:
  • the representation of the assembly,
  • the scoring function and
  • the optimization method.
  • The ensemble of solutions to the optimization problem embodies the most accurate structural characterization given the available information.
We created IMP, the Integrative Modeling Platform, to make it easier to implement such an integrative approach to structural and dynamics problems. IMP is designed to allow mixing and matching of existing modeling components as well as easy addition of new functionality. We encourage and support contributions from other laboratories through the IMP Community.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Visual C++
  • GCC
  • Intel C++

Added : 2011-05-31 Amended: 2011-05-31 Licensing : Open Source

    IMP, the Integrative Modeling Platform - IMP is a platform for modeling the structure and dynamics of protein assemblies
  • website
  • Submitted by:Daniel Russel
Add a comment

Intel Threading Building Blocks - Intel TBB offers a rich and complete approach to expressing parallelism in a C++

Intel® Threading Building Blocks (TBB) offers a rich and complete approach to expressing parallelism in a C++ program. It is a library that helps you take advantage of multi-core processor performance without having to be a threading expert. Threading Building Blocks is not just a threads-replacement library. It represents a higher-level, task-based parallelism that abstracts platform details and threading mechanisms for scalability and performance.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Any standard C++ compiler

Added : 2009-09-01 Amended: 2009-09-01 Licensing : Open Source

    Intel Threading Building Blocks - Intel TBB offers a rich and complete approach to expressing parallelism in a C++
  • Intel TBB Homepage
  • Submitted by:Kizza George Mbidde
Add a comment

InterViews - GUI class library developed by Stanford University

Make sure you get v3.1 or later. This library contains excellent examples of multiple inheritance used profitably. I understand that InterViews development will not continue past the current version; author Mark Linton is concentrating his efforts on the X Consortium Fresco project, which should show up in X11R6.

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

Add a comment

iof - Replacement for printf/scanf in C++

Many people wonder how to get the same effects using C++ streams as they would using printf/scanf. They are usually pointed to STL manipulators with std::setw etc.

There is at least one: the iof library at http://iof.sourceforge.net. There is also the boost format library (http://www.boost.org) but it doesn't support scanf-like input.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Unix
  • PC Windows

Compilers

  • Visual C++
  • GCC

Added : 2006-12-01 Amended: 2007-04-10 Licensing : Copyrighted freeware

Add a comment

Irrlicht - Lightning fast realtime 3D engine

The Irrlicht Engine is an open source high performance realtime 3D engine written and usable in C++ and also available for .NET languages. It is completely cross-platform, using D3D, OpenGL and its own software renderer, and has all of the state-of-the-art features which can be found in commercial 3D engines.

Operating Systems

  • Cross platform, should work on any.

Compilers

  • Visual C++
  • GCC
  • MetroWerks CodeWarrior

Added : 2010-11-16 Amended: 2010-11-16 Licensing : Open Source

Add a comment

ISC366.ZIP - Interrupt Service Class (v. 3.66)

Allows hooking of interrupts (software and hardware) into classes, comes with classes for staying resident, for serial communication (interrupt driven), and like-wise classes. Comes with full source code!

Operating Systems

  • PC DOS

Compilers

  • Borland C++

Added : 1995-01-01 Amended: 1995-01-01 Licensing : Public Domain

Add a comment

Ivf++ - C++ OpenGL visualisation library

Ivf++ is a simple OpenGL based C++ visualisation framework. The main goal with Ivf++ was not to create a complete visualisation library, but create a foundation of classes that can be extended in simple ways. Ivf++ contains a simple gui framework based on FLTK. Ivf++ can also be used together with other GUI libraries using provided widgets. Currently Win32, FLTK, and MFC are supported.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • SGI Irix

Compilers

  • Visual C++
  • GCC
  • SGI CC

Added : 2000-04-26 Amended: 2008-07-29 Licensing : GNU copyleft

Add a comment

ivmaps - C++ libraries for manipulation and visualization of geo-spatial map data

ivmaps is a set of C++ libraries for reading, writing, processing, painting, viewing, and querying map data, with 2D and 3d map viewers that support DEM elevation data, DLG and VPF vector map data, and DRG and DOG raster. Compiles on ivtools and PROJ-4.3.3 from the USGS. Optionally can be compiled to use ACE, clippoly, Vtk, and Mesa.

Added : 1998-07-22 Amended: 1998-07-22 Licensing : Freeware

Add a comment

ivtools - C++ frameworks for graphical editors and spatial data servers

ivtools is a set of C++ frameworks for building graphical editors, spatial data servers, and combinations of both. It incorporates an alternate distribution of the InterViews and Unidraw libraries last published by Stanford University and Silicon Graphics in release 3.2a. New C++ libraries augment the baseline drawing editor mechanism of Unidraw with various features, which are then used in drawing editors evolved from idraw: a network-ready editor, a multi-frame flipbook editor, and a hiearchical node-graph editor. Optionally can be compiled to use ACE and clippoly C++ libraries.

Added : 1998-07-22 Amended: 1998-07-22 Licensing : Freeware

Add a comment

ixlib - c++ tools library

ixlib is a C++ tools library based upon the STL. It provides garbage collection, a small well-integratable JavaScript interpreter, linear algebra components (e.g., linear solver, LU decomposition), planar geometry, polygons, automatic arrays, rasterization for geometric primitives and polygons, regular expressions and XML parsing (non-DTD). Its main design goals were simplicity and small size.

GNU C++ 2.95.2 (linux and mingw32) tested, any ISO-compliant compiler should work.

Compilers

  • GCC

Added : 2001-01-22 Amended: 2001-01-22 Licensing : GNU copyleft

Add a comment

jjLibrary - C++ Pattern Library

jjLibrary is a C++ library which provides
  1. jjPattern : Pattern-based container class (Hash, Tree, List, Graph)
  2. jjErrno : error handling, and
  3. jjCGI : CGI library

jjPattern has unique feature which can be compared to STL.

Operating Systems

  • Linux
  • HP UX
  • could run on any OS, but not tested

Compilers

  • GCC
  • HP C++
  • could be compiled, but not tested

Added : 2004-09-06 Amended: 2004-09-06 Licensing : GNU copyleft

Add a comment

JPTUI - Textual user interface for DJGPP

Textual user interface for DJGPP 2, v4.0e

JPTUI is an object-oriented textual user interface. Designed for C++, it provides a simple to use application programming interface. JPTUI is available for DJGPP 2 and Borland C++ 4.

I am told that this library is no longer on Simtel, but there is an older version stil available via ftp from a different site.

Operating Systems

  • PC

Compilers

  • DJGPP
  • Borland C++

Added : 1998-02-24 Amended: 2000-04-26 Licensing : Copyrighted freeware

Add a comment

jsoncons C++ header-only library - JSON construction with JSONPointer, JSONPatch, J

jsoncons is a modern C++, header-only library for constructing JSON. It supports parsing a JSON file or string into a json value, building a json value in C++ code, and serializing a json value to a file or string. It also provides an API for generating json read and write events in code, somewhat analogously to SAX processing in the XML world. It is distributed under the Boost Software License.

jsoncons uses some features that are new to C++ 11, including move semantics and the AllocatorAwareContainer concept. It has been tested with MS VC++ 2015, GCC 4.8, GCC 4.9, GCC 6.2.0 and recent versions of clang. Note that std::regex isn't fully implemented in GCC 4.8., so jsoncons_ext/jsonpath regular expression filters aren't supported for that compiler.

Operating Systems

  • Linux
  • PC Windows
  • Mac

Compilers

  • Visual C++
  • GCC
  • Any Unix C++ compiler

Added : 2018-01-19 Amended: 2018-01-19 Licensing : Boost

Add a comment

JsonMe++ - JSON parsing C++ wrapper library with operator overloading.

The JsonMe++ (JSON Made easy for C++) library is a C++ wrapper for the JSON-Glib C library. The library makes heavy use of C++ syntactic sugar type C++ language constructs, most notably the subscript operator and cast operator as essential API components, which makes this JSON library extremely simple to use. As a result, access to a deeply nested value from a piece of JSON data can be expressed simply.

Operating Systems

  • Cross platform, should work on any.

Compilers

  • Any Unix C++ compiler
  • Any standard C++ compiler

Added : 2012-09-20 Amended: 2012-09-20 Licensing : Copyright (other)

    JsonMe++ - JSON parsing C++ wrapper library with operator overloading.
  • Projects freecode page
  • Submitted by:Rob Meijer
Add a comment

JThreads/C++ - Java-like Threads for C++

JThreads/C++ is the short-form of "Java-like Threads for C++". JThreads/C++ is a high-level thread abstraction library that gives C++ programmers the "look & feel" of Java threads.

JThreads/C++ is free for non-commercial use and available with its full source code.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • SGI Irix
  • Solaris
  • HP UX
  • Unix
  • Dec Alpha
  • Dec OSF/1

Compilers

  • Visual C++
  • GCC
  • Dec CC
  • SGI CC
  • Sun CC
  • HP C++

Added : 1998-02-24 Amended: 1998-02-24 Licensing : Copyright (other)

Comment from : Andrew Marlow on 2008-07-29

OOC was acquired by IONA who incorporated JThreads/C++ into Orbacus. Thus JThreads/C++ is no longer available separately (except via old copies in various free software reposistories)

Add a comment

JX - Application framework and widget library for use with X Windows

JX is a full-featured C++ application framework and GUI class library for X Windows. It provides support for all facets of application development, including distributed applications, and aims to combine the best of MacOS and NeXTSTEP. It is built directly on top of Xlib and has been carefully optimized for performance.

Operating Systems

  • Linux
  • Sparc
  • SGI Irix
  • Sun
  • Solaris
  • HP UX
  • Unix
  • X Windows
  • Dec Alpha
  • Dec Ultrix

Compilers

  • GCC
  • Compiler independent

Added : 1997-12-06 Amended: 2008-07-29 Licensing : Copyright (other)

Add a comment

Kalman - A class library for Kalman filtering

Contains lumatrix.c++ etc.

Compilers

  • GCC

Added : 1995-01-01 Amended: 2003-10-20 Licensing : Not known

Add a comment

kplib - Basic but highly optimised C++ library

The library consists of the following classes:
  • KPList<T> A two-way list that assumes nothing about its elements except they correctly implement a default constructor and operator=().
  • KPComparableList<T> A subclass of KPList<T> which also assumes its elements can be compared with operator==(), thus providing more powerful methods.
  • KPSortableList<T> A subclass of KPComparableList<T> which also assumes its elements can be compared with operator<(), thus providing more powerful methods.
  • KPReadOnlyIterator<T> An iterator with pointer-like semantics which can iterate over any of the above lists for reading purposes only.
  • KPIterator<T> An iterator with pointer-like semantics which can iterate over any of the above lists for the purpose of reading, modifying, deleting, or adding elements to or from arbitrary locations in the list.
  • KPArray<T> A dynamically-sizable array that assumes nothing about its elements except they correctly implement a default constructor and operator=().
  • KPComparableArray<T> A subclass of KPArray<T> which also assumes its elements can be compared with operator==(), thus providing more powerful methods.
  • KPSortableArray<T> A subclass of KPComparableArray<T> which also assumes its elements can be compared with operator<(), thus providing more powerful methods.
  • KPQueue<T> A queue that assumes nothing about its elements except they correctly implement a default constructor and operator=().
  • KPPriorityQueue<T> A priority queue that assumes its elements correctly implement a default constructor, operator=(), operator==() and operator<().
  • KPStack<T> A stack that assumes nothing about its elements except they correctly implement a default constructor and operator=().
  • KPSet<T> A set that assumes its elements correctly implement a default constructor, operator=(), operator==() and operator<(). All union, intersection, difference and superset/subset operations are of order O(n).
  • KPBag<T> A bag that assumes its elements correctly implement a default constructor, operator=(), operator==() and operator<().
  • KPString A string class which implements basic string functions and more (such as tokenizing methods which return KPList<KPString>). This class uses reference counting and copy-on-write semantics to insure that it as efficient as possible.

Operating Systems

  • Unix

Compilers

  • GCC
  • MetroWerks CodeWarrior
  • Watcom C++

Added : 2000-04-26 Amended: 2000-12-22 Licensing : Public Domain

Add a comment

Lapack++ - C++ version of some of lapack fortran code

Developmental version of proposed C++ version of lapack. Contains blas.h++ etc, but needs Fortran library to link.

Documents : Overview paper (9 pages postscript), release notes (7 page ps)

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

Add a comment

LEDA - A Library of Efficient Data Types and Algorithms

Provides basic data-types like lists, stacks, queues, trees, sets, partitions, priority queues and a few others. These are parameterizable classes, you may add your own datatype and have a priority queue ... An important datatype is a graph, these are also parameterizable and there are useful algorithms for them like shortest path, transitive closure, matching, maximum flow, spanning tree and others, we have implemented a few algorithms for dealing with perfect graphs, but these ar not part of the standard library. The latest part deals with computational geometry.

It can be used with C++ compilers which understand templates

Compilers

  • GCC
  • Cfront

Added : 1995-01-01 Amended: 1999-06-04 Licensing : Education

Add a comment

lexertl - Dynamic Lexical Analyser Generator

Generate lexical analysers at runtime and start using them right away. Generate code or serialise the generated machine when you are happy with the results.

Recursion is supported allowing support for things like nested comments or simple grammars.

Operating Systems

  • Platform-independent

Compilers

  • Any standard C++ compiler

Added : 2012-08-06 Amended: 2012-08-06 Licensing : Boost

    lexertl - Dynamic Lexical Analyser Generator
  • lexertl
  • Submitted by:Ben Hanson
Add a comment

libcds C++ template library of lock-free algo - libcds C++ template library of lock-free containers and GC

CDS (Concurrent Data Structures) is a C++ template library of lock-free and fine-grained lock-based algorithms. It contains a collection of concurrent containers: queues, maps, and various types of safe memory reclamation algorithms for lock-free programming - Hazard Pointer, Pass-the-Buck and others.

Operating Systems

  • Linux
  • PC 32-bit Windows
  • Sparc
  • Solaris
  • HP UX
  • PC Windows
  • BSD

Compilers

  • Visual C++
  • GCC

Added : 2012-01-03 Amended: 2012-01-03 Licensing : BSD style

    libcds C++ template library of lock-free algo - libcds C++ template library of lock-free containers and GC
  • Doxugen documentation
  • Download
  • Submitted by:Max Khiszinsky
Add a comment

libCON - C++ Game Programming Library

This is an easy-to-use C++ API for creating games, graphics, and sounds. It is built over DirectX 6.0 and is meant to run in Windows 95/98 using 16-bit display modes. The library supplies a multi-level API to these resources: keyboard, mouse, joystick, and the screen as a 2D drawing surface and a target for 3D rendering. This library comes as a packaged DLL, so you don't need to have the DirectX SDK at all, but rather only the runtime components.

Changes: New features including AVI, mp3, fog, dynamic textures, dynamic 3D lights.

Operating Systems

  • PC 32-bit Windows

Compilers

  • Visual C++

Added : 1999-07-21 Amended: 2000-08-09 Licensing : Non commercial

Add a comment

libg++ - (GNU's C++ library)

Libg++ is probably only relevant if you are using g++; and if so, you already know about it. It does have some good implementations of bignum's and of regular expressions and strings.

Compilers

  • GCC

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

Add a comment

LibKISSLog - Light-weight C++ template library for logging.

libKISSlog is a trivial lightweight C++ template library for logging designed and written according to the KISS (Keep It Simple and Straightforward) principle. It leans heavily on STL for keeping its implementation as simple as its usage, and tries to provide C++ developers with a lightweight, paradigm-pure, and flexible alternative to logging libraries which use design and/or implementation decisions which at least the author of libKISSlog believes to be questionable. Its easiest to explain why libKISSlog would be suitable for your needs by listing the things which libKISSlog does not choose to use or do: no singletons or other forms of mutable global state, no macros, no attempt to fit the Java runtime everything model onto a C++ library, no attempt to be a Java-style (bloated) framework, no attempt to make the choice for you of whether you need thread safety, and no compromise on simplicity in order to facilitate questionable inner-loop logging practices.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Any Unix C++ compiler
  • Any standard C++ compiler

Added : 2012-09-20 Amended: 2012-09-20 Licensing : Boost

    LibKISSLog - Light-weight C++ template library for logging.
  • project homepage
  • Submitted by:Rob Meijer
Add a comment

libLCS - Library for Logic Circuit Simulation

libLCS is a hardware description library in C++ aiming to be as powerfull and easy as the Verilog HDL. It currently supports logic gates, flipflops, clock, and facilitates delays, continuous assignments and variable value dumping into VCD files.

libLCS is a library for Logic Circuit Simulation developed in 100% c++. The ultimate aim of LCS is to become a thorough hardware description library, matching the functionality of the Verilog hardware description language, while keeping the usage (and syntax) as intuitive as possible. Currently, it supports simulation of digital systems containing logic gates, flipflops, clock, user defined modules, and facilitates propogation delays, continuous assignments and dumping value changes into VCD files.

Operating Systems

  • PC DOS
  • Linux
  • PC 32-bit Windows
  • Solaris
  • Unix
  • PC Windows

Compilers

  • GCC

Added : 2007-06-27 Amended: 2007-06-27 Licensing : GNU copyleft

Add a comment

Libnet - Generic networking API

Libnet is a generic networking API that provides access to several protocols. It is not designed as a 'all in one' solution to networking.

Currently many features that are common in some network protocols are not available with Libnet, such as streaming via TCP/IP.

Operating Systems

  • PC DOS
  • Linux
  • PC 32-bit Windows
  • Unix
  • OSF
  • FreeBSD

Compilers

  • DJGPP
  • Visual C++
  • GCC
  • RSXNT

Added : 2010-11-16 Amended: 2010-11-16 Licensing : Open Source

Add a comment

libpropc++ - Add properties to C++ (widget.color = "red";)

  • variable like syntax for accessing properties;
  • only two lines to create a property (having get/set functions);
  • aimed to implement binding properties (http://ex-code.com/articles/binding-properties.html);
  • documented.

Template library for properties in C++ (like this: widget.color = "red"; to change widget color).

class Widget { 
  ... 
  Color get_color(); 
  void  set_color(Color value); 
  prop::Property<Widget, Color, 
                 &Widget::set_color, &Widget::get_color> 
      color; 
  ... 
};

Optionally uses libsigc++ to notify about property value changes.

It will support binding several properties together to change accordingly each other.

Article: Binding Properties of Objects

Operating Systems

  • Platform-independent

Compilers

  • Any standard C++ compiler

Added : 2004-08-31 Amended: 2004-08-31 Licensing : GNU copyleft

Add a comment

libsigc++ - Callback Framework for C++ (signal/slot)

Libsigc++ implements a full callback system for use in widget libraries, abstract interfaces, and general programming. Originally part of the Gtk-- widget set, libsigc++ is now a seperate library to provide for more general use. It is the most complete library of its kind with the ablity to connect an abstract callback to a class method, function, or function object. It contains adaptor classes for connection of dissimilar callbacks and has an ease of use unmatched by other C++ callback libraries. Ligsigc++ is licensed under the LGPL.

Operating Systems

  • PC 32-bit Windows
  • Unix

Compilers

  • Visual C++
  • GCC

Added : 1999-06-15 Amended: 1999-06-15 Licensing : GNU copyleft

Add a comment

Lily (LIsp LibrarY) - Gives C++ programmers the capability to write LISP-style code

I think Lily will be useful in academia for instructors who want to teach artificial intelligence techniques with C++. The garbage collection mechanism employed by Lily is slow which will make it unattractive for commercial use.

Documentation is minimal. The "Lily User's Guide" (in file lily.txt) provides a good overview of the architecture of Lily -- the document is unfinished. All of the example programs are from Winston's book "LISP Second Edition" so you will be much better off if you have a copy. Steele's "Common LISP" describes the behavior of the LISP functions.

Operating Systems

  • Unix
  • PC Windows

Compilers

  • GCC
  • Borland C++

Added : 1995-01-01 Amended: 1995-01-01 Licensing : GNU copyleft

Add a comment

LinAlg - C++ Linear Algebra and Optimization classlib

  • defines Matrix,Vector, subMatrices, and LAStreams over real domain;
  • contains efficient and fool-proof implementations of level 1 and 2 BLAS (element-wise operations and various multiplications), transposition, determinant evaluation and matrix inverse.
  • There are operations on a single row/col/diagonal of a matrix.
  • Distinct features of the package are Matrix views, various Matrix streams, and LazyMatrices. Lazy construction allows one to write matrix expressions in a natural way while imposing no hidden temporaries, no deep copying, and no reference counting.
  • LinAlg stresses Matrix streams, which provide a sequential view/access to a matrix or its parts. LABlockStreams may span over an arbitrary rectangular block of a matrix, including the whole matrix, a single matrix element, and all other block sizes in between. Matrix streams are seek-able and subrange-able. A stream or a substream are always created in-line; they do not allocate any heap storage, and are safe.
  • The package implements Singular Value Decomposition (SVD), and its application to solving Ax=b, where matrix A does not have to be square, and b does not have to be a thin vector.
  • The package also implements Brent's univariate optimization and root finding, Hooke-Jeeves multidimensional optimization of functors, and Aitken-Lagrange interpolation.
  • Every feature is extensively tested in the validation code (included).
Current Version: 4.3, December 25, 1998

Operating Systems

  • Linux
  • PC 32-bit Windows
  • SGI Irix
  • IBM AIX
  • Solaris
  • HP UX
  • Unix
  • Dec Alpha
  • Mac
  • BeOS

Compilers

  • Visual C++
  • GCC
  • SGI CC
  • Sun CC
  • MetroWerks CodeWarrior
  • egcs

Added : 1996-05-22 Amended: 1999-06-04 Licensing : Public Domain

Add a comment

Lodestar Database - Client/Server - High performance, non-relational database engine

Lodestar Database is a super fast, non-relational database engine which comes in either single user or network enabled, multi-user client/server versions. The network version comes with either a Novell server or an NT server with clients for Windows 95/98/2000 and Windows NT. Both versions have libraries for Borland C++, Delphi, C++ Builder and Visual Basic.

Lodestar Database has been in use for 10 years in the financial industry and has contributed to huge run time improvements in Credit Union software used throughout the US, but is just now being released to the public as shareware. Credit Unions with as many as 10 branches and thousands of users are currently using our database engine with sub-second response times. Statement runs are 35 minutes for a 35,000 member credit union with over 100,000 accounts and can be run while the credit union is open with virtually no degradation in online response time.

Operating Systems

  • PC Windows
  • Novell

Compilers

  • Borland C++

Added : 2000-04-26 Amended: 2000-04-26 Licensing : Shareware

    Lodestar Database - Client/Server - High performance, non-relational database engine
  • Lodestar Database Home
  • Submitted by:dbaker@lodestardatabase.com
Add a comment

Loki - Loki is a C++ library of designs.

Loki is a C++ library of designs, containing flexible implementations of common design patterns and idioms.

Operating Systems

  • All platforms that support ANSI C++ and PThreads

Compilers

  • Any standard C++ compiler

Added : 2009-09-03 Amended: 2009-09-03 Licensing : Open Source

    Loki - Loki is a C++ library of designs.
  • Loki Homepage
  • Submitted by:Kizza George Mbidde
Add a comment
Our ads
Buy gold
Beat the credit crunch - buy gold online - quickly, safely and at low prices
www.bullionvault.com
Google
Trumphurst Home Page
C++ Usenet Newsgroup
A Web form for submissions to this list
Contact the author for permission to distribute

Copyright (c) 2024 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.