Buscar

[INF1007] DicasGerais

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 3, do total de 10 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 6, do total de 10 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 9, do total de 10 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Prévia do material em texto

Programação II 
Monitor: André Vicente Pessanha 
Dicas Gerais: 
 
*************************************************************************************************** 
 
 
OBS:​ Essas dicas são úteis para a P1, P2 e P3! :) 
 
 
*************************************************************************************************** 
 
 
- Modo mais simples de escrever condições que verifica se algo é NULL ou não: 
 
EX: Prevenção de erro na alocação dinâmica. 
 
float * notas; 
 
notas = (float *) malloc (10 * sizeof(float)); 
if(!notas){ 
 puts("Erro! Sem memoria!"); 
 exit(1); 
} 
 
 
Vamos por partes: 
 
- if(!notas) é o mesmo que escrever if(notas == 0) 
 
- Tem uma macro >> #define NULL 0 << no protótipo <stdlib.h> 
 
OBS:​ É justamente por isso que precisamos incluir a <stdlib.h> quando usamos NULL! 
 
Então escrever if(!notas) é exatamente o >> MESMO << que if(notas == NULL) 
E da mesma forma, escrever if(notas) é o >> MESMO << que if(notas != NULL) 
 
OBS:​ Eu recomendo usar if(!notas) ou if(notas) dependendo da situação, por ser muito mais 
simples e prático! :) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 
 
- Modo mais simples de escrever condições com >>Apenas<< uma linha em seu 
bloco de execução: 
 
EX: Uma função que retorna o valor da multa de acordo com a quantidade de dias em 
atraso: 
 
float calculaMulta (int qtd){ 
 if(qtd == 0){ 
 puts("Isento de Multa!"); 
 return 0; 
 } 
 else if(qtd < 5) 
 return qtd * 3.7; 
 else if(qtd < 10) 
 return qtd * 5.7; 
 else 
 return qtd * 8.7; 
} 
 
OBS:​ Notou que em condições com >>Somente<< uma linha de código, podemos omitir as 
chaves? :) 
 
Já que podemos fazer isso, porque não colocar ao lado da condição? :D 
 
 
float calculaMulta (int qtd){ 
 if(qtd == 0){ 
 puts("Isento de Multa!"); 
 return 0; 
 } 
 else if(qtd < 5) return qtd * 3.7; 
 else if(qtd < 10) return qtd * 5.7; 
 return qtd * 8.7; 
} 
 
Dessa forma, além de ficar bem mais simples e prático, ocupa bem menos espaço! (No 
Visual Studio e principalmente no papel!) 
 
OBS: Lembrando que como a função é encerrada em todas as condições, nesse caso 
podemos omitir o 'else' também! 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 
 
 
- Atalho em condições e funções: 
 
EX: Temos uma função que compara dois valores e queremos saber se o primeiro é maior 
que o segundo: 
 
int ehMaior(int x, int y){ 
 if(x > y) return 1; 
 return 0; 
} 
 
res = ehMaior (10, 5); //Chamada da função. 
 
OBS:​ O mais comum é retornar 1 pra verdade e 0 pra falso. 
 
 
Mas podemos reescrever essa função de uma forma bem mais simples: 
 
int ehMaior(int x, int y){ 
 return (x > y); 
} 
 
OBS:​ Os parênteses são opcionais! 
 
 
Mas como isso funciona? 
 
(x > y) é um exemplo de expressão Booleana, pra facilitar imagina como se tivesse um 'if' ao 
lado. 
 
Dependendo do resultado dessa expressão a função: 
 
- Retorna Zero se for falsa. 
 
>> OU << 
 
- Retorna um valor >> diferente << de Zero se for verdadeira. (Normalmente 1!) 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 
 
 
 
- Printf Avançado: 
 
Observe esse exemplo super simples que compara dois valores e exibe uma mensagem 
para o usuário: 
 
 
int main (void){ 
int x = 5, y = 10; 
 
if(x > y) puts("X eh maior!"); 
else puts("X eh menor!"); 
 
return 0; 
} 
 
