Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Linguagem C
Lab. de Termofluidodinâmica
PEQ/COPPE/UFRJ
Curso de Nivelamento
2007
Ementa do Curso
● Introdução à ● Fluxos de Controle
Programação ● Condicionais if, switch
Científica ● Laços for, while
● Tipos e Operadores ● Tipos Derivados
Básicos
● I/O de Arquivos
● Variável inteira,
caractere, pt flutuante
● Arrays (matrizes)
● Operadores
● Ponteiros e
aritiméticos e Referências
relacionais ● Prática e Exercícios
● Prática e Exercícios
Computação Científica
Interpreta o código
Código fonte Executável
(*.c) (*.exe)
main()
{
// Comando para escrever em tela.
printf("Eu adoro programar em C");
}
●
Comentários no código com // ou /* */
● Acesso aos comandos declarando as bibliotecas
● Programa principal dentro do main()
Formato de edição livre (sensível à caixa)
● Escrever na tela: printf("Oi!"); Ponto e vírgula ao final do comando
Tipos e Operadores Básicos
● Tipos de variáveis
z = y + i*x → variáveis devem ser declaradas no código
● Reserva de espaço na memória RAM
Variáveis i e z declaradas e o espaço na memória é reservado
main()
{
int i; // Declaração de i como inteira
int j,k; /* Declaração de j e k como inteiros.
É possível declarar mais de uma
variável por linha */
int ii = 123; // Ao declarar ii, já atribuo um valor.
main()
{
char ch1,ch2;
printf("Entre com 1 caracter: ");
/* le um caracter do console sem mostra-lo */
ch1 = getch();
Brinquem à vontade!! :)
Tipos e Operadores Básicos
● Variáveis de Ponto Flutuante
● Precisão simples (6 casas decimais) float
● Precisão dupla (15 casas decimais) double
● Computação científica necessita de maior precisão.
● Uso de precisão dupla é mais usual.
● Detalhes na saída de tela.
#include<stdio.h>
|||2.500
Tipos e Operadores Básicos
● Variáveis de Ponto Flutuante
#include<stdio.h>
#include<math.h>
int main()
{
float pi_float;
double pi_double;
pi_float = acos(-1.);
pi_double= acos(-1.);
Execução do código:
Valor com precisao simples : 3.1415927410125732000 Qual destes valores é
Valor com precisao dupla : 3.1415926535897931000 mais confiável? Porque?
Tipos e Operadores Básicos
● Variáveis Booleanas
● Tipo bool, pode ser true ou false
#include<stdio.h>
main()
{
bool flag = true;
double d = 3.14;
CUIDADO!!
int m = 7;
bool b, c;
Sempre avaliado como true!!
b = 3 < m < 9; // b = true 1 (true) < 9
m = 20; 0 (false) < 9
c = 3 < m < 9; // c = true
if(condição)
{ // Executo um ou mais comandos aqui } Execução do else somente se
else
{ // Executo outros comandos aqui }
a condição for false
if(condição1)
{ // Executo bloco 1 de comandos }
Se a primeira condição
else if(condição2) for satisfeita, os testes de
{ // Executo bloco 2 de comandos } condição seguintes (e
else if(condição3)
{ // Executo bloco 3 de comandos } seus comandos) serão
else ignorados.
{ // Executo bloco 4 de comandos } Preste atenção!!
Fluxos de Controle
● Condicionais if-else if
// Usuário entra com T (em K)
printf("Entre com a temperatura da agua (K)");
scanf("%16le",&T); O que vai ler? Qual variável?
printf("\n");
for(i=0;i<n;i++)
{
// Processo será repetido n vezes
// Valor de i é atualizado a cada iteração
printf(“%d\n”,i);
}
int i,j;
long double b = 5.; 4 27
2
for(i=1;i<5;i++) 5∏ ∏ i j
for(j=27;j>=-3;j--) i=1 j=−3
b*=i+j*j;
do
comandos
while(condição)
stream = fopen(“NomeArquivo”,“Regra”);
fclose(stream);
int main()
{
FILE *fp;
char nomearq[40], nome[40];
int idade;
float altura;
/* Le o nome do arquivo na tela: */
printf("Entre o nome do arquivo: ");
gets(nomearq);
/* Abre o arquivo: */
fp = fopen(nomearq,"w");
/* Le os dados na tela e grava no arquivo: */
do
{
printf("Entre o nome, idade e altura: ");
scanf("%s %d %f", nome, &idade, &altura);
fprintf(fp, "%20s %5d %5.2f\n", nome, idade, altura);
} while(strlen(nome) > 1);
/* Fecha o arquivo: */
fclose(fp);
return(0);
}
Tipos Derivados
● Arrays – Vetores e Matrizes
● Sendo T uma variável declarada, T[n] é um array
unidimensional (vetor) de n elementos com o mesmo tipo de
T.
● Elementos são indexados de 0 até n-1 continuamente na
memória.
int n = 10;
double v[n];
Tipos Derivados
● Arrays – Vetores e Matrizes
int i,j;
float vec[3]; // array com 3 floats; vec[0], vec[1], vec[2]
int st[30]; // array com 30 ints; st[0], ... st[29]
vec[0] = 1.0;
vec[2] = 2.0;
for(i=0;i<30;i++) st[i]=i*i+7;
j = st[29];
O que acontece com vec[1]?
Foi alocado, mas não foi inicializado...
int i,j;
double mt[2][5]; // array 2D c/ 2 linhas e 5 colunas
mt[0][0] = 5.0;
mt[1][4] = 5.0;
for(i=0;i<2;i++)
{ for(j=0;j<5;j++)
{ mt[i][j] = i + j; }
}
Tipos Derivados
● Arrays – Vetores e Matrizes
● Podem ser inicializados na declaração
int v[] = {1, 2, 3, 4};
int a[3]= {2, 4, 5};
int u[][3] = { {1, 2, 3} , {4, 5, 8} };
char filename[30] = "output"; // Array de caracteres
... i j ...
*pi
int i = 5; // i é int, valor do objeto i é 5. (a)
int* pi=&i; // p é um ponteiro de um inteiro (b)
// e atribui o endereço de i a pi
int j = *pi; // valor da variável apontada por pi (c)
// é atribuído a j, j = 5;
double* = &j; // Ilegal!!
Tipos Derivados
● Ponteiros e Referência
double d1 = 2.7, d2 = 3.1; // (a)
double* p = &d1; // p aponta para d1, *p = 2.7 (b)
double a = *p; // a = 2.7
p = &d2; // p aponta para d2, *p = 3.1 (c)
double b = *p; // b = 3.1
*p = 5.5; // o valor para qual p aponta é 5.5 (d)
double c = *p; // c = 5.5
double d = d2; // d = 5.5, já que *p = 5.5
(a) .. d1 d2 .. (b) .. d d2 ..
. . . 1 .
*p
(c) .. d d2 .. (d) .. d d2 ..
. 1 . . 1 .
*p *p
5.1
Funções
● Evitar duplicidade de código
● Incorporar códigos de terceiros
● Flexibilidade de uso e legibilidade do código
Passagem de parâmetros
do programa principal
para a subrotina (e vice-
Programa versa) Subrotina
Principal
Considere a subrotina como um
outro mundo fora do programa
principal e você deve dizer a ela
quais variáveis ela deve conhecer