int strlen(char *s)
{
    char *p = s;

    //
    // *++p primeiro incrementa, depois retorna valor
    //
    // Ele chega até o NULL, pois:
    //
    // Exemplo:
    // Assumir a string "Hello World", ela tem 11 caracteres + \0
    // +-------+----------+  +-------+----------+
    // | Letra | Endereço |  | Letra | Endereço |
    // +-------+----------+  +-------+----------+
    // |   H   |   28     |  |   W   |   2E     |
    // |   e   |   29     |  |   o   |   2F     |
    // |   l   |   2A     |  |   r   |   30     |
    // |   l   |   2B     |  |   l   |   31     |
    // |   o   |   2C     |  |   d   |   32     |
    // |       |   2D     |  |  \0   |   33     |
    // +-------+----------+  +-------+----------+
    //
    // Ao chegar em \0, o loop termina. Mas, p estará apontando
    // para o endereço 33, ou seja, \0.
    // No final, a diferença p-s fará 33 - 28 (início da string, para onde s aponta)
    // totalizando 11.
    //
    // Para verificar isso, como exemplo, usar 28+12 = 40.
    // Mas, entre de 28 até 40 são 13 números que existem, mesmo caso acima e por
    // isso que NULL não é contado, mesmo que p fique apontando para \0 no final.
    //
    while(*++p);

    return (int)(p-s);
}

Observação: Talvez nunca nem eu nem você tenhamos que nos preocupar com operações do gênero, de tão baixo nível, ainda mais que como eu mesmo disse, isso é uma função da biblioteca padrão (ou como no caso de C++ que abole as strings de C com a classe string). Mas, estudar nunca é demais, isso ajuda a clarear ainda mais sobre ponteiros.

Nesse artigo, vou cobrir a relação ponteiro vs. constantes:

1. Ponteiro:

   tipo *nome;

2. Ponteiro não constante para dados constantes:

   const tipo *nome;

3. Ponteiro constante para dados não constantes:

   tipo *const nome;

4. Ponteiro e dados constantes:

   const tipo *const nome;

A idéia é que se o operador * vem depois de const são assumidos os dados bases (assim, é um ponteiro para dados constantes). Se o operador vem antes de const, então é um ponteiro constante.

Isso pode ser facilmente identificado quando é feita uma leitura da direita para a esquerda:

// Leitura de declarações <-
int *x;             // x é um ponteiro para int
const int *y;       // y é um ponteiro não constante para um int constante
const int *const p; // p é um ponteiro constante para um int constante
int *const w;       // w é um ponteiro constante para um int não constante

Exemplo completo

    // +--------------------------------------------------------------------+
    // | Ponteiro não constante para dados não constantes                   |
    // +--------------------------------------------------------------------+
    char *p, a, b;

    p  = &a;  // Recebe endereço de a
    *p = 'A'; // Altera conteúdo de a
    p  = &b;  // Recebe endereço de b

    // +--------------------------------------------------------------------+
    // | Ponteiro não constante para dados constantes                       |
    // +--------------------------------------------------------------------+
    const int *p;
    int i = 25, z;

    // p aponta para i, o qual não pode ser alterado.
    p = &i;

    // Mas, p pode apontar para outra variável
    p = &z;
    // Esse comando gera falha, porque p vai tentar alterar
    // o conteúdo de z, mas não pode pois foi declarado para
    // apontar para dados constantes
    // *p = 35;

    // Comando válido, por não se referenciar ao ponteiro, e sim,
    // diretamente na variável
    i = 45;

    // +--------------------------------------------------------------------+
    // | Ponteiro constante para dados não constantes                       |
    // +--------------------------------------------------------------------+
    int i = 25, z;

    // Como é ponteiro constante, atribuição de endereço deve ser feito
    // na definição.
    int *const p = &i;

    // Comando inválido, não se pode alterar para onde p aponta
    // p = &i;

    // Comando válido, por se tratar de dados não constantes
    *p = 45;

    // +--------------------------------------------------------------------+
    // | Ponteiro constante para dados constantes                           |
    // +--------------------------------------------------------------------+
    int i = 25, z;

    // Como é ponteiro constante, atribuição de endereço deve ser feito
    // na definição.
    const int *const p = &i;

    // Comando inválido, não se pode alterar para onde p aponta
    // p = &i;

    // Comando inválido, por se tratar de dados constantes
    // *p = 45;

    // Comando válido, por não se referenciar ao ponteiro, e sim,
    // diretamente na variável
    i = 45;

