Retroceder 10 minutos atrás
:earlier 10m

Avançar 30 segundos
:later 30s

Imagem histórica não recuperada

(clique para ampliar)

Vamos as regras:

1. Linkar a pessoa que te indicou.
2. Escrever as regras do meme em seu blog.
3. Contar 6 coisas aleatórias sobre você.
4. Indique mais 6 pessoas e coloque os links no final do post.
5. Deixe a pessoa saber que você o indicou, deixando um comentário para ela.
6. Deixe os indicados saberem quando você publicar seu post.

Minhas coisas aleatórias

1. Tenho vontade de ter uma bateria, embora não tenho vontade de participar de uma banda, só por tocar mesmo.
2. Musica, minha segunda paixão, ouço de tudo de blues a metal, é mais fácil me ver sem calças do que sem fones.
3. Cerveja, adoro (já outras bebidas como destilados não gosto, nem mesmo vinho).
4. Gosto muito de ler e estudar e não só assuntos como programação, eletrônica, mais também sobre religiões (embora seja agnóstico), e apesar disso nunca fui bom aluno na escola, na verdade sempre estive entre os piores alunos, e me considero um autodidata nato.
5. Pessoas diferentes tem idéias diferentes ao meu respeito totalmente opostas, alguns me acham idiota e brincalhão e outros serio e inteligente, não por ter varias personalidades e sim porque sempre tento conhecer as pessoas antes de dizer algo.
6. Estudar Latex, Vim e Expressões regulares são meus hobbies

Convido Amanda, Diego, Bruno Croci os outros que eu não indiquei é porque já foram indicados.

Mais informções:

• http://www.qtsoftware.com/about/news/lgpl-license-option-added-to-qt
• http://labs.trolltech.com/blogs/2009/01/14/nokia-to-license-qt-under-lgpl/
• http://www.qtsoftware.com/about/licensing/frequently-asked-questions

Para quem não conhece a LGPL, ela permite ao programador linkar bibliotecas dinamicamente (DLL) sem exigir que o código fonte seja distribuido junto ao binario, tornando possivel usa-la em projetos comercias e não opensource, que ao contrario da GPL mesmo usando linkagem dinamica viola os termos da licença se nao distribuido os fontes.

A boa noticia é que aprendi muitas coisas novas (sem maldade xD) como as bibliotecas Qt, phonon, Webkit, e aprendi mais sobre as que eu já sabia (boost e stl), expressões regulares e até uma linguagem nova chamada Ruby

Eu sempre achei a idea de usar combobox, checkbox, etc como filtro uma idea complicada, ter que ficar marcando e depois clicar em filtrar, entao pensei em algo assim, basta voce digitar qualquer atributo do material que já vinha tudo que for relevante, por exemplo “AL TR”, já retorna todos os alumunios que são trifilados. No video da para se ter uma idea do que eu escrevi (claro que não é nenhum google, é bem simples)

E aqui o codigo responsável pela busca

18
19
20
21
22
23
24
25
26
27
28
29

void ItemView::filterChanged(const QString& text)
{
	QString filter, query;
	QStringList list = text.split(" ", QString::SkipEmptyParts);
 
	for (int i = 0; i < list.size(); ++i) {
		filter.append(QString(" %1 nome ILIKE '\%%2\%'").arg(
			list.size() > 1 && i != 0 ? " AND " : " ").arg(list.at(i)));
	}
 
	model->setFilter(filter);
}

Onde model é um ponteiro do tipo QSqlTableModel, e o metodo setFilter nada mais é do que a inserção da clausa WHERE

Se voce quer aprender mais como a Qt implementa o padrão de projeto Model-View-Controller leia aqui

É isso ae, espero que gostem, qualquer duvida, critica e/ou sujestões já sabem

Accumulators Um framework de calculo incremental

Asio agora com suporte portas serial, raw sockets (fazia falta mesmo), ICMP (mais conhecido como ping) entre outras ‘coisitas’.

