Snaipe / Libcsptr
Licence: mit
Smart pointers for the (GNU) C programming language
Stars: ✭ 1,023
Labels
Projects that are alternatives of or similar to Libcsptr
Arduino Rgb Tools
A arduino library with tools for controlling an RGB-LED
Stars: ✭ 37 (-96.38%)
Mutual labels: cmake
Samp Plugin Profiler
Performance profiler plugin for SA-MP server
Stars: ✭ 33 (-96.77%)
Mutual labels: cmake
Summer Sessions 2020
Series of lectures and hands-on tutorials organized to familiarize new lab entrants with the fundamental areas of robotics research.
Stars: ✭ 36 (-96.48%)
Mutual labels: cmake
Librevault
Librevault - Peer-to-peer, decentralized and open source file sync.
Stars: ✭ 1,001 (-2.15%)
Mutual labels: cmake
Orne navigation
This repository provides mobile robot navigation system with i-Cart mini for Tsukuba Challenge under Project ORNE.
Stars: ✭ 43 (-95.8%)
Mutual labels: cmake
Fairroot
C++ simulation, reconstruction and analysis framework for particle physics experiments
Stars: ✭ 41 (-95.99%)
Mutual labels: cmake
Meshcompare
Comparison tools for Maya meshes, to help visualize the differences between similar meshes.
Stars: ✭ 35 (-96.58%)
Mutual labels: cmake
Picmake
你还在学CMake的过程中毫无头绪吗?你还在为复杂程序库依赖发愁吗?你是否觉得原生CMake的编写冗余而低效?那就快来学习和使用PICMake吧!只需要一行,无论是可执行,动态库还是静态库,轻松搞定!同时高效支持多目标,复杂库的编译安装,从此告别大量冗余CMake代码,专注开发核心应用程序,编译不再愁! 例如下面是使用PICMake编译一个依赖OpenGL的可执行文件,只需要一行!
Stars: ✭ 43 (-95.8%)
Mutual labels: cmake
Jupedsim
Simulating pedestrians with state of the art models.
Stars: ✭ 31 (-96.97%)
Mutual labels: cmake
Openconnect Gui
Mirror - Graphical OpenConnect client (beta phase)
Stars: ✭ 993 (-2.93%)
Mutual labels: cmake
Pcl For Android
Cross-compilation of PCL (point cloud library) for Android
Stars: ✭ 43 (-95.8%)
Mutual labels: cmake
Cmake csharp example
CMake C#/.NET WPF and WinForms Examples
Stars: ✭ 41 (-95.99%)
Mutual labels: cmake
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 the project description data, including the texts, logos, images, and/or trademarks,
for each open source project belongs to its rightful owner.
If you wish to add or remove any projects, please contact us at [email protected].