Mapa mental

C - Ponteiros constantes e não constantes

]]> http://www.auriumsoft.com.br/programadorpratico/2010/05/c-ponteiros-constantes-e-nao-constantes/feed/ 0 http://www.auriumsoft.com.br/programadorpratico/2010/05/c-ponteiros-constantes-e-nao-constantes/ http://feedproxy.google.com/~r/ProgramadorPratico/~3/dy1M63cgT-s/ http://www.auriumsoft.com.br/programadorpratico/2010/04/desenvolvimento-de-jogos-para-iphone-passos-iniciais/#comments Sun, 25 Apr 2010 03:06:10 +0000 Alfred Reinold Baudisch http://www.auriumsoft.com.br/programadorpratico/?p=67 Reflexão pessoal

iPhone, a solução dos desenvolvedores de games?

Sempre tive um sonho em desenvolver jogos, tanto que comecei a programar porque eu queria criar jogos. Mas, uns acertos aqui, acertos ali, e sempre me deixei levar pelas oportunidades de desenvolvimento Web que surgiram, e desde então toda minha vida de programador foi voltada a Web. Porém, agora que decidi mudar os passos do que faço, é hora de voltar a percorrer o sonho inicial (e creio que o sonho de quase todo programador): programar jogos!

Ainda mais nos dias atuais, em que distribuir e desenvolver os jogos é algo relativamente fácil e barato comparado com as limitações do passado: as fabricantes de consoles apenas distribuíam os kits de desenvolvimento sob pesadíssimas taxas, licenças e restrições. Ou seja, você precisaria de alguns milhares de dólares antes mesmo de pensar em criar um jogo profissional. Hoje, temos o excepcional mercado Mobile, principalmente em termos de iPhone + App Store e Android e seu respectivo Market.

Não vou entrar em detalhes, mas escolhi o iPhone para que eu possa me aprofundar no desenvolvimento de jogos, além de tentar finalmente desenvolver um jogo comercial, mesmo que eu sempre tenha o título de “indie”. A idéia é criar um aprofundamento nos principais conceitos, e assim, partir para algo viável. E ao criar algo bom, o preço que a Apple cobra é incrivelmente baixo, e terei um mercado com milhões de consumidores sedentos por novidades a alguns cliques (só não podendo esquecer das pesadas políticas de aprovação de aplicações na AppStore).

Por onde começar?

Após, mais uma vez, usar exaustivamente o Oráculo, achei vários tutoriais, comunidades e bibliotecas. Resolvi começar por uma série de tutoriais sobre desenvolvimento de jogos no iCodeBlog. Mas, já de imediato (o que era de se esperar), o tutorial mostra código em Objective C.

Eu, que apenas recentemente comprei um Mac, nunca toquei em Objective C, muito menos no XCode. Então é hora de aprender Objective C.

Como já estudei C e C++, posso partir direto para o Objective C, mas deixarei registrado aqui o passo a passo para quem está começando do zero, incluindo em termos de linguagem de programação.

Tutoriais Iniciais

1. Introdução à C, de modo claro e rápido: http://cocoadevcentral.com/articles/000081.php
2. Arrays e memória em C: http://theocacao.com/document.page/231
3. Ponteiros e memória dinâmica em C: http://theocacao.com/document.page/234
4. Tutorial de Objective C: http://cocoadevcentral.com/d/learn_objectivec/ Creio que esse tutorial seja o mais rápido e conciso.
5. Outro tutorial rápido de Objective C: http://mobileappmastery.com/objective-c-tutorial/
6. E o tutorial definitivo e completo, oficial da Apple: http://bit.ly/aKn7xC

Os 5 primeiros levam no máximo 1 hora para serem lidos, se você “pegar no tranco”. Já o da Apple pode tomar um tempo.

