bool element_in_list_p(node* startFrom, const element& what)
{
	node* iter = startFrom();
	while(iter != NULL)
	{
		if(iter->value == what)
		{
			return true;
		}
		iter = iter->next;
	}
	return false;
}

bool element_in_list_p(node* startFrom, node* end, const element& what)
{
	end->next = new_list_node(what);

	node* iter = startFrom();
	while(iter->value != what)
	{
		iter = iter->next;
	}
	
	if(iter == end) //doszlismy do konca listy - elementu nie bylo
	{
		delete_list_node(end->next);
		end->next = NULL;
		return false;
	}
	//element znaleziony
	delete_list_node(end->next);
	end->next = NULL;
	return true;
}

1. Przekazujemy je do funkcji wyższego rzędu, takich jak map czy reduce.
2. Ponieważ są to obiekty, możemy trzymać w nich dodatkowe informacje lub umożliwiać wykonywanie na nich dodatkowych operacji.

class MathFunction
{
//...
public:
	MathFunction FirstDerivative(); //funkcja zwracajaca nam pierwsza pochodna
	double operator() (double x); //funkcja zwracajaca nam wartosc w punkcie
};

//uzycie
MathFunction funkcja;
double wynik = funkcja(100.0);
std::for_each(dane.begin(), dane.end(), funkcja);

(defclass math-function ()
  () ; tutaj mozemy umieszczac sloty, czyli zmienne skladowe
  (:metaclass ccl:funcallable-standard-class))

(defgeneric first-derivative ()
  (:documentation "Returns analytical first derivative of a function."))

(defmethod first-derivative ((f math-function))
  (...)) ; kod metody pomijam

(defmethod initialize-instance :after ((f math-function) &key code)
  (set-funcallable-instance-function f code))

