iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-05-05 14:28:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1902 from cassiobsilva/c-typos

Browse Source 
[c/pt-br] Fixing Pt-br typos in C file
This commit is contained in:
Adam Bard 2015-10-31 18:32:41 +08:00
commit 9274b10f03
1 changed files with 36 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
pt-br/c-pt.html.markdown
View File

@ -7,29 +7,30 @@ contributors:
translators: translators:
- ["João Farias", "https://github.com/JoaoGFarias"] - ["João Farias", "https://github.com/JoaoGFarias"]
- ["Elton Viana", "https://github.com/eltonvs"] - ["Elton Viana", "https://github.com/eltonvs"]
- ["Cássio Böck", "https://github.com/cassiobsilva"]
lang: pt-br lang: pt-br
filename: c-pt.el filename: c-pt.el
--- ---
Ah, C. Ainda é **a** linguagem de computação de alta performance. 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 ```c
// Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99 // 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. Funcionam no C89 também.
*/ */
// Constantes: #define <palavra-chave> // Constantes: #define <palavra-chave>
#definie DAY_IN_YEAR 365 #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}; enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
// SEG recebe 2 automaticamente, TER recebe 3, etc. // SEG recebe 2 automaticamente, TER recebe 3, etc.
@ -120,7 +121,7 @@ int main() {
// Você pode inicializar um array com 0 desta forma: // Você pode inicializar um array com 0 desta forma:
char meu_array[20] = {0}; 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 // Melhor dizendo, outras linguagens são semelhantes a C
meu_array[0]; // => 0 meu_array[0]; // => 0
@ -206,7 +207,7 @@ int main() {
2 <= 2; // => 1 2 <= 2; // => 1
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; int a = 1;
// Errado: // Errado:
int entre_0_e_2 = 0 < a < 2; int entre_0_e_2 = 0 < a < 2;
@ -341,7 +342,7 @@ int main() {
/////////////////////////////////////// ///////////////////////////////////////
// Um ponteiro é uma variável declarada para armazenar um endereço de memória. // 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. // Pode usar o endereço de memória de suas variáveis, então, brincar com eles.
int x = 0; int x = 0;
@ -363,13 +364,13 @@ int main() {
printf("%d\n", *px); // => Imprime 0, o valor de x printf("%d\n", *px); // => Imprime 0, o valor de x
// Você também pode mudar o valor que o ponteiro está apontando. // 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 *. // ++ tem uma precedência maior que *.
(*px)++; // Incrementa o valor que px está apontando por 1 (*px)++; // Incrementa o valor que px está apontando por 1
printf("%d\n", *px); // => Imprime 1 printf("%d\n", *px); // => Imprime 1
printf("%d\n", x); // => 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 x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho
int xx; int xx;
for (xx = 0; xx < 20; 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 // Declara um ponteiro do tipo int e inicialize ele para apontar para x_array
int* x_ptr = x_array; int* x_ptr = x_array;
// x_ptr agora aponta para o primeiro elemento do array (o inteiro 20). // 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 // Por exemplo, quando um array é passado para uma função ou é atribuído a um
// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro. // ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
// Exceções: quando o array é o argumento de um operador `&` (endereço-de): // 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" 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 // 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_ptr + 1)); // => Imprime 19
printf("%d\n", x_array[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" // "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. 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 // 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); free(my_ptr);
// Strings são arrays de char, mas elas geralmente são representadas // Strings são arrays de char, mas elas geralmente são representadas