diff options
Diffstat (limited to 'pt-br/c-pt.html.markdown')
| -rw-r--r-- | pt-br/c-pt.html.markdown | 649 |
1 files changed, 649 insertions, 0 deletions
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown new file mode 100644 index 00000000..451df4f3 --- /dev/null +++ b/pt-br/c-pt.html.markdown @@ -0,0 +1,649 @@ +--- +language: c +filename: learnc.c +contributors: + - ["Adam Bard", "http://adambard.com/"] + - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] +translators: + - ["João Farias", "https://github.com/JoaoGFarias"] +lang: pt-br +filename: c-pt.el +--- + +Ah, C. Ainda é **a** linguagem de computação de alta performance. + +C é a liguangem de mais baixo nível que a maioria dos programadores +irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique +antento que este manual de gerenciamento de memória e C vai levanter-te +tão longe quanto você precisa. + +```c +// Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99 + +/* +Comentários de multiplas linhas se parecem com este. +Funcionam no C89 também. +*/ + +// Constantes: #define <palavra-chave> +#definie DAY_IN_YEAR 365 + +//enumarações também são modos de definir constantes. +enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB}; +// SEG recebe 2 automaticamente, TER recebe 3, etc. + +// Cabeçalhos são inclusos com #include +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +// (Nomes dos arquivos entre <colchetes> são cabeçalhos para bibliotecas padrão de C.) +// Para cabeçalhos próprios, use aspas ao invés de colchetes: +#include "minha_biblioteca.h" + +// Declare assinaturas das funções no início do arquivo .h ou no topo +// do seu arquivo .c. +void funcao_1(char c); +int funcao_2(void); + +// Deve-se declarar um 'protótipo de função' antes do main() quando as ocorrências +// dessas funções estão após sua função main() +int soma_dois_ints(int x1, int x2); // protótipo de função + +// O ponto de entrada do teu programa é uma função +// chamada main, com tipo de retorno inteiro +int main() { + // Usa-se printf para escrever na tela, + // para "saída formatada" + // %d é um inteiro, \n é uma nova linha + printf("%d\n", 0); // => Imprime 0 + // Todos as declarações devem acabar com + // ponto e vírgula + + /////////////////////////////////////// + // Tipos + /////////////////////////////////////// + + // ints normalmente tem 4 bytes + int x_int = 0; + + // shorts normalmente tem 2 bytes + short x_short = 0; + + // chars sempre tem um byte + char x_char = 0; + char y_char = 'y'; // Literais de caracter são cercados por ' + + // longs tem entre 4 e 8 bytes; longs long tem garantia + // de ter pelo menos 64 bits + long x_long = 0; + long long x_long_long = 0; + + // floats são normalmente números de ponto flutuante + // com 32 bits + float x_float = 0.0; + + // doubles são normalmente números de ponto flutuante + // com 64 bits + double x_double = 0.0; + + // Tipos inteiros podem ser sem sinal. + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // caracteres dentro de aspas simples são inteiros + // no conjunto de caracteres da máquina. + '0' // => 48 na tabela ASCII. + 'A' // => 65 na tabela ASCII. + + // sizeof(T) devolve o tamanho de uma variável do tipo T em bytes + // sizeof(obj) devolve o tamanho de uma expressão (variável, literal, etc.). + printf("%zu\n", sizeof(int)); // => 4 (na maioria das máquinas com palavras de 4 bytes) + + // Se o argumento do operador `sizeof` é uma expressão, então seus argumentos + // não são avaliados (exceto em VLAs (veja abaixo)). + // O valor devolve, neste caso, é uma constante de tempo de compilação. + int a = 1; + // size_t é um inteiro sem sinal com pelo menos 2 bytes que representa + // o tamanho de um objeto. + size_t size = sizeof(a++); // a++ não é avaliada. + printf("sizeof(a++) = %zu where a = %d\n", size, a); + // imprime "sizeof(a++) = 4 onde a = 1" (quando em uma arquitetura de 32 bits) + + // Arrays precisam ser inicializados com um tamanho concreto + char meu_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes + int meu_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes + // (assumindo palavras de 4 bytes) + + // Você pode inicializar um array com 0 desta forma: + char meu_array[20] = {0}; + + // Indexar um array é semelhante a outras linguages + // Melhor dizendo, outras linguagens são semelhantes a C + meu_array[0]; // => 0 + + // Array são mutáveis; são apenas memória! + meu_array[1] = 2; + printf("%d\n", meu_array[1]); // => 2 + + // No C99 (e como uma features opcional em C11), arrays de tamanho variável + // VLA (do inglês), podem ser declarados também. O tamanho destes arrays + // não precisam ser uma constante de tempo de compilação: + printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho + char buf[0x100]; + fgets(buf, sizeof buf, stdin); + + // strtoul transforma a string em um inteiro sem sinal + size_t size = strtoul(buf, NULL, 10); + int var_length_array[size]; // declara o VLA + printf("sizeof array = %zu\n", sizeof var_length_array); + + //Uma possível saída para esse programa seria: + // > Entre o tamanho do array:: 10 + // > sizeof array = 40 + + // String são apenas arrays de caracteres terminados por um + // byte NUL (0x00), representado em string pelo caracter especial '\0'. + // (Não precisamos incluir o byte NUL em literais de string; o compilador + // o insere ao final do array para nós.) + char uma_string[20] = "Isto é uma string"; + // Observe que 'é' não está na tabela ASCII + // A string vai ser salva, mas a saída vai ser estranha + // Porém, comentários podem conter acentos + printf("%s\n", uma_string); // %s formata a string + + printf("%d\n", uma_string[16]); // => 0 + // i.e., byte #17 é 0 (assim como 18, 19, e 20) + + // Se temos caracteres entre aspas simples, temos um caracter literal. + // Seu tipo é `int`, *não* `char` (por razões históricas). + int cha = 'a'; // ok + char chb = 'a'; // ok também (conversão implícita de int para char) + + // Arrays multi-dimensionais: + int multi_array[2][5] = { + {1, 2, 3, 4, 5}, + {6, 7, 8, 9, 0} + }; + // Acesso a elementos: + int array_int = multi_array[0][2]; // => 3 + + /////////////////////////////////////// + // Operadores + /////////////////////////////////////// + + // Atalho para multiplas declarações: + int i1 = 1, i2 = 2; + float f1 = 1.0, f2 = 2.0; + + int a, b, c; + a = b = c = 0; + + // Aritimética é óbvia + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // => 0 (0.5, porém, é truncado para 0) + + f1 / f2; // => 0.5, mais ou menos epsilon + // Números e cálculos de ponto flutuante não são exatos + + // Modulo também existe + 11 % 3; // => 2 + + // Operadores de comparação provavelmente são familiares, + // porém não há tipo booleano em C. Usa-se ints no lugar. + // (Ou _Bool or bool em C99.) + // 0 é falso e qualquer outra coisa é verdadeiro + // (Os operadores de comparação devolvem 0 ou 1.) + // Comparison operators are probably familiar, but + 3 == 2; // => 0 (falso) + 3 != 2; // => 1 (verdadeiro) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // C não é Python - comparações não se encadeam. + int a = 1; + // Errado: + int entre_0_e_2 = 0 < a < 2; + // Correto: + int entre_0_e_2 = 0 < a && a < 2; + + // Lógica funciona sobre ints + !3; // => 0 (Não lógico) + !0; // => 1 + 1 && 1; // => 1 (E lógico) + 0 && 1; // => 0 + 0 || 1; // => 1 (Ou lógico) + 0 || 0; // => 0 + + //Expressão condicional ( ? : ) + int a = 5; + int b = 10; + int z; + z = (a > b) ? a : b; // => 10 "se a > b retorne a, senão retorne b." + + //Operadores de incremento e decremento: + char *s = "iLoveC"; + int j = 0; + s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j. + j = 0; + s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s. + // o mesmo com j-- e --j + + // Operadores bit a bit! + ~0x0F; // => 0xF0 (negação bit a bit, "complemento de 1") + 0x0F & 0xF0; // => 0x00 (bit a bit E) + 0x0F | 0xF0; // => 0xFF (bit a bit OU) + 0x04 ^ 0x0F; // => 0x0B (bit a bit OU EXCLUSIVO) + 0x01 << 1; // => 0x02 (bit a bit shift para esquerda (por 1)) + 0x02 >> 1; // => 0x01 (bit a bit shift para direita (por 1)) + + // Cuidado quando fizer shift em inteiro com sinal - o seguinte é indefinido: + // - Fazer shift sobre um bit de sinal de um inteiro com sinal (int a = 1 << 32) + // - Fazer shift a esquerda sobre um número negativo (int a = -1 << 2) + // - Fazer shift maior que a largura do tipo de LHS: + // int a = 1 << 32; // Indefinido se int é de tamanho 32 bits + + /////////////////////////////////////// + // Estruturas de Controle + /////////////////////////////////////// + + if (0) { + printf("Nunca rodará\n"); + } else if (0) { + printf("Também nunca rodará\n"); + } else { + printf("Eu serei impresso\n"); + } + + // Loops while existem + int ii = 0; + while (ii < 10) { //QUALQUER valor diferente de 0 é verdadeiro + printf("%d, ", ii++); // ii++ incrementa o valor de ii APÓS usá-lo + } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + int kk = 0; + do { + printf("%d, ", kk); + } while (++kk < 10); // ++kk incrementa o valor de kk ANTES de usá-lo + // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // Loops for também + int jj; + for (jj=0; jj < 10; jj++) { + printf("%d, ", jj); + } // => imprime "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // *****NOTAS*****: + // Loops e Funções PRECISAM ter um corpo. Se nenhum corpo é necessário: + int i; + for (i = 0; i <= 5; i++) { + ; // Use ponto e vírgula para agir como um corpo (declaração nula) + } + + // Criando branchs com escolhas múltiplas: switch() + switch (alguma_expressao_integral) { + case 0: // labels precisam ser expressões integrais **constantes** + faca_algo(); + break; // Sem break, o controle continua após a label + case 1: + faca_outra_coisa(); + break; + default: + // Se `alguma_expressao_integral` não coincidir com nenhuma label + fputs("erro!\n", stderr); + exit(-1); + break; + } + + + /////////////////////////////////////// + // Cast de tipos + /////////////////////////////////////// + + // Todo valor em C tem um tipo, mas você pode fazer um cast de um valor em outro tipo + // se você quiser (com algumas restrições). + + int x_hex = 0x01; // Você pode colocar valores hexadecimais em variáveis + + // Cast entre tipos tentará preservar seus valores numéricos + printf("%d\n", x_hex); // => Imprime 1 + printf("%d\n", (short) x_hex); // => Imprime 1 + printf("%d\n", (char) x_hex); // => Imprime 1 + + // Tipos irão ter overflow sem aviso + printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits) + + // Para determinar o valor máximo de um `char`, de um `signed char` e de + // um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX + // e UCHAR_MAX de <limits.h> + + // Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa. + printf("%f\n", (float)100); // %f formata um float + printf("%lf\n", (double)100); // %lf formata um double + printf("%d\n", (char)100.0); + + /////////////////////////////////////// + // Ponteiros + /////////////////////////////////////// + + // Um ponteiro é uma variável declarada para armazenar um endereço de memória. + // Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você + // Pode usar o endereço de memória de suas variáveis, então, brincar com eles. + + int x = 0; + printf("%p\n", (void *)&x); // Use & para usar o endereço de uma variável + // (%p formata um objeto ponteiro do tipo void *) + // => Imprime algum endereço de memória; + + // Ponteiros começam com * na sua declaração + int *px, nao_eh_um_ponteiro; // px é um ponteiro para um int + px = &x; // armazena o endereço de x em px + printf("%p\n", (void *)px); // => Imprime algum endereço de memória + printf("%zu, %zu\n", sizeof(px), sizeof(nao_eh_um_ponteiro)); + // => Imprime "8, 4" em um sistema típico de 64 bits + + // Para pegar um valor no endereço apontado por um ponteiro, + // coloque * na frente para de-referenciá-lo. + // Nota: sim, é confuso usar '*' _tanto_ para declaração de ponteiro + // como para de-referenciá-lo. + printf("%d\n", *px); // => Imprime 0, o valor de x + + // Você também pode mudar o valor que o ponteiro está apontando. + // Teremo que cercar a de-referência entre parenteses, pois + // ++ tem uma precedência maior que *. + (*px)++; // Incrementa o valor que px está apontando por 1 + printf("%d\n", *px); // => Imprime 1 + printf("%d\n", x); // => Imprime 1 + + // Arrays são um boa maneira de alocar um bloco contínuo de memória + int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho + int xx; + for (xx = 0; xx < 20; xx++) { + x_array[xx] = 20 - xx; + } //Inicializa x_array com 20, 19, 18,... 2, 1 + + // Declara um ponteiro do tipo int e inicialize ele para apontar para x_array + int* x_ptr = x_array; + // x_ptr agora aponta para o primeiro elemento do array (o inteiro 20). + // Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos. + // Por exemplo, quando um array é passado para uma função ou é atribuído a um + // ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro. + // Exceções: quando o array é o argumento de um operador `&` (endereço-de): + // Exceptions: when the array is the argument of the `&` (address-of) operator: + int arr[10]; + int (*ptr_to_arr)[10] = &arr; // &arr não é do tipo `int *`! + // É do tipo "ponteiro para array" (de `int`s). + // ou quando o array é uma string literal usada para inicializar um array de char: + char arr[] = "foobarbazquirk"; + // ou quando é um argumento dos operadores `sizeof` ou `alignof`: + int arr[10]; + int *ptr = arr; // equivalente a int *ptr = &arr[0]; + printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8" + + // Ponteiros podem ser incrementados ou decrementados baseado no seu tipo + // (isto é chamado aritimética de ponteiros + printf("%d\n", *(x_ptr + 1)); // => Imprime 19 + printf("%d\n", x_array[1]); // => Imprime 19 + + // Você também pode alocar dinamicamente blocos de memória com a função + // da biblioteca padrão malloc, a qual recebe um argumento do tipo size_t + // representando o número de bytes a ser alocado (geralmente da heap, apesar de + // isto poder não ser verdadeiro em, e.g., sistemas embarcados - o C padrão diz + // nada sobre isso). + int *my_ptr = malloc(sizeof(*my_ptr) * 20); + for (xx = 0; xx < 20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx + } //Inicializa a memória com 20, 19, 18, 17... 2, 1 (como ints) + + // Dereferenciar memória que você não alocou cria + // "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido" + printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa. + + // Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo, + // ou ninguém mais será capaz de usá-lo até o fim da execução + // (Isto cham-se "memory leak"): + free(my_ptr); + + // Strings são arrays de char, mas elas geralmente são representadas + // como um ponteiro para char (com o apontador para o primeiro elemento do array). + // É boa prática usar `const char *' quando de-referenciando uma literal string, + // dado que elas não deverão ser modificadas (i.e. "foo"[0] = 'a' é ILEGAL.) + const char *my_str = "Esta é a minha literal string"; + printf("%c\n", *my_str); // => 'T' + + // Este não é o caso se a string for um array + // (potencialmente inicializado com um literal string) + // que reside em uma memória de escrita, como em: + char foo[] = "foo"; + foo[0] = 'a'; // Isto é legal, foo agora contém "aoo" + + funcao_1(); +} // fim da função main + +/////////////////////////////////////// +// Funções +/////////////////////////////////////// + +//Sintaxe de declaração de funções: +// <tipo de retorno> <nome da função>(<argumentos>) + +int soma_dois_int(int x1, int x2) +{ + return x1 + x2; // Use return para retornar um valor +} + +/* +Funções são chamadas por valor. Quando uma função é chamada, os argumentos passados +para a função são cópias dos argumento originais (a não ser arrays). Qualquer coisa +que você faz nos argumentos de uma função não alteram o valor do argumento original +onde a função foi chamada. + +Use ponteiros se você precisa alterar os valores dos argumentos originais + +Exemplo: reversão de string in-place +*/ + +// Uma função void não retorna valor algum +void str_reverse(char *str_in) +{ + char tmp; + int ii = 0; + size_t len = strlen(str_in); // `strlen()` é parte da biblioteca padrão C + for (ii = 0; ii < len / 2; ii++) { + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // iiº char do final + str_in[len - ii - 1] = tmp; + } +} + +/* +char c[] = "Isto é um teste."; +str_reverse(c); +printf("%s\n", c); // => ".etset mu é otsI" +*/ + +// Se estiver referenciando variáveis externas à função, use a palavra-chave extern. +int i = 0; +void testFunc() { + extern int i; //i aqui agora está usando a variável externa +} + +// Faça variáveis externas privadas para o código-fonte com static: +static int i = 0; // Outros arquivos usando testFunc() não podem acessar a variável i +void testFunc() { + extern int i; +} +//**Você pode declarar funções como static para torná-las privadas** + + +/////////////////////////////////////// +// Tipos definidos pelo usuário e structs +/////////////////////////////////////// + +// Typedefs podem ser usadas para criar apelidos para tipos +typedef int meu_tipo; +meu_tipo var_meu_tipo = 0; + +// Structs são apenas coleções de dados, os membros são alocados sequencialmente, +// na ordem que são escritos: +struct retangulo { + int altura; + int largura; +}; + +// Geralmente não é verdade que +// sizeof(struct retangulo) == sizeof(int) + sizeof(int) +// devido ao potencial de preenchimento entre os membros da estrutura +// (isto é por razões de alinhamento). [1] + +void funcao_1() +{ + struct retangulo meu_retan; + + // Acesse os membros da estrutura com . + meu_retan.altura = 10; + meu_retan.largura = 20; + + // Você pode declarar ponteiros para structs + struct retangulo *meu_retan_ptr = &meu_retan; + + // Use de-referenciamento para setar os membros da + // struct apontada... + (*meu_retan_ptr).altura = 30; + + // ... ou ainda melhor: prefira usar o atalho -> para melhorar legibilidade + meu_retan_ptr->largura = 10; // O mesmo que (*meu_retan_ptr).largura = 10; +} + +//Você pode aplicar um typedef para uma struct por conveniência +typedef struct retangulo retan; + +int area(retan r) +{ + return r.largura * r.altura; +} + +// Se você tiver structus grande, você pode passá-las "por ponteiro" +// para evitar cópia de toda a struct: +int area(const retan *r) +{ + return r->largura * r->altura; +} + +/////////////////////////////////////// +// Ponteiros para funções +/////////////////////////////////////// +/* +Em tempo de execução, funções são localizadas em endereços de memória +conhecidos. Ponteiros para funções são como qualquer outro ponteiro +(apenas guardam endereços de memória), mas podem ser usados para invocar funções +diretamente e passá-las para por toda parte. +Entretanto, a sintaxe de definição por ser um pouco confusa. + +Exemplo: use str_reverso através de um ponteiro +*/ +void str_reverso_através_ponteiro(char *str_entrada) { + // Define uma variável de ponteiro para função, nomeada f. + void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo. + f = &str_reverso; //Atribue o endereço da função em si (determinado em tempo de execução. + // f = str_reverso; Também funciona - função tornam-se ponteiros, assim como arrays + (*f)(str_entrada); // Chamando a função através do ponteiro + // f(str_entrada); // Esta é uma sintaxe alternativa, mas equivalente. +} + +/* +Desde que as assinaturas das funções sejam compatíveis, você pode atribuir qualquer +função ao mesmo ponteiro. Ponteiros para funções são geralmente um typedef por +simplicidade e legibilidade, como segue: +*/ + +typedef void (*minha_função_type)(char *); + +// Declarando o ponteiro: +// ... +// minha_função_type f; + +//Caracteres especiais: +'\a' // Alerta (sino) +'\n' // Nova linha +'\t' // Tab (justifica texto a esquerda) +'\v' // Tab vertical +'\f' // Nova linha (formfeed) +'\r' // Retorno de carroça +'\b' // Backspace +'\0' // Caracter nulo. Geralmente colocado ao final de string em C. + // oi\n\0. \0 é usado por convenção para marcar o fim da string. +'\\' // Barra invertida +'\?' // Interrogação +'\'' // Aspas simples +'\"' // Aspas duplas +'\xhh' // Número hexadecimal. Exemplo: '\xb' = tab vertical +'\ooo' // Número octal. Exemplo: '\013' = tab vertical + +// formatando impressão: +"%d" // inteiro +"%3d" // inteiro com pelo menos 3 dígitos (justifica texto a direita) +"%s" // string +"%f" // ponto-flutuante +"%ld" // long +"%3.2f" // ponto-flutuante com pelo menos 3 dígitos a esquerda e 2 a direita +"%7.4s" // (também pode-se fazer com strings) +"%c" // char +"%p" // ponteiro +"%x" // hexadecimal +"%o" // octal +"%%" // imprime % + +/////////////////////////////////////// +// Ordem de avaliação +/////////////////////////////////////// + +//-----------------------------------------------------------// +// Operadores | Associatividade // +//-----------------------------------------------------------// +// () [] -> . | esquerda para direita // +// ! ~ ++ -- + = *(type)sizeof | direita para esqureda // +// * / % | esquerda para direita // +// + - | esquerda para direita // +// << >> | esquerda para direita // +// < <= > >= | esquerda para direita // +// == != | esquerda para direita // +// & | esquerda para direita // +// ^ | esquerda para direita // +// | | esquerda para direita // +// && | esquerda para direita // +// || | esquerda para direita // +// ?: | direita para esqureda // +// = += -= *= /= %= &= ^= |= <<= >>= | direita para esqureda // +// , | esquerda para direita // +//-----------------------------------------------------------// + +``` + +## Leitura adicional + +É recomendado ter uma cópia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language). +Este é *o* livro sobre C, escrito pelos criadores da linguage. Mas cuidado - ele é antigo e contém alguns erros (bem, +ideias que não são consideradas boas hoje) ou práticas mudadas. + +Outra boa referência é [Learn C the hard way](http://c.learncodethehardway.org/book/). + +Se você tem uma pergunta, leia [compl.lang.c Frequently Asked Questions](http://c-faq.com). + +É importante usar espaços e indentação adequadamente e ser consistente com seu estilo de código em geral. +Código legível é melhor que código 'esperto' e rápido. Para adotar um estilo de código bom e são, veja +[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle). + +Além disso, Google é teu amigo. +[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member |