Mas como são só duas possibilidades, podemos reescrever da seguinte forma: 
 
 
int main (void){ 
int x = 5, y = 10; 
 
printf("%s\n", (x > y)? "X eh maior!" : "Y eh maior!"); 
 
return 0; 
} 
 
Lembra que uma expressão Booleana pode ser verdadeira ou falsa? :) 
 
Então é como se fosse uma pergunta mesmo! A interrogação faz parte da notação! 
 
(x > y)? 
 
Temos duas possibilidades de resposta. Se for verdade, vai exibir a primeira mensagem "X 
eh maior!", senão vai exibir a segunda! 
 
OBS:​ Imagine esses dois pontos > : < como se fosse um 'else'! 
 
 
 
 
 
 
 
 
 
 
EX2: Se fosse pra exibir o maior valor: 
 
int main (void){ 
int x = 5, y = 10; 
 
printf("Maior Valor: %d\n", (x > y)? x : y); 
 
return 0; 
} 
 
Mesmo esquema, mas ao invés de exibir mensagem, imprime o maior valor. 
 
OBS:​ É totalmente opcional usar esse printf e talvez nem todo professor ensine esses 
detalhes, sem riscos de aparecer ou ser cobrado em provas, talvez em algum exercício de 
aula, mas não deixa de ser interessante essa nova notação! :D 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Sobre as mensagens para o usuário: 
 
puts("Erro! Sem memoria!"); 
return NULL; 
 
Essas mensagens são completamente opcionais! Recomendo só colocar se o enunciado 
deixar bem claro que precisa, tirando isso, nem perca tempo! Nessa prevenção de erro do 
malloc por exemplo, pode encerrar direto a função. 
 
E nos casos em que o enunciado pede pro usuário digitar algo: Nome e média por exemplo, 
pra não deixar em branco, coloque assim: 
 
puts("Nome e Média: "); 
 
Evite mensagens elaboradas do tipo: 
 
puts("Senhor usuario, tem como digitar o seu nome e a sua media?"); :D 
 
 
OBS: ​A função 'puts' exibe mensagens da mesma forma que o printf, mas com a vantagem 
de já ter o '\n' embutido! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Funções que imprimem mensagens na tela: 
 
Comparação função puts v.s printf: 
 
- Ambas imprimem mensagens na tela. 
 
- Somente o printf consegue imprimir formatos de impressão Ex: %d, %f, etc. 
 
- O puts vem com o '\n' embutido nele, ou seja, sempre que você for imprimir algo, ele já 
pula uma linha automaticamente. (Se vc usar o '\n' no puts ele vai pular 2 linhas) 
 
- Como o puts só serve pra imprimir mensagens, ele é um pouco mais leve que o printf na 
execução do programa. 
 
OBS:​ Use o puts com sabedoria, somente quando você > NÃO < precisar imprimir formatos 
de impressão e além disso, muito cuidado em casos que você não quer pular linha, nesse 
caso use o printf. 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 >>​NUNCA​<< use while ou 'for' na recursão! Justamente pelo fato da recursão já ser uma 
repetição! 
 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Use > return ; < pra encerrar manualmente funções void! 
 
OBS:​ Mesmo sem colocar nada, a função void sempre se encerra automaticamente ao 
chegar no fim do seu bloco. Mas isso só acontece porque é o próprio compilador que coloca 
o "return ;" no final! Como se ele estivesse invisível lá! :D 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
 
 
 
- Arquivo >NÃO< é cobrado em Prog 2! 
 
Mesmo se passarem exercícios que envolvam arquivo, essa matéria >>NÃO<< será 
cobrada em Prog 2! E pelo menos a parte do exercício que envolve manipulação de arquivo 
já vem pronta! 
 
OBS:​ Arquivos podem ser usados pra deixar o exercício um pouco mais próximo da 
realidade, onde lidamos com uma grande quantidade de dados e também pra agilizar a 
forma de testar o programa. (Ao invés de pedir pra um usuário imaginário digitar os dados) 
 
 
------------------------------------------------------- // ------------------------------------------------------------- Sobre declaração de variáveis: 
 