; stworzony obiekt zapisujemy do zmiennej square
(setq square (make-instance 'math-function :code (lambda (x) (* x x))))

; uzycie:
(funcall square 3)
;wynik: 9

(setf (fdefinition 'square) square)

; ponizszy kod teraz bedzie dzialal:
(square 3)
; wynik: 9

• Uproszczony lexical_cast
• Obiekty do łatwego synchronizowania operacji na std::ostream(tak, na std::cout też!) w programach wielowątkowych
• Funkcję do pobierania czasu z milisekundową rozdzielczością
• Pomocnicze makra zastępujące powtarzający się w kółko kod
• Pomocnicze funkcje do wygodnego fork() (łącznie z przepinaniem STDIN i STDOUT dziecka); fork-exec idiom trzeba sobie zrobić samemu, ale co to za problem wywołać sobie funkcję exec() :P.
• Klasy izolujące nienazwane i nazwane pipe'y (FIFO), semafory, pamięć współdzieloną i kolejki komunikatów
• Inne pomocnicze funkcje

//================================================================
//Beta section
//================================================================
int process_beta(void* data)
{
	betaQueue.attach();
	alphaSharedQueue.attach();

	char buffer[1024];

	while(true)
	{
		std::memset(buffer, 0, 1024*sizeof(char));
		
		//get data from msg queue
		betaQueue.receive_message(buffer);

		//cut out last two letters
		buffer[std::max(static_cast<int>(std::strlen(buffer)) - 2, 0)] = '\0';

		//send data via message queue to P1
		alphaSharedQueue.send_message(buffer);
	}

	return 0;
}

while(1)
{
	if(board.GetMainBoard().analog(7) > FORWARD_THRESHOLD)
	{
		board.GetMainBoard().motor(0, 255);
	}
	else
	{
		board.GetMainBoard().motorsOff();
	}
}

//(...)
//gdzies tam w konstruktorze:
//set up ir sensor data
irSensorSettings[0] = 0; 	irSensorRanges[0] = 1.3f;
irSensorSettings[1] = 12;	irSensorRanges[1] = 0.65f;
irSensorSettings[2] = 15;	irSensorRanges[2] = 0.34f;
irSensorSettings[3] = 25;	irSensorRanges[3] = 0.30f;
irSensorSettings[4] = 30;	irSensorRanges[4] = 0.24f;
irSensorSettings[5] = 40;	irSensorRanges[5] = 0.16f;
irSensorSettings[6] = 50;	irSensorRanges[6] = 0.13f;
irSensorSettings[7] = 75;	irSensorRanges[7] = 0.08f;
irSensorSettings[8] = 100;	irSensorRanges[8] = 0.06f;
irSensorSettings[9] = 150;	irSensorRanges[9] = 0.025f;
//(...)
//magiczna funkcja:
int GetIRThresholdForDistance(float distance)
{
	for(int i = 1 ; i < IR_SENSOR_SAMPLES ; ++i)
	{
		if(distance > irSensorRanges[i])
		{
			float scale = (distance - irSensorRanges[i])/(irSensorRanges[i-1] - irSensorRanges[i]);
			return static_cast<int>(irSensorSettings[i]*(scale) + irSensorSettings[i-1]*(1.0f-scale));
		}
	}
	return 0;
}

Robot, którego programowałem

#define GUARD(functionName) {static const char __GUARDED_FUNCTION_NAME__[] = #functionName; try{
#define UNGUARD } catch(...) { Framework->GetErrorManager()->AddCallHistory(__GUARDED_FUNCTION_NAME__); throw; } }
//przyklad uzycia
void funkcja_chroniona()
{
	GUARD(funkcja_chroniona);
	//jakies operacje
	UNGUARD(funkcja_chroniona);
}

//punkt obslugi, fragment jakiejs funkcji
//...
try
{
	EnterMainLoop();
}
catch(std::exception& exc)
{
	errorSystem->DisplayException("STL exception", exc.what());
}
catch(CMyException& exc)
{
	errorSystem->DisplayException(exc.type(), exc.what());
}
catch(...)
{
	errorSystem->DisplayException("Unknown exception", "Unknown error");
}
//...

• Każdą chronioną funkcję / blok kodu trzeba zawierać w makrach GUARD/UNGUARD
• Blok try/catch powoduje zwiększenie czasu wykonania funkcji
• Utrudnione lub wręcz uniemożliwione jest używanie w kodzie wyjątków w celach innych niż obsługa błędów krytycznych, powodujących awaryjne zakończenie pracy programu

• Zastosowanie dyrektyw #ifdef / #else / #endif do warunkowej kompilacji makr GUARD/UNGUARD, dzięki czemu można będzie je łatwo wyłączyć
• Stworzenie dodatkowej pary makr GUARD_SLOW i UNGUARD_SLOW, które będą automatycznie wyłączane w wersji wydaniowej (patrz punkt poprzedni), a które stosowane będą w funkcjach wymagających możliwie wysokiej wydajności
• Połączenie chronienia funkcji z własnymi makrami Assert/Verify, dzięki czemu przerywając pracę programu uzyskamy dokładne informacje o miejscu naruszenia asercji i drodze do tego miejsca. Własne makra Assert/Verify opiszę w przyszłości.
• Połączenie makra GUARD z loggerem, dzięki czemu nazwa funkcji będzie automatycznie dopisywana do komunikatu. Jest to duże udogodnienie, jeśli ktoś zapisuje nazwy funkcji do loga.
• Przerobienie makr, by system działał w oparciu o Unicode (w przypadku kodu, który w całości jest oparty o to kodowanie znaków)

• 0xBAADFOOD - funkcja HeapAlloc() w taki sposób inicjuje alokowaną pamięć
• 0xFEEEFEEE - funkcja HeapFree() w taki sposób czyści zwolnioną pamięć
• 0xFDFDFDFD - w ten sposób malloc() oznacza cztery bajty przed i cztery bajty po przydzielonym bloku pamięci (służą jako 'strażnicy')
• 0xDDDDDDDD - funkcja free() tak oznacza zwolnioną pamięć

• Czas rzeczywisty trwania profilowanego bloku (w milisekundach)
• Ilość wywołań danego bloku w ciągu jednej klatki profilowania (np. w ciągu jednego obiegu pętli głównej)
• Procentowy czas trwania wszystkich wywołań bloku w danej klatce profilowania w stosunku do czasu trwania klatki

#ifdef _UNICODE
typedef wchar_t achar;
typedef std::wstring astring;
typedef std::wstringstream astringstream;
typedef boost::wformat aformat;
//(...)
#else
typedef char achar;
typedef std::string astring;
typedef std::stringstream astringstream;
typedef boost::format aformat;
#endif

#ifdef _UNICODE
#define ATEXT(x) L##x
#else
#define ATEXT(x) x
#endif

#ifdef _UNICODE
#define astrdate _wstrdate
#define astrcpy wcscpy
//(...)
#else
#define astrdate _strdate
#define astrcpy strcpy
//(...)
#endif

#ifdef ANYTHING_USE_SEH

#pragma comment (lib, "Dbghelp.lib")

#include <dbghelp.h>
#include <shellapi.h>
#include <shlobj.h>

#endif //ANYTHING_USE_SEH

namespace Anything
{
	int GameMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
	{
		(...)
	}
} //end of namespace Anything

#ifdef ANYTHING_USE_SEH

//SEH stuff...
//credit to st3tc for showing me this idea
int GenerateDump(EXCEPTION_POINTERS* pExceptionPointers)
{
	MINIDUMP_EXCEPTION_INFORMATION ExpParam;
	SYSTEMTIME stLocalTime;
	HANDLE hDumpFile;
	char szFileName[MAX_PATH];

	GetLocalTime( &stLocalTime );
	std::sprintf( szFileName, "CrashDump-%04d%02d%02d-%02d%02d%02d.dmp",
	stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
	stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond );

	hDumpFile = CreateFile( szFileName, GENERIC_READ|GENERIC_WRITE,
	FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);

	ExpParam.ThreadId = GetCurrentThreadId();
	ExpParam.ExceptionPointers = pExceptionPointers;
	ExpParam.ClientPointers = TRUE;

	MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile, MiniDumpNormal, &ExpParam, NULL, NULL);
	return EXCEPTION_EXECUTE_HANDLER;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	__try
	{
		int retCode = Anything::GameMain(hInstance, hPrevInstance, lpCmdLine, nShowCmd);
		return retCode;
	}
	__except(GenerateDump(GetExceptionInformation()))
	{
	}
	return 0;
}

#else

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	return Anything::GameMain(hInstance, hPrevInstance, lpCmdLine, nShowCmd);
}

#endif //ANYTHING_USE_SEH

if( uZmienna< std::numeric_limits<signed int>::max() )
//przekroczono maksymalna wartosc int'a
//uZmienna ma typ unsigned int

if( fDistance - fRadius < std::numeric_limits<float>::epsilon() )
//fDistance i fRadius sa typu float
//przykladowy kod mogacy pochodzic z niezbyt zoptymalizowanego
//sprawdzania kolizji sferami otaczajacymi

• Wyjście tekstowe - najważniejsze i najczęściej stosowane. Bezpośredni zapis komunikatów do pliku tekstowego, z ewentualnym niewielkim formatowaniem.
• XHTML - zapis do pliku XHTML jest niewiele bardziej skomplikowany od wyjścia tekstowego - musi tylko ujmować komunikaty w odpowiednie tagi formatujące. Ta metoda pozwala nam na wizualne wyróżnianie komunikatów (np. zaznaczenie komunikatów o błędzie na czerwono). W połączeniu z arkuszami CSS log w tym formacie może się okazać bardzo przyjazny dla odczytującego, oraz nadawać się do natychmiastowego wrzucenia na stronę internetową.
• XML - zapis w XML'u jest bardzo podobny do zapisu w XHTML, jednak pozwala programiście na wygodne zapisanie wszystkich informacji o komunikacie w postaci tagów XML. Tak stworzony plik może być zarówno odczytywany, jak i parsowany przez inne programy. Na GameDev.net można znaleźć wart przeczytania artykuł, który prezentuje możliwości zapisu w XML.
• RTF - jest to ciekawy format zapisu, zaproponowany i omówiony w ciekawym artykule na GameDev.net. Oferuje on funkcjonalność podobną do plików XHTML.
• OutputDebugString() - w systemie Windows mamy do dyspozycji funkcję OutputDebugString(), która wypisuje podany jej jako argument tekst do okna debuggera (jeśli ten jest włączony). Posiadanie takiego wyjścia warto rozważyć, jeśli korzystamy z debuggera w czasie tworzenia naszej aplikacji. Jako ciekawostkę polecam artykuł z CodeProject.com, w którym autor prezentuje klasę strumienia podobną do std::ostream korzystającą z OutputDebugString()
• Konsola Windows - wspomniana już w artykule, do którego przeczytania zachęcałem na początku. To szczególne wyjście pozwala nam śledzić komunikaty o błędach w czasie rzeczywistym. System Windows pozwala też na łatwą zmianę kolorów wypisywanego tekstu, co dobrze współpracuje z komunikatami loggera o różnych priorytetach. Konsola Windows, gdy jest wyświetlana, ma jednak zabójczy wpływ na framerate (jeśli będzie zainteresowanie, to rozszerzę ten temat). Temat używania konsoli jest szerszy i osobiście zachęcam zapoznanie się z artykułem Regedita pod tytułem "Asynchroniczna konsola Windows".
• Dziennik zdarzeń Windows - ten rodzaj wyjścia może być mało przydatny w grach, ale warto wspomnieć o jego istnieniu. Systemy Windows z rodziny NT prowadzą tak zwany dziennik zdarzeń, w którym logują ważne zdarzenia w systemie. Odczytać ten dziennik można przez narzędzie MMC. Temat sposobów zapisu do tego dziennika pozostawię Czytelnikowi do zbadania samodzielnie; podpowiem jedynie funkcję ReportEvent() (choć jeśli będzie zainteresowanie, to i o tym mogę tu napisać szerzej).
• Wyjście w sieć - jeśli "po drugiej stronie" mamy uruchomiony odpowiedni program, to możemy stworzyć połączenie komunikaty loggera wysyłać przez sieć - czy to w obrębie lokalnej maszyny, czy to przez Internet. Zdalne debugowanie aplikacji to kolejny szeroki temat do omówienia; sygnalizuję teraz jedynie jego istnienie.

[TYP KOMUNIKATU] [CZAS] Klasa::Funkcja() - komunikat

[S] [10:15:51] CTexture::Load() - loaded texture textures/font.tga - width: 512, height: 512, bpp: 32.

• Drzewa, alias "Trudny Wybór"
• Osie Symetrii, alias "Nieśmiały Chłopak 98bpm", znane popularnie pod nazwą "GOsie"

• Megalopolis, alias "Słowa"

const ulLenVendorPreferred = wcslen(pszVendorPreferred);

const size_t ulLenVendorPreferred = wcslen(pszVendorPreferred);

static CoMemCopyWFEX(const WAVEFORMATEX * pSrc, WAVEFORMATEX ** ppCoMemWFEX)

static HRESULT CoMemCopyWFEX(const WAVEFORMATEX * pSrc, WAVEFORMATEX ** ppCoMemWFEX)

for (const WCHAR * psz = (const WCHAR *)lParam; *psz; psz++) {}
return psz + 1;

const WCHAR * psz = (const WCHAR *)lParam;
for (; *psz; psz++) {}
return psz + 1;

template <typename destT, typename srcT>
destT & absolute_cast(srcT &v)
{
  return reinterpret_cast<destT&>(v);
}

template <typename destT, typename srcT>
const destT & absolute_cast(const srcT &v)
{
  return reinterpret_cast<const destT&>(v);
}

SPPHONEID* pphoneId = dsPhoneId;

SPPHONEID* pphoneId = absolute_cast<SPPHONEID*>(dsPhoneId);

pphoneId += wcslen(pphoneId) + 1;

pphoneId += wcslen(absolute_cast<wchar_t *>(pphoneId) ) + 1;

PVOID __stdcall __AllocStdCallThunk(VOID);
VOID  __stdcall __FreeStdCallThunk(PVOID);

#define AllocStdCallThunk() __AllocStdCallThunk()
#define FreeStdCallThunk(p) __FreeStdCallThunk(p)

#pragma comment(lib, "atlthunk.lib")

#define AllocStdCallThunk() HeapAlloc(GetProcessHeap(), 0, sizeof(_stdcallthunk))
#define FreeStdCallThunk(p) HeapFree(GetProcessHeap(), 0, p)