Merge pull request #1902 from cassiobsilva/c-typos

[c/pt-br] Fixing Pt-br typos in C file

pt-br/c-pt.html.markdown

@@ -7,29 +7,30 @@ contributors:
 translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
     - ["Elton Viana", "https://github.com/eltonvs"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
 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
+C é a linguagem de mais baixo nível que a maioria dos programadores
-irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique
+utilizarão, 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
+atento se este manual de gerenciamento de memória e C vai te levar
-tão longe quanto você precisa. 
+tão longe quanto 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. 
+Comentários de múltiplas 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.
+//enumeraçõ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.
 
@@ -54,13 +55,13 @@ 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, 
+	// 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
     ///////////////////////////////////////
@@ -78,7 +79,7 @@ int main() {
     // 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; 
+    long long x_long_long = 0;
 
     // floats são normalmente números de ponto flutuante
 	// com 32 bits
@@ -93,7 +94,7 @@ int main() {
     unsigned int ux_int;
     unsigned long long ux_long_long;
 
-	// caracteres dentro de aspas simples são inteiros 
+	// 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.
@@ -104,7 +105,7 @@ int main() {
 
 	// 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. 
+	// 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.
@@ -120,7 +121,7 @@ int main() {
 	// Você pode inicializar um array com 0 desta forma:
     char meu_array[20] = {0};
 
-	// Indexar um array é semelhante a outras linguages
+	// Indexar um array é semelhante a outras linguagens
 	// Melhor dizendo, outras linguagens são semelhantes a C
     meu_array[0]; // => 0
 
@@ -129,7 +130,7 @@ int main() {
     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 
+	// 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];
@@ -144,14 +145,14 @@ int main() {
     // > Entre o tamanho do array: 10
     // > sizeof array = 40
 
-	// String são apenas arrays de caracteres terminados por um 
+	// String são apenas arrays de caracteres terminados por um
 	// byte nulo (0x00), representado em string pelo caracter especial '\0'.
 	// (Não precisamos incluir o byte nulo em literais de string; o compilador
 	// o insere ao final do array para nós.)
-    char uma_string[20] = "Isto é uma string"; 
+    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 
+	// Porém, comentários podem conter acentos
     printf("%s\n", uma_string); // %s formata a string
 
     printf("%d\n", uma_string[17]); // => 0
@@ -175,7 +176,7 @@ int main() {
     ///////////////////////////////////////
 
     // Atalho para multiplas declarações:
-    int i1 = 1, i2 = 2; 
+    int i1 = 1, i2 = 2;
     float f1 = 1.0, f2 = 2.0;
 
     int a, b, c;
@@ -206,7 +207,7 @@ int main() {
     2 <= 2; // => 1
     2 >= 2; // => 1
 
-	// C não é Python - comparações não se encadeam.
+	// C não é Python - comparações não se encadeiam.
     int a = 1;
     // Errado:
     int entre_0_e_2 = 0 < a < 2;
@@ -231,7 +232,7 @@ int main() {
     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; 
+    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
 
@@ -308,7 +309,7 @@ int main() {
         exit(-1);
         break;
     }
-    
+
 
     ///////////////////////////////////////
     // Cast de tipos
@@ -327,8 +328,8 @@ int main() {
 	// 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 
+	// 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 
+	// 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.
@@ -341,7 +342,7 @@ int main() {
     ///////////////////////////////////////
 
 	// 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ê
+	// Sua 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;
@@ -363,13 +364,13 @@ int main() {
     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
+	// Temos que cercar a de-referência entre parênteses, 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
+	// Arrays são uma 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++) {
@@ -379,7 +380,7 @@ int main() {
 	// 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.
+	// Isto funciona porque arrays são apenas ponteiros para seus 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):
@@ -395,7 +396,7 @@ int main() {
     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
+	// (isto é chamado aritmética de ponteiros
     printf("%d\n", *(x_ptr + 1)); // => Imprime 19
     printf("%d\n", x_array[1]); // => Imprime 19
 
@@ -413,9 +414,9 @@ int main() {
 	// "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,
+	// Quando se termina 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"):
+	// (Isto chama-se "memory leak"):
     free(my_ptr);
 
 	// Strings são arrays de char, mas elas geralmente são representadas
@@ -537,7 +538,7 @@ int area(retan r)
     return r.largura * r.altura;
 }
 
-// Se você tiver structus grande, você pode passá-las "por ponteiro" 
+// Se você tiver structus grande, você pode passá-las "por ponteiro"
 // para evitar cópia de toda a struct:
 int area(const retan *r)
 {
@@ -554,8 +555,8 @@ conhecidos. Ponteiros para funções são como qualquer outro ponteiro
 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 
+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.
@@ -575,7 +576,7 @@ typedef void (*minha_função_type)(char *);
 
 // Declarando o ponteiro:
 // ...
-// minha_função_type f; 
+// minha_função_type f;
 
 //Caracteres especiais:
 '\a' // Alerta (sino)
@@ -586,7 +587,7 @@ typedef void (*minha_função_type)(char *);
 '\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. 
+     //   oi\n\0. \0 é usado por convenção para marcar o fim da string.
 '\\' // Barra invertida
 '\?' // Interrogação
 '\'' // Aspas simples
@@ -606,7 +607,7 @@ typedef void (*minha_função_type)(char *);
 "%p"    // ponteiro
 "%x"    // hexadecimal
 "%o"    // octal
-"%%"    // imprime % 
+"%%"    // imprime %
 
 ///////////////////////////////////////
 // Ordem de avaliação