PtrContainer Chega de ficar declarando vector de shared_ptr, alem […]

Em programação não existe plágio, na verdade tudo é refactory em código fonte alheio

E para quem usa o VIM, O vimpress esse plugin (do vim, e não do wordpress) permite postar e editar posts pelo editor sem ter que sair do conforto do vim.

[Via youtube]

history|awk '{print $2}'|awk 'BEGIN {FS="|"} {print $1}'|sort|uniq -c|sort -rn|head -10

Resultado

1. ls
2. cd
3. vim
4. g++
5. mplayer
6. startx
7. lynx
8. ps
9. mc
10. tar

Fica registrado meu “intimado” a todos que lêem me blog, postarem os 10 ultimo mais usados comando do linux (ou qualquer outro *nix)

Imagem histórica não recuperada

O instalador pode ser baixado aqui, mais informações em http://www.boost-consulting.com/products/free

task.hpp

#ifndef _task_hpp
#define _task_hpp

#include <ctime>
#include <boost /function.hpp>
#include </boost><boost /bind.hpp>

class task
{
	public:
		explicit task(const boost::function<void ()>& callback)
		: _call_back(callback)
		, _call_count(0)
		, _total_time_used(0)
		{
		}

		virtual ~task() { }

		virtual void before_task() { }

		void do_task()
		{
			before_task();
			_call_back();
			after_task();
		}

		virtual void after_task() { }

		void set_callback(const boost::function</void><void ()>& callback)
		{
			_call_back = callback;
		}

		const boost::function</void><void ()>& get_callback() const
		{
			return _call_back;
		}

		bool is_valid() const
		{
			return true;
		}

	private:
		boost::function</void><void ()> _call_back;
		std::size_t _call_count;
		std::clock_t _total_time_used;
};

#endif

schedule.hpp

#ifndef _schedule_hpp
#define _schedule_hpp

#include <algorithm>
#include <deque>
#include <boost /pool/pool_alloc.hpp>
#include </boost><boost /shared_ptr.hpp>
#include </boost><boost /noncopyable.hpp>
#include </boost><boost /thread/thread.hpp>
#include </boost><boost /thread/xtime.hpp>
#include </boost><boost /thread/mutex.hpp>

#include "task.hpp"

using std::for_each;
using std::deque;
using boost::shared_ptr;

class task;
typedef shared_ptr<task> task_ptr;
typedef deque<task_ptr , boost::pool_allocator<task_ptr> > deque_task;

class schedule : public boost::noncopyable
{
	public:
		schedule() : job(boost::bind(&schedule::thread_dispatcher, this))
		{
			_thread_sleep.sec = 10;

			try
			{
				job.join();
			}

			catch (boost::thread_interrupted&) { /* don't care... */ }
		}

		virtual ~schedule() { }

		void add_task(const shared_ptr<task>& _task)
		{
			boost::mutex::scoped_lock lock(monitor);

			deque_task::const_iterator it = std::find(_task_pool.begin(),
					_task_pool.end(), _task);

			if (it == _task_pool.end())
			{
				_task_pool.push_back(_task);
			}

			else {
				// duplicate item
			}
		}

		void remove_task(const shared_ptr</task><task>& _task)
		{
			boost::mutex::scoped_lock lock(monitor);

			deque_task::iterator it = std::find(_task_pool.begin(),
					_task_pool.end(), _task);

			if (it != _task_pool.end())
			{
				_task_pool.erase(it);
			}

			else {
				// does't exist
			}
		}

	protected:
		void thread_dispatcher()
		{
			for (;;)
			{
				for_each(_task_pool.begin(), _task_pool.end(),
					boost::mem_fn(&task::do_task));

				boost::thread::sleep(_thread_sleep);
			}
		}

	private:
		deque_task _task_pool;
		boost::thread job;
		boost::mutex monitor;
		boost::xtime _thread_sleep;
};

#endif

Unidade para testes, main.cpp

