mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 01:51:38 +00:00
Merge pull request #1902 from cassiobsilva/c-typos
[c/pt-br] Fixing Pt-br typos in C file
This commit is contained in:
Adam Bard
commit
9274b10f03
@ -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
|
||||
|
||||
Loading…
Reference in New Issue
Block a user