Só podemos declarar variáveis no começo de blocos { } e >>ANTES<< de qualquer linha de 
comando! O mais comum é declarar variáveis após o começo do bloco de uma função, mas 
também é possível declarar no começo de bloco de repetições, condições, etc. 
 
EX: O erro mais comum é quando precisamos alocar dinamicamente duas variáveis em 
sequência. 
 
 
int main (void){ 
 Ponto *p; 
 Cor *c; 
 
 p = (Ponto *) malloc (sizeof(Ponto)); 
 if(!p) exit(1); 
 c = (Cor *) malloc (sizeof(Cor)); 
 if(!c) exit(2); 
 
} 
 
OBS:​ Essa é a forma mais correta e segura! Alocar e fazer a prevenção de erro de cada um 
separadamente. 
 
Mas lembra que podemos declarar e alocar ao mesmo tempo? É exatamente aí que 
acontece o erro! 
 
 
 
 
int main (void){ 
 Ponto *p = (Ponto *) malloc (sizeof(Ponto)); 
 if(!p) exit(1); 
 Cor *c = (Cor *) malloc (sizeof(Cor)); 
 if(!c) exit(1); 
 
} 
 
OBS:​ if(!p) é uma linha de comando, então >>NÃO<< podemos declarar mais variáveis 
depois! E pra variar, esse é mais um erro que o Visual Studio não avisa! :( 
 
Nesse caso, temos a opção de declarar separadamente (Recomendado!) ou declarar as 
duas e fazer a prevenção de erro junto: 
 
int main (void){ 
 Ponto *p = (Ponto *) malloc (sizeof(Ponto)); 
 Cor *c = (Cor *) malloc (sizeof(Cor)); 
 if(!p || !c) exit(1); 
 
} 
 
OBS: Se deu erro na alocação de um >> OU << do outro, o programa é encerrado. 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Sobre a função strcmp: 
 
 
- Retorna um valor >MENOR< que zero se a primeira string vem >ANTES< (Ordem 
alfabética) da segunda. 
 
- Retorna um valor >MAIOR< que zero se a primeira string vem >DEPOIS< da segunda. 
 
- Retorna zero se são iguais. 
 
 
OBS:​ Um erro comum é achar que a strcmp retorna -1, 0 ou 1! (Apesar de algumas versões 
do Visual Studio retornarem sempre esses valores) 
 
 
 
 
Cada caracter possui uma numeração na Tabela ASCII. 
 
Tabela: https://linabanovec.files.wordpress.com/2011/11/ascii.png 
 
O que a função strcmp faz é simplesmente diminuir o código dos caracteres! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
 
- Conversão de tipos: (Typecast) 
 
Dependendo da necessidade, podemos converter um formato em outro. 
 
EX: Temos um valor em float que queremos converter pra int. 
 
float valor = 6.45; 
 
printf("Desconsiderando decimais: %d\n", (int) valor); 
 
EX2: Sempre que usamos a função malloc. 
 
Aluno * novo; 
 
novo = (Aluno *) malloc (sizeof(Aluno)); 
 
OBS: Como a função malloc nos retorna um ponteiro genérico, precisamos >>Sempre<< 
usar o typecast pra converter o ponteiro pro formato que precisamos! 
 
 
------------------------------------------------------- // ------------------------------------------------------------ 
 
 
- Leitura de String em sequência: 
 
 
Para ler uma sequência de strings usando a mesma variável.(Armazenando por cima da 
anterior) 
Use sempre scanf com um >> espaço << entre a primeira aspa e a %! 
 
 
 
 
 
 
EX: 
 
int main (void){ 
char s1[41]; 
int i; 
 
for(i=0;i<2;i++){ 
 puts("Digite um nome: "); 
 scanf(" %40[^\n]", s1); 
 printf("Nome: %s\n",s1); 
} 
return 0; 
} 
 
 
------------------------------------------------------- // ------------------------------------------------------------

Outros materiais