c-smart-pointers alternatives and similar libraries
Based on the "Miscellaneous" category.
Alternatively, view c-smart-pointers alternatives based on common mentions on social networks and blogs.
-
ZXing
ZXing ("Zebra Crossing") barcode scanning library for Java, Android -
RE2
RE2 is a fast, safe, thread-friendly alternative to backtracking regular expression engines like those used in PCRE, Perl, and Python. It is a C++ library. -
ZBar
Clone of the mercurial repository http://zbar.hg.sourceforge.net:8000/hgroot/zbar/zbar -
American fuzzy lop
american fuzzy lop - a security-oriented fuzzer -
Serial Communication Library
Cross-platform, Serial Port library written in C++ -
Better Enums
C++ compile-time enum to string, iteration, in a single header file -
Mach7
Functional programming style pattern-matching library for C++ -
Experimental Boost.DI
DI: C++14 Dependency Injection Library -
UNITS
a compile-time, header-only, dimensional analysis and unit conversion library built on c++14 with no dependencies. -
constexpr-8cc
Compile-time C Compiler implemented as C++14 constant expressions -
outcome
Provides very lightweight outcome<T> and result<T> (non-Boost edition) -
cxx-prettyprint
A header-only library for C++(0x) that allows automagic pretty-printing of any container. -
libcpuid
a small C library for x86 CPU detection and feature extraction -
CppVerbalExpressions
C++ regular expressions made easy -
kangaru
🦘 A dependency injection container for C++11, C++14 and later -
value-category-cheatsheet
A C++14 cheat-sheet on lvalues, rvalues, xvalues, and more -
casacore
Suite of C++ libraries for radio astronomy data processing -
neither
Either and Maybe monads for better error-handling in C++ ↔️ -
StrTk
C++ String Toolkit Library https://www.partow.net/programming/strtk/index.html -
ub-canaries
collection of C/C++ programs that try to get compilers to exploit undefined behavior -
QtVerbalExpressions
This Qt lib is based off of the C++ VerbalExpressions library. [MIT] -
access_profiler
a tool to count accesses to member variables in c++ programs -
libsigc++
A typesafe callback system for standard C++. [LGPL] -
cppq
Simple, reliable & efficient distributed task queue for C++17
Access the most powerful time series database as a service
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of c-smart-pointers or a related project?
README
C Smart Pointers
What this is
This project is an attempt to bring smart pointer constructs to the (GNU) C programming language.
Features
unique_ptr
,shared_ptr
macros, andsmart
type attribute- Destructor support for cleanup
- Custom variable metadata on allocation
- Cross-platform: tested under linux 3.18.6-1, Mac OS X Yosemite 10.10, and Windows 7 (with MinGW and the Cygwin port of GCC)
Installing
With a package manager
- Mac OS X:
brew install snaipe/soft/libcsptr
- AUR:
yaourt -S libcsptr
Ubuntu:
$ sudo add-apt-repository ppa:snaipewastaken/ppa $ sudo apt-get update $ sudo apt-get install libcsptr-dev
Building from source
Prerequisites
To compile the library, GCC 4.6+ is needed.
Installation
- Clone this repository
- run
mkdir build && cd $_ && cmake -DCMAKE_INSTALL_PREFIX=$HOME .. && make && make install
from the project root for a local install, or run
mkdir build && cd $_ && cmake -DCMAKE_INSTALL_PREFIX=/usr .. && make && sudo make install
for a global install.
Examples
Simple unique_ptr: simple1.c:
#include <stdio.h> #include <csptr/smart_ptr.h> int main(void) { // some_int is an unique_ptr to an int with a value of 1. smart int *some_int = unique_ptr(int, 1); printf("%p = %d\n", some_int, *some_int); // some_int is destroyed here return 0; }
Shell session:
$ gcc -std=c99 -o simple1 simple1.c -lcsptr $ valgrind ./simple1 ==3407== Memcheck, a memory error detector ==3407== Copyright (C) 2002-2013, and GNU GPL\'d, by Julian Seward et al. ==3407== Using Valgrind-3.10.0 and LibVEX; rerun with -h for copyright info ==3407== Command: ./test1 ==3407== 0x53db068 = 1 ==3407== ==3407== HEAP SUMMARY: ==3407== in use at exit: 0 bytes in 0 blocks ==3407== total heap usage: 1 allocs, 1 frees, 48 bytes allocated ==3407== ==3407== All heap blocks were freed -- no leaks are possible ==3407== ==3407== For counts of detected and suppressed errors, rerun with: -v ==3407== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Simple unique_ptr with destructor:
#include <unistd.h> #include <fcntl.h> #include <csptr/smart_ptr.h> struct log_file { int fd; // ... }; void cleanup_log_file(void *ptr, void *meta) { (void) meta; close(((struct log_file *) ptr)->fd); } int main(void) { smart struct log_file *log = unique_ptr(struct log_file, { .fd = open("/dev/null", O_WRONLY | O_APPEND), // ... }, cleanup_log_file); write(log->fd, "Hello", 5); // cleanup_log_file is called, then log is freed return 0; }
Allocating a smart array and printing its contents before destruction:
#include <stdio.h> #include <csptr/smart_ptr.h> #include <csptr/array.h> void print_int(void *ptr, void *meta) { (void) meta; // ptr points to the current element // meta points to the array metadata (global to the array), if any. printf("%d\n", *(int*) ptr); } int main(void) { // Destructors for array types are run on every element of the // array before destruction. smart int *ints = unique_ptr(int[5], {5, 4, 3, 2, 1}, print_int); // ints == {5, 4, 3, 2, 1} // Smart arrays are length-aware for (size_t i = 0; i < array_length(ints); ++i) { ints[i] = i + 1; } // ints == {1, 2, 3, 4, 5} return 0; }
More examples
Using a different memory allocator (although most will replace malloc/free):
#include <csptr/smart_ptr.h> void *some_allocator(size_t); void some_deallocator(void *); int main(void) { smalloc_allocator = (s_allocator) {some_allocator, some_deallocator}; // ... return 0; }
Automatic cleanup on error cases:
#include <unistd.h> #include <fcntl.h> #include <csptr/smart_ptr.h> struct log_file { int fd; // ... }; static void close_log(void *ptr, void *meta) { (void) meta; struct log_file *log = ptr; if (log->fd != -1) close(log->fd); } struct log_file *open_log(const char *path) { smart struct log_file *log = shared_ptr(struct log_file, {0}, close_log); if (!log) // failure to allocate return NULL; // nothing happens, destructor is not called log->fd = open(path, O_WRONLY | O_APPEND | O_CREAT, 0644); if (log->fd == -1) // failure to open return NULL; // log gets destroyed, file descriptor is not closed since fd == -1. return sref(log); // a new reference on log is returned, it does not get destoyed } int main(void) { smart struct log_file *log = open_log("/dev/null"); // ... return 0; // file descriptor is closed, log is freed }
Using named parameters:
#include <csptr/smart_ptr.h> void nothing(void *ptr, void *meta) {} int main(void) { struct { int a; } m = { 1 }; smart int *i = unique_ptr(int, .dtor = nothing, .value = 42, .meta = { &m, sizeof (m) } ); return 0; }
FAQ
Q. Why didn't you use C++ you moron ?
A. Because when I first started this, I was working on a C project.
Also, because it's fun.
Q. Can I use this on a serious project ?
A. Yes, but as this project has not been widely used, there might be
some bugs. Beware!
Q. How did you make this ?
A. Here's a link to my blog post on the matter.
*Note that all licence references and agreements mentioned in the c-smart-pointers README section above
are relevant to that project's source code only.