summaryrefslogtreecommitdiffhomepage
path: root/pt-br/c-pt.html.markdown
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br/c-pt.html.markdown')
-rw-r--r--pt-br/c-pt.html.markdown71
1 files changed, 36 insertions, 35 deletions
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 43688724..2c274f12 100644
--- a/pt-br/c-pt.html.markdown
+++ b/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
-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 é a linguagem de mais baixo nível que a maioria dos programadores
+utilizarão, e isso dá a ela uma grande velocidade bruta. Apenas fique
+atento se este manual de gerenciamento de memória e C vai te levar
+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
- // um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX
+ // 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.
@@ -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