There are a number of “smart pointer” implementations in C++. Each one has a different set of features and it seems hard to pick one that satisfies scenarios.

auto_ptr: Available as part of the standard C++ library (#include ). Has the several useful features and shortcomings:

1. Pointer initializes itself to 0 if not explicitly initialized
2. Pointer automatically deletes itself when it goes out of scope
3. Only one auto_ptr can point to an object at a given time (so no question of reference counting). If you do x=y auto_ptr x will now point to what was pointed to by y. But y will now point to NULL!!
4. Does not work for arrays because it deletes its pointer with delete and not delete []
5. Does not work with STL. Warning: May appear to work but reportedly results in subtle devastating bugs
6. It is not thread safe

Feature 3 limits its usefulness IMHO. This article – Using auto_ptr Effectively – summarizes auto_ptr features.

shared_ptr: This pointer from  the BOOST C++ library uses reference counting. So a shared_ptr that is assigned to another will point at the same object in memory and will increment a reference count to that object. When either of the pointers is deleted the object reference count is decremented. If the object reference count is zero the object is truely deleted from memory.

1. Reference counted
2. Does NOT do copy on write. If shared_ptr x is assigned to y and later *x (or *y) is changed then the memory location pointed to is changed (just like a regular pointer)
3. Cycling references may lead to memory leaks – this is a problem with reference counting itself and not this specific implementation
4. Thread safety – some operations seem atomic. See BOOST docs.
5. Cannot hold a pointer to an array (see shared_array)
6. Pointer automatically deletes itself (or reduces reference count) when it goes out of scope

This may be already added to C++ standard library in the near future (already in?).

C++ file I/O quick notes.

Gcc will not produce any warnings about uninitialized variables if the optimization level is not 1 or greater. The following code has an obvious uninitialized variable problem.

test.c

int foo() {
    int x;
    return x;
}

But gcc (3.4 and 4.2.1) produces no warning or error when you use this command line:

gcc -Wall -Werror -O0 test.c
gcc -Wall -Werror  test.c (this defaults to -O0)

I have tested the above on Linux as well as Mac OS X.
The -Wall flag is supposed to automatically include the -Wuninitialized flag. But if the optimization level is 0 then the check for uinitialized variables is not done.

gcc -Wall -Werror -Wuninitialized test.c

If included explicitly like above:

$ gcc -Wall -Werror -Wuninitialized test.c
cc1: warnings being treated as errors
cc1: warning: -Wuninitialized is not supported without -O

For gcc to check for uninitialized variables you need to throw at least -O1 optimization.

From the gcc man page:

-Wuninitialized
Warn if an automatic variable is used without first being
initialized or if a variable may be clobbered by a “setjmp” call.

These warnings are possible only in optimizing compilation, because
they require data flow information that is computed only when
optimizing. If you do not specify -O, you will not get these
warnings. Instead, GCC will issue a warning about -Wuninitialized
requiring -O.

However, uninitialized checking does not seem to work correctly. This code compiles on Mac OS X (Snow Leopard):

#include <stdlib.h>
#include <iostream>

int main() {

    int l_retVal;
    unsigned int x = 1;
    unsigned int y = random() % 10;
    if(y == x) {
        l_retVal = 2;
        std::cout<<"HERE \n";
    }
    return l_retVal;
}

$ g++ -Wall -Werror -Wuninitialized -O test.cpp
$

• Blog on using Linux Oprofile on Ubuntu
• Using GNU’s GDB Debugger – a good introduction and tutorial.
• Compiler tools website
• Supplement to the “dragon book” (Compilers: Principles, Techniques, and Tools)
• GCC Internals
• Online version of “Linkers and Loaders” by John Levine
• Linux Journal Article on Linkers and Loaders

• NVIDIA GPU Gems1 book online
• NVIDIA GPU Gems2 book (discusses GPU architecture) online

OpenCL Links

• ATI: An Introduction to OpenCL – Short article
• AMD: Introductory Tutorial to OpenCL – Short Article
• MacResearch OpenCL Tutorials
• OpenCL Programming Guide for Mac OS X
• Apple documentation on  Concurreny and Application Design – not strictly OpenCL but concurrent programming.
• OpenCL Tutorial at GPGPU – Presented at PPAM 2009
• High Performance Computing with CUDA Tutorial at NVIDIA.com

TCLAP library

Why not to use double precision to represent objects in 3D – TomF’s Tech Blog

Interesting post on how debuggers work.

Other interesting articles:

1. Abusing mach on Mac OS X: Discusses how to replace some ptrace functionality using Mach functions
2. mach_star and mach_inject (still being developed?): Opensource code to dynamically load your code into a running process. Port for Intel machines. Also see this link.

Ok not quite game physics but a very good article on modeling collisions in a game. The author talks about modeling both “hard” collision – like a billiards ball hitting another – and soft collisions (sumo wrestlers).

Article at MacResearch: The Physics of Sumos (A Flirtation with iPhone Game Development)