A tail call is a specific pattern of source code where the last instruction executed in a method is another function call. For instance:
[cpp]
int last( int i );
int second( int i );
int first( int i ) {
int j = second( i );
return last( j );
}
[/cpp]
In this code, the call to last is considered a tail call because there are no further instructions to execute once the call is made.
Continue reading
At my day job, we do a lot of complex math calculations in our frameworks. To increase performance, we have enabled the optimizer to use certain assembly instruction sets such as MMX and SSE. However, we have found that not all customers have processors which support these instruction sets. A while back, I added a simple CPUID check to the library initialization code to ensure the customer had SSE support on chip and I figured that was the end of that. I was wrong.
Continue reading
I had a very nice holiday season this year, and I hope you did as well. My wife and I went down to TX to visit her family, and spend time lounging in a beach house. I didn’t write any blog posts while I was there because I was too busy playing Skyrim, fishing and eating copious amounts of delicious food. However, now that I’ve come crashing back to the realities of life, I’ll start blogging again.
Since it’s 2012 now, I figured it might be fun to reflect on what technologies I found important in 2011.
And I can’t list the good without listing the bad as well!
If you’d like to share your technology hits and misses, feel free! Otherwise, I hope you had a great 2011, and have an even better 2012 (unless the world ends because the Mayans were right :: snorts ::)!
In the STL, there are multiple classes of iterators: random access, bidirectional, forward, input, and output. I’d like to discuss the different types of iterators in a bit more detail, so that I can whine about “missing” functionality.
Continue reading
A coworker approached me today with an interesting problem and I figured I’d talk about the crazy acrobatics that solved it.
He wanted to fill out a list of operations to perform that could be registered easily “at compile time”, so that the list could be traversed later to perform these operations. Basically, he wanted his code to look something like this:
[cpp]
typedef std::map< const char *, void (*)( void ) > WorkItemList;
static WorkItemList sWork;
void some_function( void ) {
// Do some work
}
REGISTER( "operation 1", some_function );
REGISTER( "operation 2", some_function );
void some_other_function( void ) {
// Do some work
}
REGISTER( "operation 3", some_other_function );
REGISTER( "operation 4", some_other_function );
REGISTER( "operation 5", some_other_function );
// Later
void DoWork( const char *workItem ) {
WorkItemList::iterator iter = sWork.find( workItem );
if (iter != sWork.end())
iter->second();
}
[/cpp]
So how do you make this work?
Continue reading
On Windows, when you need to access a string resource, you turn to the LoadString API. It takes care of finding the string for you, loading it, and copying it into the buffer you supply. However, there are times when LoadString simply falls short. For instance, for my day job, I found myself needing to access localized resources regardless of the user’s current UI locale. The only way to do this is to use the FindResourceEx function and pass in the specific language you’re after. This works fine for most resources, but strings would always come back as not found! I want to cover this particular case in more depth today.
Continue reading
I’m a big proponent of using design patterns whenever they are the proper tool for the job. One of the design patterns I find myself pulling out of the toolbox fairly frequently these days is the visitor design pattern. However, it’s not one of the more common patterns you see many people blogging about. So I’d like to cover it with some real-world examples of how I put it to use.
Continue reading
Type traits are a slightly more advanced topic in C++ because it they are heavily used in template metaprogramming. However, it is not an impenetrable concept, and it comes with some great benefits if you like to write generic, reusable code. I’d like to give you a simple introduction to the concept of type traits, and show some of the more beneficial use cases for them.
Continue reading
While fiddling around a bit with clang, I came across an interesting C++ language extension from Microsoft. If you’ve done library development on Windows, you’ve likely come across the __declspec keyword for things like importing and exporting symbols from a framework. You use __declspec( dllexport ) or __declspec( dllimport ), respectively. The __declspec keyword is basically Microsoft’s version of attributes, though it predates the concept (in C++) by many years. The __declspec that caught my eye was __declspec( property ). It’s way to have automatically generated getter and setter behavior for C++ class member variables. At first, I thought this was a great feature! Then I looked into it a bit more.
Continue reading
Destructors are one of those inescapable concepts in C++. We’ve all used them, many times without even really thinking about it. But how do destructors work? What can and can’t you do with destructors? There’s a lot more complexity to this seemingly simple concept than meets the eye.
Continue reading
Aaron Ballman is a Principal Compiler Engineer for Intel and is the lead maintainer of the Clang open source compiler. He has two decades of experience writing cross-platform frameworks in C/C++, compiler & language design, and software engineering best practices and is currently a voting member of the C (WG14) and C++ (WG21) standards committees.
In case you can't figure it out easily enough, the views expressed here are my personal views and not the views of my employer, my past employers, my future employers, or some random person on the street. Please yell only at me if you disagree with what you read.
