It seems that every project has an "utility" module with various code snippets used throughout other files and which don't fit any particular pattern.
What utility classes, functions, and macros do you find most useful in your C/C++ projects? Please keep the entries small (under 100 lines) and give only one example per post.
I use these pretty often, they are string trim functions.
inline std::string &rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}
inline std::string <rim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
return s;
}
inline std::string &trim(std::string &s) {
return ltrim(rtrim(s));
}
I also use this lexical cast in the few cases where linking to boost is undesirable, the only problem is that it does no error checking (but that can be easily added by checking the stream state before returning.
template<typename T2, typename T1>
inline T2 lexical_cast(const T1 &in) {
T2 out;
std::stringstream ss;
ss << in;
ss >> out;
return out;
}
#define NuLog(str, args...) {\
fprintf(NULOG_OUTPUT, "Log (" NUMODULE_NAME "): " str "\n", ##args); \
fflush(NULOG_OUTPUT); \
}
Define NUMODULE_NAME in each component of your software and log to your heart's content.
The following code implements a couple of list_sequence() template functions that I find helpful for debugging. Basically, you can call:
cout << list_sequence(myVector, ", ") << "\n";
to list any standard container (such as vector<T> or list<T>) to stdout, or more generally,
cout << list_sequence(begin, end, ", ") << "\n";
to list an arbitrary iterator range between iterators begin and end.
#ifndef SEQUENCE_LISTER_H
#define SEQUENCE_LISTER_H
#include <iostream>
#include <string>
#include <iterator>
template<typename X> class sequence_lister; // Forward reference
template<typename InIter>
inline std::ostream& operator<<(std::ostream& os, sequence_lister<InIter> const& sl) {
// copy(sl._first, sl._last, ostream_iterator<typename InIter::value_type>(os, sl._delim));
for (InIter i = sl._first; i != sl._last; ++i) {
if (i != sl._first) {
os << sl._delim;
}
os << *i;
}
return os;
}
template<typename InIter>
class sequence_lister {
public:
sequence_lister(InIter first, InIter last, char const* delim = "") :
_first(first),
_last(last),
_delim(delim)
{}
// Also allow construction from any container supporting begin() and end()
template<typename Cont>
sequence_lister(Cont& cont, char const* delim = "") :
_first(cont.begin()),
_last(cont.end()),
_delim(delim)
{}
sequence_lister(sequence_lister const& x) :
_first(x._first),
_last(x._last),
_delim(x._delim)
{}
sequence_lister& operator=(sequence_lister const& x) {
_first = x._first;
_last = x._last;
_delim = x._delim;
}
friend std::ostream& operator<< <>(std::ostream& os, sequence_lister<InIter> const& sl);
private:
InIter _first, _last;
char const* _delim;
};
template<typename InIter>
inline sequence_lister<InIter> list_sequence(InIter first, InIter last, char const* delim = "") {
return sequence_lister<InIter>(first, last, delim);
}
template<typename Cont>
inline sequence_lister<typename Cont::const_iterator> list_sequence(Cont& cont, char const* delim = "") {
return sequence_lister<typename Cont::const_iterator>(cont, delim);
}
#endif // SEQUENCE_LISTER_H
Determine a file's size with ISO-C:
long fsize(FILE * file)
{
if(fseek(file, 0, SEEK_END))
return -1;
long size = ftell(file);
if(size < 0)
return -1;
if(fseek(file, 0, SEEK_SET))
return -1;
return size;
}
I can't post the code - it belongs to my employer, after all - but the thing I found most useful is
int number = 2;
sendMessage(makestring() << "This message has a " << number << " in it.");
IOW, in-place stream formatting. Implementation is left as an exercise to the reader (or maybe boost hast it :) ).
finally, my last answer is a string split function which splits on a single character delimiter of your choice.
inline void split(const std::string &s, char delim, std::vector<std::string> &elems) {
std::stringstream ss(s);
std::string item;
while(std::getline(ss, item, delim)) {
elems.push_back(item);
}
}
Reading in a whole file, ISO-C:
size_t fget_contents(char ** buffer, const char * name, _Bool * error)
{
FILE * file = NULL;
char * temp = NULL;
size_t read = 0;
// assume failure by default
*buffer = NULL;
if(error) *error = 1;
do
{
file = fopen(name, "rb");
if(!file) break;
long size = fsize(file);
if(size < 0) break;
// no io error till now
if(error) *error = 0;
temp = malloc((size_t)size + 1);
if(!temp) break;
read = fread(temp, 1, (size_t)size, file);
temp[read] = 0;
// `temp` is needed because realloc may fail here!
*buffer = realloc(temp, read + 1);
if(!*buffer) break;
temp = NULL;
if(error) *error = (size != (long)read);
}
while(0);
// cleanup
if(file) fclose(file);
if(temp) free(temp);
return read;
}
I've found myself writing the equivalent if the function too many times (sorry for typos):
template<class __p> static void deleteVector(std::vector<__p*>& target) {
for(std::vector<__p*>::iterator i = target.begin(); i != target.end(); ++i) {
delete *i;
}
target.clear();
}
Might be the perfect example of where to use some kind of smart pointer, but it's not all projects that uses that kind of coolness.
CCASSERT - force a compile-time assert
#define CCASSERT(predicate) _x_CCASSERT_LINE(predicate, __LINE__)
#define _x_CCASSERT_LINE(predicate, line) typedef char constraint_violated_on_line_##line[2*((predicate)!=0)-1];
Typical usage:
CCASSERT(sizeof(_someVariable)==4)
This is useful for debugging:
#ifdef NDEBUG
#define Dprintf(format, ...)
#else
#define Dprintf(format, ...) \
fprintf(stderr, "[%s]:%s:%d: " format, __FILE__, \
__func__, __LINE__, ##__VA_ARGS__)
#endif
It uses variadic macros.
Edit: use NDEBUG which is standard.
Fastest vs Easiest way to read a full file into a std::string.
string fast(char const* filename) {
ifstream file(filename, ios::ate);
int size = file.tellg();
file.seekg(0, ios::beg);
scoped_array<char> buffer(new char[size]);
file.read(buffer.get(), size);
return buffer.get();
}
string easy(char const* filename) {
ostringstream ss;
ss << ifstream(filename).rdbuf();
return ss.str();
}
Edit by Arrieta:
For the benefit of the community, and as a respectful extension to your clever post, I point out to code provided by Tyler McHenry:
#include <string>
#include <fstream>
#include <streambuf>
std::ifstream t("file.txt");
std::string str((std::istreambuf_iterator<char>(t)),
std::istreambuf_iterator<char>());
Get the number of elements in an array:
#define ITEMSOF(arr) (sizeof(arr) / sizeof(0[arr]))
(0[arr] is identical to arr[0] for arrays but will intentionally fail if it's used against a C++ object that overloads operator[].)
The C++ version is less intuitive but more type-safe:
template<int n>
struct char_array_wrapper{
char result[n];
};
template<typename T, int s>
char_array_wrapper<s> the_type_of_the_variable_is_not_an_array(const T (&array)[s]){
}
#define ITEMSOF(v) sizeof(the_type_of_the_variable_is_not_an_array(v).result)
Taken from this question and Imperfect C++, by Matthew Wilson, section 14.3.
Convert any streamable variable to string:
#include <string>
#include <strstream>
#include <iostream>
using namespace std;
template<class Source>
string ToString(const Source& Value)
{
strstream ss;
ss << Value << '\0';
string os = ss.str();
ss.freeze(false);
return os;
}
See also Evan's lexical_cast answer.
I use this for adding debug logging that (a) disappears in non-debug code and (b) supports variable arguments. Similar to cojocar's answer but doesn't use variadic macros (which aren't supported by all compilers):
extern int MyDebugLogRoutine( const char *fmt, ... );
#ifdef NDEBUG
#define Dprintf(x)
#else
#define Dprintf(x) MyDebugLogRoutine x
#endif
// need double parens
Dprintf(( "Format string that supports %s\n", "arguments" ));
Stringify defined as ToString here
Parse defined simetrically:
template <typename T>
void parse( std::string const & str, T & data )
{
std::istringstream st(str);
st >> data;
}
STL iterator printout (dump to stream) (maybe similar in functionality to sequence_lister here?):
// dump to stream
class stream_dumper {
public:
explicit stream_dumper( std::ostream& o, std::string const & sep = "" )
: out_( o ), sep_( sep ), first_(true) {}
template <typename T>
void operator()( T const & t ) {
if ( first_ ) first_ = false;
else out_ << sep_;
out_ << t;
}
private:
std::ostream& out_;
std::string sep_;
bool first_;
};
// usage
void f( std::vector<int> const & v, std::list<double> const & l ) {
// dump the vertor separating with commas
std::for_each( v.begin(), v.end(), stream_dumper( std::cout, ", ") );
// dump the list separating with |
std::for_each( l.begin(), l.end(), stream_dumper( std::cerr, "|" ) );
}
I used to have a similar solution to free memory held in containers through pointers, but that code is now obsolete with the use of boost::shared_ptr
My own implementation of make_string() as proposed here by Arkadiy:
class make_string
{
public:
template <typename T>
make_string& operator<<( T const & datum )
{
buffer_ << datum;
return *this;
}
operator std::string () const
{
return buffer_.str();
}
private:
std::ostringstream buffer_;
};
// usage:
void f( std::string const & );
int main()
{
std::string name = "David";
f( make_string() << "Hello " << name << "!" );
}
j_random_hacker suggests adding a const char* conversion to the class above so that it can be used with legacy/C libraries that take null terminated strings. I have had not that much time to think about it, but I feel unease as adding that conversion would allow the following code to compile [edit: bad example, read answer to second comment]:
const char* str = make_string() << "Hello world"; // 1
// ...
std::cout << str << std::endl; // 2
To the compiler the code above is correct, but the usage is wrong as in line 1 the make_string() temporary is destroyed and the pointer is no longer valid.
Response to second comment:
Assume a simple implementation of const char* operator:
class make_string
{
// ...
public:
operator const char* ()
{
return buffer_.str().c_str();
}
};
The str() creates a std::string object, whose scope is inside the operator const char_ method. The c_str() returns a pointer inside that std::string. By the time the caller receives the pointer, the std::string has gone out of scope and the memory has been released.
The other big difference with the code sample where the user requests the .c_str() from the std::string returned from the conversion operator is that the user is explicitly doing it and as such it appears in the code. If the conversion to null terminated string is implemented the user will have more trouble to detect where the error is.
void f( std::string const & );
void g( const char* );
f( make_string() << "Say hi" ); // works ok
g( make_string() << "Bye" ); // kills the application
g( (make_string() << "Hi again").c_str() ); // ok again std::string temporary is alive until g() returns
Now, try to explain what is so wrong with the second and not with the first or third lines one to the poor programmer whose application keeps dying. After all, she is just using a feature you are offering.
Another detail is that you could have a std::string member attribute and use it to force the lifespan of the std::string to be equivalent to that of the make_string object.
Anyway, I recomend everyone to read Modern C++ Design from Andrei Alexandrescu, and specially the chapter on smart pointers. The discussion of what features to implement is quite interesting. It changed my set of mind from 'implement as many features as you can' to a more conservative 'implement what is required, weight advantages and disadvantages of all other features'
#include <queue.h>
Never write buggy linked list implementations again.
#include <tree.h>
Never write buggy tree implementations again.
Fully portable and legal for close-source commercial products.
What a coincidence! I'm just collecting mines here. Everything is in C and is meant to be absolutely minimal, with as few dependencies as possible. At the moment I have:
It's a work in progress and I add code, examples and documentation when time permits. The code is for my own projects but is released under BSD should someone else find it useful.
When calling a Win32 API that wants to write into a string buffer, it would be nice to be able to pass it a std::string or std::wstring directly.
Here's a simple way to enable that:
template <class C>
class _StringBuffer
{
typename std::basic_string<C> &m_str;
typename std::vector<C> m_buffer;
public:
_StringBuffer(typename std::basic_string<C> &str, size_t nSize)
: m_str(str), m_buffer(nSize + 1) { get()[nSize] = (C)0; }
~_StringBuffer()
{ commit(); }
C *get()
{ return &(m_buffer[0]); }
operator C *()
{ return get(); }
void commit()
{
if (m_buffer.size() != 0)
{
size_t l = std::char_traits<C>::length(get());
m_str.assign(get(), l);
m_buffer.resize(0);
}
}
void abort()
{ m_buffer.resize(0); }
};
template <class C>
inline _StringBuffer<C> StringBuffer(typename std::basic_string<C> &str, size_t nSize)
{ return _StringBuffer<C>(str, nSize); }
So now I can say:
std::string str;
GetWindowsDirectory(StringBuffer(str, MAX_PATH), MAX_PATH);
StringBuffer gives a writeable buffer to the API, and then on destruction it copies it into str.
Here is one of mines that I didn't saw it here (reproduced without a compiler, might not be exact):
class Monitor
{
private:
CRITICAL_SECTION cs;
public:
Monitor() { InitializeCriticalSection(&m_cs); }
~Monitor() { DeleteCriticalSection(&m_cs); }
void Lock() { EnterCriticalSection(&m_cs); }
void Unlock() { LeaveCriticalSection(&m_cs); }
};
class Locker
{
private:
Monitor& m_monitor;
public:
Locker(Monitor& monitor) : m_monitor(monitor) { m_monitor.Lock(); }
~Locker() { m_monitor.Unlock(); }
};
#define SCOPE_LOCK(monitor) Locker locker##__LINE__(monitor)
And it can be used like this:
class X : public Monitor {};
X x;
void use_x()
{
SCOPE_LOCK(x);
//use x
//on scope exit, x is unlocked
}
void
dprintf (char *format, ...)
{
#ifdef DEBUG
{
int rete;
va_list args;
static char buffer[1000000];//yes 1000000, I need this to debug
int ret;
va_start (args, format);
ret = vsprintf (buffer, format, args);
OutputDebugString (buffer);
printf (buffer);
}
#else
return;
#endif
}
When a class need to override the default copy constructor/assignment I sometime use something like this:
class SomeClass
{
struct Members
{
int a;
int b;
};
Members m;
int* evilptr;
public:
SomeClass(SomeClass const& rhs) : m(rhs.m), evilptr(new int(*rhs.evilptr))
{
}
~SomeClass(){ delete evilptr; }
SomeClass& operator=(SomeClass const& rhs)
{
m = rhs.m;
evilptr = new int(*rhs.evilptr);
return *this;
}
};
This way, if you add a new members to the class you can't forget to add it to the copy constructor/assignement operator. This save some possibility of error.
Of course in my exemple I could use some kind of clone_ptr but in real life this is not always this simple. Also beware that I never check for NULL in my exemple when dereferencing evilptr, you should of course adapt the code according to your needs.
[Edit]: I added a destructor for those complaining about memory leaks. Please note that I still omit a lot of checks as the point I was trying to illustrate was that with wrapping normally-copyable variable in a struct you don't need to update the copy constructor/assignment operator when adding/removing a variable from a class. That's the only point of my answer so please try to judge it on that and not on a bunch of other points not really related to the case.
Working with VTK the following defs were useful:
#define EPSILON 0.00001
// ex. if ( FLOAT_EQ(d,1) ) ...
#define FLOAT_EQ(x,y) ( ((x-EPSILON) < y) && (y < (x+EPSILON)) )
// Fit "val" to be between e1 and e2, just like vtkMath::ClampValue
#define FLOAT_CLAMP(val, e1, e2) \
{\
if ( (val)<(e1) ) (val)=(e1); \
if ( (val)>(e2) ) (val)=(e2); \
}
// 3D coordinate
#define FLOAT_COPY(src, dst) \
{\
(dst)[0]=(src)[0]; \
(dst)[1]=(src)[1]; \
(dst)[2]=(src)[2]; \
}
#define FLOAT_FILL(v, value) \
{\
(v)[0]= (v)[1]= (v)[2]=(value); \
}
#define FLOAT_SET(v, x,y,z) \
{\
(v)[0]=(x); \
(v)[1]=(y); \
(v)[2]=(z); \
}
Of course "const double epsilon = 0.00001;" and similar can be used instead of define. There's a CodeGuru article with explanations
This class to trace the time spent on the execution of the expressions in the scope:
#include <iostream>
#include <sys/time.h>
class trace_elapsed_time
{
public:
explicit trace_elapsed_time(const std::string& msg, std::ostream& out = std::cout)
: msg_(msg), out_(out)
{
gettimeofday(&init_time_, 0);
}
~trace_elapsed_time()
{
timeval now;
gettimeofday(&now, 0);
double elapsed_seconds = now.tv_sec - init_time_.tv_sec +
now.tv_usec/1e6 - init_time_.tv_usec/1e6;
std::string::size_type pos = msg_.find("%t");
out_ << msg_.substr(0, pos) << elapsed_seconds
<< msg_.substr(pos+2, msg_.size()-1) << std::flush;
}
private:
std::string msg_;
std::ostream& out_;
timeval init_time_;
};
Example of use:
int main()
{
trace_elapsed_time t("Elapsed time: %ts.\n");
usleep(1.005 * 1e6);
}
Output:
Elapsed time: 1.00509s.
Note: You can make this code portable using boost time functions and linking against the corresponding library.
Note2: I recently found a very similar multiplatform utility in boost: boost::progress_timer
A simple hexdumpis often good to have...
#include <ctype.h>
#include <stdio.h>
void hexdump(void *ptr, int buflen) {
unsigned char *buf = (unsigned char*)ptr;
int i, j;
for (i=0; i<buflen; i+=16) {
printf("%06x: ", i);
for (j=0; j<16; j++)
if (i+j < buflen)
printf("%02x ", buf[i+j]);
else
printf(" ");
printf(" ");
for (j=0; j<16; j++)
if (i+j < buflen)
printf("%c", isprint(buf[i+j]) ? buf[i+j] : '.');
printf("\n");
}
}
This is EVIL! I know, but has come in handy:
#define private public
#include "OhSoEncapsulatedLittleObject.hpp" // Let me at'em!
#undef private
typedef boost::shared_ptr<Foo> FooPtr;
systematically getting team to use shared_ptr and using it in a common way
Thought there were far too few answers that can be used with C.
#include <getopt.h>
#define HAS_ARG 1
static struct option longopts[] = {
{ "option-a", HAS_ARG, 0, 'a' },
{ "option-b", HAS_ARG, 0, 'b' },
{ 0, 0, 0, 0 }
};
void show_usage(char* argvzero)
{
printf("%s usage\n", argvzero); /* more follows */
}
int process_args(int argc, char** argv)
{
/* do stuff to process the commandline options using <getopt.h> API */
};
A very nerd one, which works if you are surrounded by nerds who do not care about code maintenance:
#define as ;while
int main(int argc, char* argv[]){
int n = atoi(argv[1]);
do printf("n is %d\n", n) as ( n --> 0);
return 0;
}
In my C code, I often have dynamic array structures declared like this:
struct {
int num;
SomeType *list;
} foobar;
To make that easier in code where I'm iterating over those dynamic arrays a lot, I use this macro:
#define FOREACH(var,lst) \
for(i=0 ; (i<(lst).num?(((var)=(lst).list[i]),1):0) ; i++)
Which means I can then do this:
int i;
SomeType foo;
FOREACH(foo, foobar) {
/* Do something with foo here... */
}
While yes, it's not the world's most reusable (the i is an issue, but that's awkward to fix and maintain strict C89 compatibility) it helps a lot because it means that I have my iteration code written correctly, once. I have another similar construct – FOREACH_HASH – for iterating over the key/value pairs in hash tables, but that's more horrific and harder for other people to reuse so I won't repeat it here.
With C++0x, I have a neat little string builder that I like to pass as arguments to exceptions, etc.
#include <sstream>
#include <iostream>
using namespace std;
void mksubstr(const ostringstream& stream)
{
(void)stream;
}
template<class T, class... Args>
void mksubstr(ostringstream& stream, const T& first, const Args&... rest)
{
stream << first;
mksubstr(stream, rest...);
}
template<class T, class... Args>
string mkstring(const T& first, const Args&... rest)
{
ostringstream buf;
buf << first;
mksubstr(buf, rest...);
return buf.str();
}
int main()
{
int x = 1, y = 10;
cout << mkstring("Foo: (", x, ", ", y, ")") << endl;
}