Isso é o suficiente para começar, estou “preso” no tutorial da Apple. Assim que terminar, continuo com os próximos passos (que nem eu ainda sei quais são!)

Referências:

• Créditos da Imagem

• OR: a expressão será verdadeira se qualquer um dos operandos forem verdadeiros, e falsa caso os dois operandos sejam falsos.
• AND: a expressão será verdadeira se e somente se os dois operandos forem verdadeiros, caso contrário será falsa.

Com a leitura do Ruby by Matz entendi o porquê de tal lógica (o livro explica em detalhes toda a teoria). Vamos assumir as seguintes expressões:

a || b                 # "a or b"
a && b                 # "a and b"

• OR: Se a for verdadeiro, a expressão imediatamente retorna a e ignora o b. Se a for falsa, retorna b.
• AND: Se a for verdadeiro, a expressão imediatamente retorna b e ignora a. Se a for falsa, a expressão imediatamente retorna a e ignora b.

Exemplos

O seguinte código explora todas as possíveis opções seguindo a teoria.

# OR
a = true
b = true

# Se a for verdadeiro, a expressão imediatamente retorna a e ignora o b.
a || b         # => a, true

# Se a for falsa, retorna b.
a = false
a || b         # => b, true

# Se a for falsa, retorna b, que também possui um resultado falso.
b = false
a || b         # => b, false

# AND
a = true
b = true

# Se a for verdadeiro, a expressão imediatamente retorna b e ignora a.
a && b         # => b, true

# Se a for verdadeiro, a expressão imediatamente retorna b (que possui um resultado falso) e ignora a.
a = true
b = false
a && b         # => b, false

# Se a for falsa, a expressão imediatamente retorna a e ignora b.
a = false
b = true
a && b         # => a, false

# Se a for falsa, a expressão imediatamente retorna a e ignora b.
a = false
b = false
a && b         # => a, false

Mapa mental

Clique para ampliar

Espero que também tenha lhe sido claro.

Funcionamento de uma expressão flip-flop

Vamos a um exemplo:

(1..10).each {|x| print x if x==3..x==5 }

Aqui, a flip-flop consiste nas duas condições (x==3 e x==5) ligadas pelo operador .. na condicional if no final.

A expressão é false até que a expressão da esquerda se torne true, então a expressão dá um “flip” e mantém o estado true. Ela se mantém true (e retorna sempre true) até que a expressão da direita se torne true, assim a expressão dá um “flop” para um estado false até que a esquerda se torne true novamente e sucessivamente.

Com isso em mente, o exemplo acima imprime: 345

Uma flip-flop pode ser escrito tanto com .. quanto com ...: quando uma flip-flop .. torna-se true, ele retorna true e também testa logo em seguida a expressão da direita para ver se deve mudar o estado para false. Já uma flip-flop ... espera pela próxima iteração antes de testar a expressão da direita.
Exemplo:

# Imprime "3". Flip e flop de volta quando x==3
(1..10).each {|x| print x if x==3..x>=3 }
# Imprime "34". Flip quando x == 3 e flop quando x==4
(1..10).each {|x| print x if x==3...x>=3 } # Imprime "34"

Mapa mental

Clique para ampliar

Exemplo prático

O próprio Matz desencoraja o uso de flip-flops (Matz, p. 110), porém podem ser úteis em alguns casos de leitura de arquivos e sources, como o exemplo a seguir (fonte):

code = <<-CODE
  /**
   * Some comments
   * longer comments here that we can parse.
   *
   * Wahoo
   */
   function subroutine() {

   }

   /* some more comments */

   /**
    * Another comment.
    */
    function something() {

    }
CODE

