Olá, seja bem-vindo de volta.
Nesta aula, quero falar sobre alguns erros comuns que você cometerá
ao programar em c.
Você pode estar familiarizado com alguns deles em seus
desafios anteriores e já encontrou esses erros, mas esses são
os tipos de erros mais comuns.
O primeiro é muito, muito óbvio. Está faltando um ponto e vírgula.
Lembre-se de que todas as instruções em c terminarão em ponto-e-vírgula.
Se você não tiver, o compilador irá reclamar.
Portanto, colocar um ponto-e-vírgula errado ou perder um ponto-e-vírgula inteiramente é
um erro muito comum. Nesse caso, estamos perdendo um ponto-e-vírgula.
Temos uma declaração if. Colocamos um ponto e vírgula no final da instrução if.
E isso realmente faz com que o comportamento do programa seja completamente diferente.
Isso irá realmente compilar.
Quando você perde um ponto-e-vírgula e nem o inclui, ele não compila.
Mas, neste caso, o valor de j sempre será definido como zero
porque o ponto-e-vírgula na instrução if foi colocado.
Portanto, o ponto-e-vírgula é perfeitamente válido após a instrução if.
Na verdade, representa a instrução nula.
E, portanto, você não tem um erro do
compilador, mas isso causará um problema porque j nunca será definido como zero.
E esse tipo de erro também pode ser comum em looping.
Quando você tem um loop e coloca o ponto-e-vírgula
no final do loop for e então você pode ter um colchete, onde você
não tem o colchete porque você terá um erro se tiver o colchete, muito comum.
Outro é confundir o operador igual com o operador igual a igual.
Mencionado especificamente que o operador igual a igual
não está comparando strings. Portanto, se você usar igual a igual
ao comparar strings, isso não é válido. Só vai comparar as referências.
Mas se você realmente pretende atribuir um valor a uma variável e,
em vez disso, usar igual a igual, você terá um compilador.
Agora, se você tentar comparar dois itens, como dois inteiros
dentro de uma instrução if e, em vez disso, usar o operador
de atribuição, na verdade não haverá um erro
do compilador, mas essa expressão sempre será avaliada como verdadeira.
Então, quando você usa igual e não usa igual igual,
isso geralmente é feito na instrução if while do, dentro da expressão booleana.
E isso é válido, exceto que tem
o efeito de atribuir a algo em oposição a executar algo.
Portanto, neste exemplo,
se a for igual a 2, estamos atribuindo 2 a a.
Sempre definido como verdadeiro, porque essa é uma afirmação verdadeira, porque você nunca
falha quando está fazendo uma atribuição. E então printf sempre será executado.
O que você realmente pretendia fazer aqui é dizer se a é igual a.
Portanto, é muito comum usar igual em oposição a igual a igual e
então não ter um erro do compilador.
Se você usar igual a igual
na situação errada, poderá
ter um comportamento inesperado também, mas terá
um erro do compilador se estiver usando-o incorretamente para atribuição.
Mas tome cuidado com isso com iguais em vez de iguais.
Omitindo declarações de protótipo.
Mencionei que é muito importante sempre declarar suas funções
no início do arquivo antes de usá-las.
Porém, isso nem sempre acontece e é um erro muito comum.
E geralmente, o que acontecerá é que você obterá um erro de declaração
implícita no compilador.
Neste exemplo, se você tiver a raiz quadrada definida posteriormente
no programa do que onde a está chamando ou em
outro arquivo e não
a declarou explicitamente, você receberá alguns avisos.
O compilador vai assumir que a função retorna um int.
É sempre mais seguro incluir essa declaração de protótipo no
topo para todas as funções
que você chama,
explícita ou implicitamente, incluindo o arquivo de cabeçalho correto em seu programa.
Mas quando você não inclui isso, essas declarações de protótipo podem
ter erros.
Falha ao incluir o arquivo de cabeçalho que inclui a definição de uma função
de biblioteca de programação c sendo usada no programa.
Portanto, neste caso, você deseja reutilizar algum código. Talvez você tenha a função
printf para exibir alguma saída, mas não incluiu o arquivo de cabeçalho lib padrão.
Isso é um erro. E isso geralmente será informado pelo compilador.
Haverá um problema de vinculação
com essa função.
Portanto, neste caso, temos uma resposta dupla igual ao valor 1 da raiz quadrada.
Se este programa não incluir a matemática. arquivo de cabeçalho, isso
irá gerar um erro de que a raiz quadrada é indefinida.
Ele tentará vincular os arquivos objeto. Não terá matemática. o.
E vai dizer, ei, você está chamando de raiz quadrada, mas não há implementação para isso.
Portanto, certifique-se de incluir os cabeçalhos corretos
para todas as suas invocações de funções, especialmente da biblioteca padrão.
Confundir uma constante de caractere em uma string de caracteres.
Portanto, aqui se temos texto igual a aspas simples, esse é
um único caractere que é atribuído ao texto.
Se tivermos uma variável chamada text e a atribuirmos entre aspas duplas,
isso será um ponteiro para a string de caracteres.
Isso não é válido para um
único personagem.
Na verdade, falamos sobre constantes de
string e como atribuí-las a matrizes de caracteres.
E como você não pode fazer isso com os iguais e você tem que
realmente fazer com a cópia da estrela.
Neste caso, quando dizemos que o texto é igual a a, está atribuindo um ponteiro
e isso também não é válido e
veja o que você teria que fazer é fazer o texto
da estrela igual a a ou a cópia da estrela se você não
não quero atribuí-lo diretamente assim.
Mas você captou a essência.
Usar um a dentro de aspas simples versus um caractere
entre aspas duplas completamente diferente, caractere versus string.
No primeiro caso, o texto é normalmente declarado como uma variável char.
E no segundo caso, deve ser declarado como um ponteiro de tipo para um char.
E se você quiser atribuir um valor a esse ponteiro
que não seja o próprio ponteiro, você terá que desreferenciá-lo.
Na verdade, isso está incorreto porque se for um ponteiro
em vez de atribuir um endereço, você está atribuindo a ele uma string, de modo
que não faz sentido.
Usando os limites errados para um array, exceção de array fora dos limites.
Aqui, estamos declarando uma matriz de inteiros de tamanho 100 e, em
seguida, algumas variáveis I e soma com apenas algumas sendo inicializadas.
E passamos por nosso loop, dizemos que para I igual a 1 I é menor que igual a 100.
Isso está incorreto porque o tamanho de cem significa que há
cem elementos no array. Mas os arrays são baseados em zero.
Portanto, o primeiro elemento é zero. O índice máximo que você
pode atribuir ou acessar em uma matriz é 99.
Isso vai para menos do que igual.
Então você vai cometer um erro fora dos limites aqui.
Este não é um
subscrito válido porque este loop irá até 100.
Provavelmente também está incorreto porque você está começando em 1.
Se você realmente quisesse o primeiro elemento desta matriz, começaria em 0.
Esquecer de reservar um local extra em uma matriz para
o caractere nulo de terminação de uma string
também é um problema comum.
Ao declarar seus arrays de caracteres, eles precisam ser grandes o suficiente para conter o caractere de terminação sozinho.
É por isso que eu sugiro que
você não coloque um tamanho em um array ao criá-lo, se estiver inicializando-o.
Você só colocaria o tamanho lá se não o estivesse inicializando.
Se você está criando inicializando na mesma linha, deixe c fazer o
trabalho para você, ele irá colocar automaticamente o tamanho certo e incluir aquele terminador nulo.
Então, por exemplo, se você tem uma string de caracteres chamada
hello, isso tem mais de cinco posições de memória, são seis por causa do terminador nulo no final.
Não se esqueça do tamanho de seus arrays.
Este é um problema comum com ponteiros sobre o qual não discutimos muito, mas
eu queria apenas mencionar porque é muito comum.
Nos ponteiros, quando você quiser acessar ou mesmo instruir, quando
quiser acessar algo por meio
de um ponteiro, deve-se usar o traço maior que o símbolo.
Isso é usado quando você está acessando um elemento de ponteiro.
Portanto, se você tiver um ponteiro que aponta para uma estrutura, é assim que você o acessa.
Se você tem uma estrutura, não
é um ponteiro, então você a acessa usando um operador ponto.
Muitas vezes, esse operador de ponto e esse traço maior que
são usados incorretamente.
Ponto para não ponteiros, ponteiros traço maior que, isso ficará claro
em mais de nossos exemplos.
Omitindo o "e" comercial antes de variáveis não apontadoras em uma chamada scanf.
Portanto, lembre-se de que nossa chamada scanf espera um ponteiro como um segundo argumento,
e isso significa um endereço.
Quando declaramos um tipo de dados como uma variável do tipo int, isso não
é um ponteiro.
Portanto, para permitir que o scanf armazene esses dados em nossa variável int, temos que passar o
e comercial para dizer que é um endereço.
Portanto, isso é incorreto,
não ter o e comercial antes do número e digitalizar f como
o segundo argumento não é válido. A única vez em que você não tem o e comercial é se estiver usando
um ponteiro, como uma matriz de caracteres.
Todos os argumentos que aparecem após a string de formato e scanf devem ser ponteiros.
Usando uma variável de ponteiro antes de ser inicializado.
Portanto, aqui está um exemplo de criação de um ponteiro e, em seguida, tentar atribuí-lo.
E esta é a atribuição correta onde você atribui um valor e o des-referencia.
Mas o que não fizemos aqui é que inicializamos o ponteiro para realmente ter qualquer
memória alocada para ele e você não
pode fazer isso em c.
Você só pode aplicar o operador de indireção,
que é o asterisco anterior a um
ponto ou variável depois de definir a variável apontando para algum lugar.
Então tem que estar apontando para algum lugar, agora é nulo, não está apontando para lugar nenhum porque
você não alocou nenhuma memória.
Portanto, o ponteiro char nunca é definido para apontar para nada, então a atribuição não é significativa.
Na verdade, isso causaria uma falha de segmentação.
Outro erro comum é omitir a instrução break no final de um caso em uma instrução switch.
Se a pausa não for incluída no final de um caso, a execução continuará para o próximo caso.
Isso é o que eu mencionei onde você tem um caso, ele é avaliado.
E se você não tiver esse intervalo, ele vai direto
para o próximo caso e executará o código dentro desse próximo caso.
Portanto, você sempre quer ter intervalos dentro de suas declarações de caso.
Há momentos em que você deseja seguir um caso para outro e
eles fazem exatamente a mesma coisa, nesse caso
você não teria nada dentro da instrução do caso.
Inserindo um ponto-e-vírgula no final de uma definição de pré-processador.
Lembre-se de que as definições do pré-processador começam com o
número, o símbolo da libra. O pré-processador é executado antes do compilador,
geralmente para otimização.
A sintaxe correta para as definições do pré-processador não deve incluir um ponto-e-vírgula.
Porém, em c você, adquira o hábito de sempre colocar um ponto e vírgula depois de tudo.
Mas você tem que lembrar que se você definir alguns dados constantes
que não precisam do ponto-e-vírgula, isso está incorreto.
Isso levará a um erro de sintaxe se
for usada uma expressão como essa.
Curtiu isso. Então, se você realmente tentar usar
isso para encontrar, não haverá problema em ter o ponto-e-vírgula no final.
Mas quando o pré-processador for executado ele irá inserir exatamente o que está definido.
Portanto, será veiculado no final dos dados de 999 dois pontos.
Isso é o que o compilador verá e, na verdade, causará um erro, que
seria um erro de sintaxe.
Omitir um parêntese de fechamento ou aspas de fechamento em
qualquer afirmação, muito comum. Então isso também está diretamente relacionado
aos colchetes, ter uma chave inicial e não terminar a chave, a mesma
coisa com os parênteses. Neste caso, temos
dois parênteses iniciais à esquerda ou três, mas temos
apenas dois parênteses finais. Estamos perdendo os parênteses direitos finais.
Isso seria um erro de sintaxe que o compilador encontraria.
Portanto, quando você usa o embed entre parênteses para separar cada parte de uma equação, torna-se
uma linha de código mais legível.
Você quer usar parênteses.
No entanto, você quer ter certeza de que todos
eles combinam se você iniciar um parêntese, você deve ter um parêntese de fechamento final, o mesmo com as chaves.
Você começa uma chave, tem que ter uma chave final.
Portanto, ou você tem muitos ou tem muito
pouco, mas o compilador reclamará, e isso é muito, muito comum.
Portanto, a segunda linha aqui também está faltando uma aspa de fechamento, esta declaração de impressão.
Não temos uma citação final.
O compilador reclamará disso.
Ambos irão gerar um erro de compilação.
Às vezes, embora o compilador seja muito enganador porque ele não
sabe realmente onde o erro ocorre. Ele acha que o erro pode ter ocorrido em uma linha subsequente.
Portanto, a linha que informa o erro pode ser enganosa.
Portanto, dependendo se o compilador
usa um parêntese ou uma aspa em uma
linha subsequente, ele realmente completará essa expressão.
Portanto, ele moverá o erro para outra linha.
E é isso que vai reclamar e dizer que é aí que está o erro. Mas o erro
real está mais acima de onde você pretendia colocá-lo.
Esses são alguns erros comuns que vejo muitos programadores de
C cometendo.
Eles são fáceis de consertar. E se você entendê-los e
estudar isso, você
saberá que não deve fazê-los. Não há problema em
fazê-los como um iniciante, mas conforme você codifica
mais e mais e pratica mais, você vai perceber, hey,
esqueci um parêntese, esqueci um colchete, não usei igual e igual a
igual corretamente , Estou usando ponteiros incorretamente, não aloquei memória.
Todas essas coisas virão como uma segunda natureza. Obrigada.