#include <iostream>
#include <boost /scoped_ptr.hpp>
#include </boost><boost /bind.hpp>

#include "schedule.hpp"

void f1()
{
	std::cout < < "f1()" << std::endl;
}

void f2()
{
	std::cout << "f2()" << std::endl;
}

int main()
{
	boost::scoped_ptr<schedule> _schedule(new schedule());

	shared_ptr<task> _task1 (new task(f1));
	shared_ptr</task><task> _task2 (new task(f2));

	_schedule->add_task(_task1);
	_schedule->add_task(_task1); // repetido, nao insere...
	_schedule->add_task(_task2);

	_schedule->start();

	return 0;
}

Agradecimentos

• Daniel pela sugestão de usar fila e apenas uma thread ao invés de uma para cada tarefa e assim evitando busy-waiting
• Alex pelos testes de compatibilidade com mingw e msvc (vide mem_fun e shared_ptr)

schedule.zip (arquivo não recuperado)

Os elementos

typedef shared_ptr<task> task_ptr;
typedef deque<task_ptr , pool_allocator<task_ptr> > deque_task_ptr;

Agora a combinação explosiva

for_each(_task_pool.begin(), _task_pool.end(),
       std::mem_fun(&task::do_task));

O problema está em usar std::mem_fun, ela não suporta chamar métodos de uma classe que estão em um shared_ptr, eu poderia ter usado bind, mais preferi manter o código, como a boost tem sua própria implementação de mem_fn ficando assim:

for_each(_task_pool.begin(), _task_pool.end(),
       boost::mem_fn(&task::do_task));

Resolvido, obrigado Alex por reportar o problema.

Imagem histórica não recuperada

IDE: Codeblocks, Visual Studio 2008 e wxFormBuilder (valeu a indicação n2liquid)
Jogos: Diablo II, Starcraft, Turok 2
Outros softwares: Winamp, Kaspersky, Opera, Media Player Classic, DVD Shrink, Nero.
Tem alguns eBooks no canto superior, e no superior esquerdo alguns projetos.
Tema usado é o Zune, e minha taskbar eu sempre uso com o tamanho dobrado (talvez seja um abito vindo do KDE), Ah é.. e como muita gente limpou o desktop para a “visita”, eu tambem dei uma enxugada no meu xD

