Yesterday I posted about rvalue references and move semantics. What's really impressive to me is the range of problems solved by the introduction of rvalue references. An interesting example of this is removing sharp edges from my old friend std::auto_ptr, allowing it to be deprecated in favor of the new std::unique_ptr.

std::auto_ptr was ( Read more... )

Dear Lazyweb,
In a C++ function with C linkage, are the arguments stored in a predictable way such that, e.g., I could cast the location of the first argument to a pointer to a struct containing the argument list?

Background

There is a commercial finite element package, ABAQUS, which has the nice feature of letting you programmatically define ( Read more... )

Cube

I can solve a Rubick's Cube without looking at instructions. Some of the moves I “get”; some of them I don't, but now that they are memorized I can watch them carefully and am beginning to understand them. Cool.

Movie

I watched The Professional. Wow. Awesome. In that, I noticed an actor I hadn't noticed before: Gary Oldman who plays the ( Read more... )

I'm taking a course this semester called Generic Software Design. One fascinating piece of reading for the course is Notes on Programming (PDF) by Alex Stepanov, father of the STL. It's great reading that seems deceptively simple, just designing a class that represents a vector of integers. But even this simple design exercise exposes some very ( Read more... )

I didn't know this was possible:

template class C1,
template class C2>
struct is_same_template {
static const bool value = false;
};

template class C1>
struct is_same_template {
static const bool value = true;
};

With that you can then do

BOOST_STATIC_ASSERT(( is_same_template::value ));
BOOST_STATIC_ASSERT(( !is_same_template::value ( Read more... )

When using C++, include cmath and not math.h. That is where you will find the overloaded T std::abs(T) and T std::pow(T, int) that you surely want to be using.

On the subject, do remember to use T std::max(T, T) and T std::min(T, T) (found in the algorithm header) rather than any crazy C-style macro definitions ( Read more... )

In C++ there's a problem with making const-correct accessors. You either need to implement the access twice or you need to use const_cast in one implementation. Neither of these solutions is elegant. The following isn't elegant either, but it has different problems. The idea is that functions with templated arguments can be called with const and ( Read more... )

Dear Lazyweb,
I'm fairly new to creating libraries. Today I ran into a bug in which two libraries I linked against both had a class named Timer. When I dynamically linked, I got insidious memory-stomping behavior; when I statically linked, I got a link error. I have the source for one so I put Timer in a namespace and it worked fine. (Previously ( Read more... )

In C++, static_cast(some_double) converts some_double to an int. In general, C++-style casts are safer than the C-style casts because they make explicit the intent of the cast. However, when converting a double to an int, is there any reason to use static_cast rather than using int's constructor: int(some_double)?

I see static_cast used like this ( Read more... )

In C++, the standard map structure, std::map, is implemented as a tree. This is generic in that it only requires a less-than operator of the key, but it isn't as fast as a hash table. I believe it's in the pipeline for future versions of C++, but I somehow only now discovered this g++ extension:

#include
using __gnu_cxx::hash_map;

It even resizes ( Read more... )