comments = code.collect { |line| line if (line =~ /^[\s]*\/\*/)..(line =~ /^[\s]*\*\//) }.join
puts comments

# Retorna
  /**
   * Some comments
   * longer comments here that we can parse.
   *
   * Wahoo
   */

   /* some more comments */

   /**
    * Another comment.
    */

Referências

• MATSUMOTO, Yukihiro; FLANAGAM, David. The Ruby Programming Language. 1st ed., p. 109-111, 2008.
• Ruby Flip Flop or Range Operators
• http://stackoverflow.com/questions/1111286/when-would-a-ruby-flip-flop-be-useful

Para mim, o caminho de aprendizado de uma linguagem de programação envolve a leitura de um ou mais livros chaves, acompanhamento constante de fóruns, além do estudo dos sources de projetos open source.

Os livros

• The Ruby Programming Language (versão em português), de autoria do criador da Ruby, conhecido como Matz, assim chamarei esse livro de “Ruby by Matz“. No momento da escrita desse artigo, estou na página 130~ e posso dizer que o livro é bem conciso e vai direto ao ponto. Não fica criando histórias ao redor do código. É código atrás de código, com todo o detalhamento necessário, além de comparações de diferenças Ruby 1.8 x 1.9. Enfim, um livro em que você não perde tempo e espero em breve criar uma resenha completa. Só um detalhe: por ele ir “direto ao ponto”, este é um livro avançado, para quem já é programador e está querendo partir para Ruby.
• 
  Programming Ruby 1.9, o tradicional “pickaxe”. O livro é um tijolo. Li os 3 primeiros capítulos, e comparando com o Ruby by Matz, é um livro com bem mais exemplos e linguagem mais direta e “light”. Recomendado para quem nunca programou e também para quem já tem experiência em qualquer outra linguagem. O bom dele também é toda a referência da linguagem nos capítulos finais (incluindo um capítulo sobre escrever extensões C para manipular dados de Ruby).
• 
  Agile Web Development with Rails, terceira edição, do criador da Ruby on Rails. O livro obviamente é uma das principais referências. Ê uma pena que não esperei um pouco mais, pois está saindo a versão 4 para Rails 3.

Gastei R$ 240,00 pelos livros mais o frete expresso, comprando-os pela Amazon. Custou barato. Por quê? Só o frete saiu por R$ 102,00, logo o preço dos livros (R$ 138,00 por 3 livros!) foi irrisório comparado com os preços dos livros no mercado nacional (entre R$ 60 a 120 um livro de programação). Um investimento que valeu a pena!

Mas, cansei. PHP tornou-se cansativo e enjoativo, não sei dizer exatamente por quê. Talvez porque se popularizou demais, e não existe um padrão de qualidade e eu gosto de fazer sempre o melhor. Qualquer servicinho feito “meia boca” já é abraçado e aceito. Claro que se eu executar sempre algo bom, o resultado vem logo em seguida, independente se outros o fazem de qualquer jeito.

Só que a dita “gigantesca comunidade PHP” se tornou relaxada, no sentido de estar suja. E consequentemente, o PHP é algo relaxado e bagunçado. Decidi então que era hora de mudar.

Some ao fato que muitas vezes precisei desenvolver aplicativos, e não somente web, web e web. PHP-GTK? Sem comentários!

Que caminho escolher?

Entre as opções, fiquei vagando entre Python e Django ou Ruby e Ruby on Rails. Tanto Python quanto Ruby são eficazes e poderosas em termos de software. Django e Rails são monstros para a Web. Agora, bastava chegar a aquela que mais me agradaria no todo, seja em linguagem, comunidade, funcionalidades, ou pelo menos, “amor a primeira vista”.

Pesquisei, pesquisei e pesquisei no oráculo, até me sentir confortável e decidido com a dupla Ruby e Ruby on Rails:

• Tanto a comunidade de Ruby, mas principalmente a de Rails é extremamente caprichosa e padronizada. Até mesmo os sites/aplicações feitos em Rails ou sites relacionados (empresas que usam Rails, etc) são caprichados em todos os detalhes. É até “gostoso” de acompanhá-los, aquela sensação de que você está num hotel 5 estrelas, bem servido.
• Ruby é, como o próprio nome sugere, uma jóia. Amei a complexidade e ao mesmo tempo extrema simplicidade da linguagem, unida a beleza de programar:

['toast', 'cheese', 'wine'].each { |food| print food.capitalize }

Python também é excepcional e acho que um dia talvez estude-a para me divertir com programação de pequenos jogos, mas simplesmente me apaixonei por Ruby e por Rails.

Caminho do aprendizado

Já estou estudando Ruby, e possuo alguns livros e outros acompanhamentos, mas isso é assunto para o próximo artigo.