A imagem está em baixa resolução porque meu monitor parou de funcionar e estou só com um reserva :(

Edit Visual Studio com tema modificado
Imagem histórica não recuperada

Imagem histórica não recuperada   Imagem histórica não recuperada

Os pontos azuis são os clicks, quanto mais avermelhado mais clicks em um determinado ponto

Motivação
Quando estava escrevendo a wintermoon estudei varias engines dentre elas a Ogre e a Irrlicht cada uma possui seu próprio sistema de arquivo virtual como descrito acima. mais porque a PhysicsFS? bom além de ser considerada muito segura e portável, ela tem um wrapper para a estrutura SDL_RWops o que facilita muito para projetos usando a biblioteca SDL. Outro ponto forte é a segurança, sua aplicação apenas poderá acessar os diretórios que você escolher, ideal para projetos baseados em scripts.

Recursos
Formatos suportados

• grp - groupfiles ou seja vários arquivos em um só sem compressão
• hog - maiores informações em href=”http://www.descent2.com/ddn/specs/hog
• lzma - formato popular usado pelo 7z
• mvl - Descent II Movielib, mais informações em http://www.descent2.com/ddn/specs/mvl/
• qpak - formato de arquivo usado no Quake 1, Quake 2 e Quake 3
• wad - usado na engine do DOOM
• zip - formato popular e muito usado

Extras

• selfextract - suporta autoextração do executável
• ignorecase - torna não case-sensitive (não diferencia maiúsculo de minusculo)
• wildcard - mascara ex. arquivo.*, *.zip, arqui??.*, *.zi?
• physfsrwops - abstração da estrutura SDL_RWops (é o que vamos usar, será mais explicado adiante)
• physfshttpd - Possibilita enviar ou receber arquivos via http

Alem de varias outras coisas, como bind para ruby e .net.

Velocidade
Como sabemos o acesso ao disco rígido é muito lento, usando um sistema de arquivos virtuais, reduzimos o acesso ao disco conseguindo um ganho de velocidade no carregamento.

Compilando
Se você usa algum Unix* (*BSD, GNU/Linux, etc) execute os comandos a seguir em algum terminal

cmake . && make && make install

No windows, baixe o cmake ou criar seu próprio projeto na sua IDE preferida.
Como o Skhaz é um bom menino ele já criou um projeto para o CodeBlocks/mingw32 bem limpo suportando apenas os formatos grp, lzma e zip, se alguem precisar de algum outro formato e não souber adicionar, mande me um email. Não foi adicionado nenhum arquivo da pasta extra, para manter compatibilidade (tive dificuldades em compilar a wintermoon em outras plataformas além do codeblocks/mingw32) caso você queira alguma facilidade da pasta extra, adicione o arquivo ao seu projeto, como explicado adiante.

SDL e PhysicsFS
A SDL é muito robusta e flexível, possibilitando “sobre escrever” as chamadas de open, read, write e close da estrutura SDL_RWops.

No diretório extras você encontra physfsrwops.c e physfsrwops.h, adicione eles ao seu projeto.

Abaixo segue um exemplo de como usar a physfs, antes de mais nada é preciso inicializar a physfs assim como a SDL

int main(int argc, char** argv)
{
  if (PHYSFS_init(argv[0]) == 0)
  {
    fprintf(stderr, "%s\n", PHYSFS_getLastError());
    exit(-1);
  }

  // ...

PHYSFS_init recebe um único parâmetro, em algumas plataformas pode ser NULL, mais por questões de portabilidade aconselho sempre usa-lo.

e também é necessário desnicializar

PHYSFS_deinit();

Adicionando alguns diretórios e arquivos

// adiciona o diretório media para a "pesquisa"
PHYSFS_addToSearchPath("media/", true);

// adiciona o arquivo jogador.zip
PHYSFS_addToSearchPath("jogador.zip", true);

// PHYSFSRWOPS_openRead se encontra no arquivo physfsrwops.c
// basicamente ela retorna uma estrutura SDL_RWops
// jogador_1.png esta dentro de jogador.zip
SDL_RWops* rwops = PHYSFSRWOPS_openRead("jogador1.png");

// O segundo parâmetro diz a IMG_Load_RW que
// libere o recurso após carrega-lo
SDL_Surface* surface = IMG_Load_RW(rwops, 1);

// Pronto já temos nossa imagem carregada.

Listando os arquivos

char **rc = PHYSFS_enumerateFiles("/");
char **i;

for (i = rc; *i != NULL; i++)
     printf("%s\n", *i);

PHYSFS_freeList(rc);

Onde
Voce pode baixar o source e compilar manualmente, para quem usa algum Unix Like, rode o comando cmake . && make && make install

• Site oficial da PhysicsFS (http://icculus.org/physfs/)
• 7zip (http://www.7-zip.org/)
• PhysicsFS já com projeto, fontes e compilada (arquivo não recuperado)
• Exemplo completo (arquivo não recuperado)

Dica
PhysicsFS com mensagens em Português do Brasil: Adicione essa macro PHYSFS_LANG_PORTUGUESE_BR” sem aspas, ou então altere-a no arquivo physfs_internal.h na linha 78

Referencias
ParaGUI (http://www.paragui.org/)
Irrlicht (http://irrlicht.sourceforge.net/)
Ogre (http://www.ogre3d.org/)

Não deixem de comentar, criticas, sugestões e elogios são muito bem vindos.

Simples e resumido, apesar de ser bem estranho você pode tratar exceções na inicialização dos atributos das classes usando try como você já esta acostumado.
Exemplo retirado do livro More Exceptional C++

class C : public A
{
    public:
        C() try : A ()
        {
        }
        catch( ... )
        {
        }
};

Referencias
More Exceptional C++
Try-catch flutuante - Caloni

Temos a seguinte interface de exemplo, Entity (pure abstract)

class Entity
{
  public:
    virtual void logic() = 0;
    virtual void draw() const = 0;
};

Note que classes como a acima são muito comuns em vários projetos

Agora a classe Player que implementa Entity

class Player : public Entity
{
  public:
    void logic()
    {
    }

    void draw() const
    {
       mDrawCount++;

      // Erro! pois é um método const
    }

  private:
     std::size_t mDrawCount;
};

Mais skhaz porque não controlar isso no método logic que não é const? eu tenho bons motivos para isso, um deles é se você implementar um sistema de ticks como descrito no artigo Controle de velocidade de jogo com ticks onde quase sempre o método draw não será chamado no mesmo ciclo que logic.

ponteiro e const_cast os “vilões”
Com o uso do cast const_cast podemos burlar o atributo declarado como mutable (assim como para const e volatile) para não constantes.

void Player::draw() const
{
  const_cast<player *>(this)->mDrawCount++;

  // work fine =D
}

Referencia http://msdn2.microsoft.com/en-us/library/bz6at95h.aspx
Um artigo recomendado pelo nosso amigo danielf sobre mutable http://www.highprogrammer.com/alan/rants/mutable.html

[Via Cyanide & Happiness]

Esse ai sou eu, o alex fugindo da foto para o meio da neblina :D

O Arret 0.0.1a escrito totalmente em C++ usando Irrlicht para o cliente e o sistema de colisão foi implementado no servidor usando a biblioteca fisica Newton e partes da ONE, o projeto não é novo, tem uns 3 anos, já foi até 2D usando SDL, mais informações em http://projetoarret.com.br/.

Apesar de eu não fazer parte da equipe (não por nenhum tipo de desavença, mais sim porque prefiro usar Ogre), sempre torci e ajudei o projeto, estamos esperando novas atualizações :D

Recentemente formatei o pc e fui baixar o codeblocks no site e tive a surpresa de encontrar a nova versao 8.02 disponivel, baixei ela e fui procurar os pacotes da nightly build mais nao encontrei… ao iniciar a instalação já notei uma quantidade generosa de novos plugins :)

Destaques

• Instalador

Nenhuma mudança significativa além de uma splashscreeen, e uma melhor organização dos diretorios



• Autoversioning

Bom esse foi o recurso que estava procurando à muito tempo, qual a função dele? bom… ele cria um arquivo .h que contem informações do SVN, como versão, assim você pode criar uma tela “Sobre” igual a do CodeBlocks mostrando a versão do SVN



• Changelog

Esse foi outro recurso que gostei muito



• ThreadSearch

É um sistema de busca muito eficiente, Não tem nada haver com programação paralela :P

Mais informações em http://www.codeblocks.org/

template <class T>
class Deleter
{
public:
void operator()(T* ptr)
{
if (ptr != NULL) {
delete ptr;
ptr = NULL;
}
}
};

Eu achava perfeito, e ainda podia usar nos for_each da vida, porém ainda era POG…

Uma noite, bebendo e ouvindo musica (metal!), lembrei das magicas que std::mem_fun podia fazer, e resolvi implementa-la, a cobaia foi a classe InputManager da Wintermoon, usando o método teardown de Mouse e Keyboard como Deleter

InputManager::Init()
{
// ...
mKeyboard = boost::shared_ptr<keyboard> (new Keyboard,
std::mem_fun(&amp;Keyboard::teardown));

mMouse = boost::shared_ptr<mouse> (new Mouse,
std::mem_fun(&amp;Mouse::teardown));
}

InputManager::Shut()
{
// reset é um membro de shared_ptr, responsavel
// por liberar a memoria do ponteiro
mKeyboard.reset();
mMouse.reset();
}

// class Mouse

void Mouse::teardown()
{
// clean up data...
}

// class Keyboard

void Keyboard::teardown()
{
// clean up data...
}

E não é que funcionou, o código ficou muito mais claro, mais ainda não acabou, ainda não crie a classe Singleton dos meus sonhos, usando shared_ptr, volatile, template, NonCopyable, mais estou no caminho…

Visual Studio 2005 Pro Code::Blocks

Imagem histórica não recuperada Imagem histórica não recuperada

Para upar suas fotos use o ImageShack ou qualquer outro serviço de hospedagem.

Baseado no artigo de Plinio Torres - Qual é a cara da sua área de trabalho?

É um projeto de minha autoria e de DarkSasori, a idea é criar uma engine para redes (similar a RakNet), Escrita em C++, usando boost.

O que já temos:

• DNS com cache
• IPAdrress
• SocketLayer (Interface)
• TCP::Socket (Implementação de SocketLayer)
• UDP::Socket (Implementação de SocketLayer)
• ServerInterface
• ClientInterface
• PeerInterface
• Thread
• ThreadGroup
• ThreadJob
• Mutex
• ScopedMutex
• NetworkInitializer
• Documentação (Doxygen)

Características:

• Cache de DNS
• Suporte a plugins (.dll ou .so), como Voice, Updater, etc

Principais plataformas alvo:

• Windows
• Linux
• MacOS
• BSD

Claro, qualquer outra plataforma que possuir sockets e threads, haverá um port da ONE!

Metas:

• Sistema de plugins usando DLL (50% feito)
• Plugin Voice, similar ao RakVoice, usando a biblioteca speex
• Compactação usando zlib, bzip2 e lzma
• Criptografia (OpenSSL ?)
• Suporte ao IPv6 (20%)

Quem já usa?

• Projeto Arret (apenas algums modulos)

Licença: LGPL 3

PS. Eu ainda não disponibilizei o download nem o SVN do projeto, pois ainda não está preparado ainda.

Referencia Classe std::string STL provoca falhas e uma corrupção da memória em computadores com múltiplos processadores

namespace Engine
{
  namespace Video
  {
     namespace Gui
     {
         class Window
         {
             public:
               virtual ~Window() { }
         };
     }
  }
}

Você tambem poderia escrever dessa forma

using namespace Engine;
using namespace Video;
using namespace Gui;

shared_ptr<window> window(new Window);

ou então

using Engine::Video::Gui::Window;

shared_ptr</window><window> window(new Window);

Nesse exemplo usamos muitos namespaces, é raro encontrar casos como esse, apenas encontrei na engine Irrlicht (até 3 sub namespaces) e na boost (até 5 sub namespaces), o interessante é criar um aliases para o namespace da seguinte forma

// evg é um aliases para Engine::Video::Gui
namespace evg = Engine::Video::Gui;

shared_ptr<evg ::Window> window(new evg::Window);

namespace “escopado”

{
  // EVG é um aliases para Engine::Video::Gui
  namespace EVG = Engine::Video::Gui;
  shared_ptr</evg><evg ::Window> window(new EVG::Window);
}

{
  // Graphics é um aliases para Engine::Video
  namespace Graphics = Engine::Video;
  shared_ptr<graphics ::Gui::Window> window(new Graphics::Gui::Window);
}

{
  using namespace Engine;
  using namespace Video;
  using namespace Gui;

  shared_ptr</graphics><graphics ::Gui::Window> window(new graphics::Gui::Window);
}

Veja que cada namespace tem seu próprio escopo.

Como boa pratica de programação prefira declarar apenas as classes que for usar de um namespace, ao invés de declará-lo todo.

Prefira usar

using std::string;
using std::vector;
using std::map;

Ao invés de

using namespace std;

Ou melhor ainda, se você tiver um projeto que use algum namespace, no seu header principal (global.h, internal.h), assim todos as classes declaradas podem ser usadas dentro do seu namespace, sem ter que ficar usando o using

namespace Wintermoon
{
  class Root;
  class Image;
  class ImageCache;
  class EventReceiver;
  class InputManager;
  ...

  using std::string;
  using std::vector;
  using std::map;
  using std::set;
  using std::multset;

  using std::for_each;
  using std::find;

  using boost::shared_ptr;
  using boost::scoped_ptr;
}

Imagem histórica não recuperada

Desejem-me sorte :)

#include <string>
#include "SDL.h"

using std::string;

class Image
{
   public:
      Image();
      virtual ~Image();

      void load(const string&amp; filename, bool transparent = true);

      operator SDL_Surface*() const
      {
         return m_pSurface;
      }

   private:
      SDL_Surface* m_pSurface;
};

Vamos à implementação

#include "Image.h"

Image::Image()
: m_pImage(NULL)
{
}

Image::~Image()
{
   if (m_pImage != NULL) {
      SDL_FreeSurface(m_pSurface);
   }
}

void Image::load(const string& filename, bool transparent)
{
   if ((m_pSurface = IMG_Load(filename.c_str())) == NULL)
   {
      throw Exception("%s", IMG_GetError());
   }

   bool hasAlpha = false;

   // Se a imagem tem 32 bits, provalvelmente
   // ela tem o canal alpha, caso contrario ela
   // não tem, e nem precissamos verificar.
   if (m_pSurface->format->BitsPerPixel == 32)
   {
      // Percorremos toda a superficie da imagem
      for (int i = 0; i < m_pSurface->w * m_pSurface->h; ++i)
      {
         Uint8 r, g, b, a;

         // Mapeamos o pixel e obtemos seus
         // respectivos valores em RGBA
         SDL_GetRGBA(((Uint32*) m_pSurface->pixels)[i],
                     m_pSurface->format, &amp;r, &amp;g, &amp;b, &amp;a);

         // Se o canal alpha for diferente de 255 (opaco)
         // então a imagem tem trasparencia
         // finalizamos o loop com o break.
         if (a != 255)
         {
            hasAlpha = true;
            break;
         }
      }
   }

   // Se a imagem tiver o canal de trasparencia
   // optimizamos ela da maneira correta.
   if (hasAlpha) {
      temp = SDL_DisplayFormatAlpha(m_pSurface);
   }

   // Caso contrario, optimizamos para uma
   // superficie sem alpha
   else {
      temp = SDL_DisplayFormat(m_pSurface);

      if (transparent)
      {
         SDL_SetColorKey(temp, (SDL_SRCCOLORKEY | SDL_RLEACCEL | SDL_HWACCEL),
             SDL_MapRGB(SDL_GetVideoSurface()->format,
             255, 0, 255));
      }
   }

   if (temp)
   {
      SDL_FreeSurface(m_pSurface);
      m_pSurface = temp;
   }
}

SDL_GetVideoSurface() Essa função retorna o ponteiro da superficie do video (a publica, e não a real), veja a documentação da SDL
para maiores informações

Veja também
Mais detalhes da estrutura interna da SDL_Surface em SDL_Surface - Introdução detalhada, de Diogo_RBG

class Image
{
public:
void Draw() const;

private:
std::size_t m_BlitErrorCount;
}

Vejamos esse exemplo do metodo Draw da classe Image
precisamos implementar um contador de erros do SDL_BlitSurface (sinceramente não vejo utilidade isso)

void Image::Draw() const
{
if (SDL_BlitSurface(mSurface, NULL, Screen, rect) < 0)
{
m_BlitErrorCount++;
// O compilador acusa erro na linha acima
// pois não podemos modificar qualquer
// atributo dentro desse método declarado como const
}
}

Como solucionar?

Adicione a palavra reservada mutable na declaração de m_BlitErrorCount, ficando assim:

class Image
{
public:
void Draw() const;

<strong> private:
mutable std::size_t m_BlitErrorCount;
}

Veja também

Um outro caso para o uso da mutable é na implementação do design Organizando a janela em classes, de nosso amigo Vinícius, onde temos à seguinte declaração do método draw

virtual void draw() const = 0;

Usando a palavra reservada mutable na declaração do atributo usado internamente em draw você “burla” o const

Agora seu código compila sem erros :)

Declaração da classe Timer

#include "SDL.h"

class Timer
{
public:
Timer();

explicit Timer(Uint32 interval);

virtual ~Timer();

// Adcionamos um timer
// interval O intervalo de tempo do timer
void addTimer(Uint32 interval);

// Remove o timer
void removeTimer();

// Seta um novo intervalo de tempo
void setInterval(Uint32 interval);

// Retorna o valor do intervalo do timer
Uint32 Timer::getInterval() const;

//
// Método puro abstrato chamado em todo
// intervalo definido pelo timer.
// Deve ser implementado na classe filha.
//
virtual void onTimer() = 0;

private:
// Usado internamente, o ponto de entrada do SDL_Timer
static Uint32 entryPoint(Uint32 interval, void* param);

Uint32 mInterval;
SDL_TimerID mTimerID;
};

Vamos à implementação

#include "Timer.h"

Timer::Timer()
: mInterval(0)
{
if (SDL_WasInit(SDL_INIT_TIMER) == 0)
{
SDL_InitSubSystem(SDL_INIT_TIMER);
}
}

Timer::Timer(Uint32 interval)
: mInterval(0)
{
if (SDL_WasInit(SDL_INIT_TIMER) == 0)
{
SDL_InitSubSystem(SDL_INIT_TIMER);
}

addTimer(interval);
}

Timer::~Timer()
{
SDL_RemoveTimer(mTimerID);
}

void Timer::addTimer(Uint32 interval)
{
mInterval = interval;
mTimerID = SDL_AddTimer(mInterval, entryPoint, this);
}

void Timer::removeTimer()
{
SDL_RemoveTimer(mTimerID);
}

void Timer::setInterval(Uint32 interval)
{
mInterval = interval;
}

Uint32 Timer::getInterval() const
{
return mInterval;
}

Uint32 Timer::entryPoint(Uint32 interval, void* param)
{
Timer* ptr = reinterpret_cast<timer *>(param);
ptr->onTimer();
return ptr->mInterval;
}

Exemplo de uso:

#include <iostream>
#include <boost /scoped_ptr.hpp>

#include "SDL.h"
#include "Timer.h"

using std::cout;
using std::endl;
using boost::scoped_ptr;

class Tick : public Timer
{
public:
Tick()
{
// Adicionamos um timer de 1 Segundo
addTimer(1000);
}

~Tick() { }

protected:

// onTImer método puro abstrato
// herdado de Timer, ele será chamado
// todo intervalo definido no timer
void onTimer()
{
cout < < "Tick::onTimer() chamado em " << SDL_GetTick() << endl;
}
};

int main()
{
// Criamos a classe Tick
// usamos aqui scoped_ptr para
// que o ponteiro seja deletado
// automaticamente ao sair do escopo
scoped_ptr<tick> tick(new Tick);

// Aguardamos uns 5 segundos
// enquanto isso o timer já esta rodando
// e imprimindo a saida no console ou no stdout.txt
SDL_Delay(5000);

// Agora vamos mudar o intervalo de tempo
// para meio segundo
tick->setInterval(500);

// Aguardamos mais ums 5 segundos
// O timer continua rodando, mais agora com o
// intervalo de meio segundo e não 1 segundo
SDL_Delay(5000);

// O resultado poderá ser visto no stdout.txt
// ou na saida do console

// Isso mantem o compilador feliz...
return 0;
}

Espero que tenha gostado, em breve eu posto as classes Thread, ThreadJob, ThreadGroup e Mutex baseadas nas Threads da SDL (até la vou ter aprendido mais sobre SDL semáforos), sintan-se à vontade de usá-las apenas mantenham os créditos ;D