Campus Alegrete
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas
Linguagem C
Índice
1. Algoritmos ...................................................................................................... 4
1.1. Introdução................................................................................................ 4
1.2. Representação de algoritmos .................................................................. 5
1.2.1. Pseudocódigo.................................................................................... 5
1.2.2. Diagrama de Fluxo de Dados............................................................ 6
1.2.3. Diagrama de Chapin ......................................................................... 7
1.3. Linguagens de Programação Interpretadas e Compiladas ...................... 7
2. Linguagem C .................................................................................................. 9
2.1. Histórico................................................................................................... 9
2.2. Bibliotecas e Cabeçalhos....................................................................... 10
2.3. Comentários .......................................................................................... 10
2.4. Bloco de Instruções ............................................................................... 11
3. Manipulação de Dados................................................................................. 11
3.1. Constantes............................................................................................. 11
3.2. Variáveis ................................................................................................ 12
3.3. Tipos de Dados...................................................................................... 12
4. Operadores .................................................................................................. 13
4.1. Operadores Aritméticos ......................................................................... 13
4.2. Operadores Aritméticos de Atribuição ................................................... 13
4.3. Operadores Relacionais ........................................................................ 13
4.4. Operadores Lógicos............................................................................... 14
4.5. Operadores de Incremento/Decremento................................................ 14
4.6. Precedência de Operadores .................................................................. 14
4.7. Exercícios de Fixação............................................................................ 14
5. Entrada/Saída .............................................................................................. 15
5.1. Introdução.............................................................................................. 15
5.2. Expressões de Controle......................................................................... 15
5.3. Códigos de Formatação......................................................................... 16
5.4. printf....................................................................................................... 16
5.4.1. Exercícios de Fixação ..................................................................... 18
5.5. scanf ...................................................................................................... 18
5.5.1. Exercícios de Fixação ..................................................................... 19
6. Algoritmo de Seleção ................................................................................... 21
6.1. Introdução.............................................................................................. 21
6.2. If – Else.................................................................................................. 21
6.2.1. Exercícios de Fixação ..................................................................... 23
6.3. Switch – Case........................................................................................ 24
6.3.1. Exercícios de Fixação ..................................................................... 25
7. Algoritmo de Repetição ................................................................................ 26
7.1. Introdução.............................................................................................. 26
7.2. While...................................................................................................... 26
1. Algoritmos
1.1. Introdução
1.2.1. Pseudocódigo
SÍNTESE
Objetivo: analisar a idade de uma pessoa
Entrada: uma idade
Saída: situação da maturidade da pessoa
DECLARAÇÕES
inteiro IDADE;
INÍCIO
escreva (“Informe sua idade: “);
leia (IDADE);
se (IDADE < 21) então
escreva (“você é jovem”);
senão
escreva (“você é adulto”);
fim_se;
FIM
Imagine uma situação onde a idade de uma pessoa deva ser analisada para
sua classificação em jovem ou adulto. O algoritmo a seguir é apresentado
graficamente por meio do fluxograma coerente com a solução desejada.
2. Linguagem C
2.1. Histórico
2.3. Comentários
/*
explicação ...
*/
Tudo que se encontrar entre /* e */ não será lido pelo compilador. Em C++,
que é uma linguagem posterior ao C que inclui orientação a objetos,
comentários também podem ser representados por // antes da explicação,
como:
// explicação ...
/* Programa 1 */ comentário
#include <stdio.h> biblioteca
#include <conio.h> biblioteca
main( ) função principal
{ inicio
.
.
<corpo do programa>
.
.
getch(); função que espera entrada por
teclado
} fim
3. Manipulação de Dados
Qualquer programa tem que fazer alguma coisa (nem que seja enviar um
sinal bip) senão não é um programa, ou seja, ele tem que apresentar conteúdo.
Assim, como apresenta conteúdo, vai “alterar” estados dentro do computador,
sendo que, o estado de uma das peças que vai inevitavelmente se alterar é a
memória interna.
É inevitável um programa utilizar a memória do computador, assim, o
programa precisa de um espaço físico na memória e para isso terá que o
requisitar.
Já realizamos abstrações desse tipo na matemática, pois uma variável é
uma expressão que varia e normalmente é representado por uma incógnita X,
e uma constante é uma expressão que não se altera (o número de Avogrado, o
Pi, o número de Neper) que pode ser representado por uma letra. Veremos a
seguir, que constantes e variáveis se comportam igualmente na computação.
3.1. Constantes
Exemplo:
PI = 3.1416;
3.2. Variáveis
Exemplo:
a = 3;
a = a + 2;
Porém, existem vários tipos de dados suportados pelo padrão ANSI C, que
são:
4. Operadores
Significado Símbolo
Atribuição =
Soma +
Subtração -
Multiplicação *
Divisão /
Resto %
Normal Reduzida
var = var + expr; var += expr;
var = var – expr; var -= expr;
var = var * expr; var *= expr;
var = var / expr; var /= expr;
Significado Símbolo
Maior >
Maior ou igual >=
Menor <
Menor ou igual <=
Igualdade ==
Diferença !=
Significado Símbolo
E &&
OU ||
Não !
1º parênteses e funções
2º potência e resto
3º multiplicação e divisão
4º adição e subtração
5º operadores relacionais
6º operadores lógicos
a) x =5*4/6+7
b) x =5*4%6+7
c) x = ((4 / 2) + (3 * 5))
d) x = (3 + 2 * (4 + (2+4))) % 2
5. Entrada/Saída
5.1. Introdução
Código Significado
%c Exibe um caractere
Código Significado
\n Nova linha
\t Tabulação
\b Retrocesso
\” Aspas
\\ Barra
\f Salta formulário
\0 Nulo
5.4. printf
/* Programa Ola_Mundo */
#include <stdio.h>
#include <conio.h>
main( )
{
printf(“\n Ola Mundo!”);
getch();
}
Podemos ver nesse exemplo que, utilizamos apenas uma função de escrita
para exibir uma frase na tela.
Outro exemplo mais completo que trata da soma entre duas constantes
pode ser visto abaixo:
/* Programa Soma_A_B */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
int b;
int c;
a = 2;
b = 3;
c = a + b;
printf(“\n A soma e: %d”, c);
getch();
}
n1 + n 2 + n3 + n 4 n1x10 + n 2 x 20 + n3 X 30 + n4 X 40
ma = mg =
4 100
1
mh =
1 1 1 1
+ + +
n1 n 2 n3 n 4
5.5. scanf
Para ler um item deve-se passar uma string que representa o formato da
entrada e os endereços das variáveis de destino. Essa string do formato pode
possuir caracteres normais que se espera na entrada e combinações especiais
usando o caractere % para representar os valores a serem lidos.
Na sintaxe:
scanf(“%d”, &a);
Notamos que o valor a ser lido é um valor inteiro devido ao %d dentro das
aspas, e esse valor será atribuído à variável a. O & (e comercial) indica que o
valor digitado será enviado para o endereço de memória da variável a.
Um exemplo completo da soma entre duas variáveis lidas através do scanf
pode ser visto abaixo:
/* Programa Ler_A_B_Somar */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
int b;
int c;
scanf(“%d”, &a);
scanf(“%d”, &b);
c = a + b;
printf(“\n A soma e: %d”, c);
getch();
}
6. Algoritmo de Seleção
6.1. Introdução
6.2. If – Else
/* Programa seleção_if */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
a = 10;
if (a >= 10)
{
printf(“\n Maior”);
}
getch();
}
Neste programa, a seleção com o comando if verifica se a variável a é
maior ou igual ao valor 10. Como o valor de a é igual a 10, torna a resposta
verdadeira, portanto o printf é executado escrevendo na tela a palavra ‘Maior’.
Quando existe apenas uma linha após o if, não precisamos abrir e fechar o
bloco condicional utilizando { e }, porém como usamos a função getch() no final
do programa, temos que abrir e fechar o bloco condicional pois poderia ser
entendido como parte integrante da condição.
Quando necessitamos exibir tanto uma resposta verdadeira quanto uma
resposta falsa, usamos o exemplo abaixo utilizando if -else:
/* Programa if_else */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
a = 10;
if(a > 10)
{
printf(“Maior”);
}
else
{
printf(“Menor ou igual”);
}
getch();
}
Neste caso, o programa escreve na tela o teste com a resposta falsa pois
recai na parte da condição do ‘senão’ (else). Lendo em português, a pergunta
da condição seria: ‘Se a é maior que 10 então escreva a palavra ‘Maior’, senão
(se a não for maior que 10) escreva as palavras ‘Menor ou igual’’.
Em um terceiro caso, a estrutura if – else possibilita condições aninhadas,
que são condições dentro de condições. Podemos ver no exemplo abaixo:
/* Programa if_else_aninhado */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
a = 7;
if(a <= 4)
{
printf(“Reprovado”);
}
else
if((a > 4) && (a < 7))
{
printf(“Recuperação”);
}
else
{
printf(“Aprovado”);
}
getch();
}
que 7, e a terceira condição (apenas o senão, pois não precisa ter uma
condição a mais) para valores que não se encaixam nas condições anteriores,
ou seja, igual ou maior que 7.
/* Programa switch-case */
#include <stdio.h>
#include <conio.h>
main( )
{
int num;
printf("Digite numero (1 ou 2 apenas): ");
scanf("%d", &num);
switch(num)
{
case 1: printf("\nSolteiro"); break;
case 2: printf("\nCasado"); break;
default: printf("\nNumero invalido");
}
getch();
}
7. Algoritmo de Repetição
7.1. Introdução
7.2. While
/* Programa while */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
a = 1;
while(a <= 100)
{
printf("\n %d", a);
a++;
}
getch();
}
7.3. For
/* Programa for */
#include <stdio.h>
#include <conio.h>
main( )
{
int a;
for(a = 1; a <= 100; a++)
{
printf("\n %d", a);
}
getch();
8. Vetores
8.1. Introdução
Onde tipo é um tipo qualquer dados, nome é o nome pelo qual o vetor vai
ser referenciado e tamanho é o número de elementos que o vetor vai conter.
Observar que, em C, o primeiro elemento tem índice 0 e o último tamanho - 1.
Exemplos de declarações de vetores são:
/* Programa vetor_int */
#include <stdio.h>
#include <conio.h>
main( )
{
int dados[3];
dados[0] = 3;
dados[1] = 9;
dados[2] = 6;
printf("%d", dados[1]);
getch();
}
9. Matrizes
9.1. Introdução
/* Programa matriz */
#include <stdio.h>
#include <conio.h>
main( )
{
int x, y, cont, num[3][3];
cont = 1;
x = 0;
y = 0;
while(x < 3)
{
while(y < 3)
{
num[x][y] = cont;
cont++;
y++;
}
y = 0;
x++;
}
x = 0;
y = 0;
while(x < 3)
{
while(y < 3)
{
printf("%d", num[x][y]);
y++;
}
printf("\n");
y = 0;
x++;
}
getch();
}
1 2 3
4 5 6
7 8 9
10. Strings
10.1. Introdução
/* Programa vetor_string */
#include <string.h>
#include <stdio.h>
#include <conio.h>
main( )
{
char nome[5];
printf("Digite nome: ");
gets(nome);
printf("%c", nome[2]);
getch();
}
#include <stdio.h>
#include <conio.h>
main()
{
char nome[] = {'f', 'a', 'b', 'i', 'o'};
printf("%c", nome[4]);
getch();
}
11.1. Introdução
/* Programa struct */
#include <stdio.h>
#include <conio.h>
main()
{
struct {
char Primeiro[15];
char Meio[15];
char Sobrenome[15];
} Nome;
printf("Digite seu primeiro nome: ");
scanf("%s", &Nome.Primeiro);
printf("Digite seu nome do meio: ");
scanf("%s", &Nome.Meio);
printf("Digite seu sobrenome: ");
scanf("%s", &Nome.Sobrenome);
printf("\nNome completo: %s %s %s", Nome.Primeiro, Nome.Meio,
Nome.Sobrenome);
getch();
}
12. Ponteiros
O ponteiro nada mais é do que uma variável que guarda o endereço de uma
outra variável.
12.1. Introdução
int *pa
*pa = 20;
Desta forma estamos atribuindo o valor 24 para a variável que está contida
no ponteiro. Para entender melhor quando e como utilizar os operadores (*) e
(&), veja o programa mostrado abaixo:
/* Programa ponteiro */
#include <stdio.h>
#include <conio.h>
main()
{
int a, b;
int *pa, *pb;
a = 20;
b = 12;
pa = &a;
pb = &b;
printf("\nEndereco do ponteiro pa: %u", pa);
printf("\nEndereco da variavel contida no ponteiro pa: %u", &pa);
printf("\nValor da variavel contida no ponteiro pa: %d", *pa);
printf("\nEndereco do ponteiro pb: %u", pb);
printf("\nEndereco da variavel contida no ponteiro pb: %u", &pb);
printf("\nValor da variavel contida no ponteiro pb: %d", *pb);
getch();
}
13. Funções
13.1. Introdução
/* Programa funcao */
#include <stdio.h>
#include <conio.h>
int total;
main()
{
int n, m;
n = 3;
m = 6;
soma(n, m);
printf("A soma e: %d", total);
getch();
}
Podemos notar que a função soma é escrita antes da função principal main,
pois quando é chamada na função main o compilador já deve ter lido a função.
Notamos também que a variável total a qual o valor será retornado (return),
está declarada fora da função main e fora da função soma. Isso se deve as
variáveis só poder ser lidas dentro de sua própria função. Declarando-a fora,
ela se torna uma variável externa e pode ser lida em qualquer parte do código.
Ainda, quando enviamos os valores a ser somados pela função main, as
variáveis são n e m, porém quando são processadas pela função soma, as
variáveis são num1 e num2, isso é irrelevante pois os valores são passados de
uma para outra.
14. Arquivos
14.1. Introdução
FILE *arqFonte;
Caso o arquivo não possa ser aberto, a função fopen retorna o ponteiro
nulo. Assim, para verificar de o arquivo foi aberto sem problemas, é necessário
testar o valor de retorno:
if (arqFonte != 0)
{
/* tudo bem */
}
else
{
/* erro */
}
/* Programa cria_arq */
#include <stdio.h>
#include <conio.h>
main()
{
FILE *fp;
fp = fopen ("teste.txt", "w");
if (fp == NULL)
{
printf ("Houve um erro ao abrir o arquivo.\n");
}
printf ("Arquivo teste.txt criado com sucesso.\n");
fclose (fp);
getch();
}
Podemos ver que foi criado um ponteiro do tipo FILE para fp. fp recebe a
abertura do arquivo chamado teste.txt em modo de escrita (w). É realizado
um teste para confirmar se o arquivo foi criado. Por último, o arquivo é fechado
com fclose se criado com sucesso.
Vimos como criar um arquivo texto, agora veremos como escrever uma
string nesse arquivo. O exemplo abaixo faz isso:
/* Programa arq_escrever */
#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <stdlib.h>
main()
{
FILE *pf;
char palavra[30];
if((pf = fopen("arquivo.txt","w")) == NULL)
{
printf("\nNao consigo abrir o arquivo ! ");
exit(1);
}
while (strlen(palavra) > 1)
{
printf("\nDigite uma nova palavra: ");
gets(palavra);
fputs(palavra, pf);
putc('\n', pf);
if(ferror(pf))
{
perror("Erro na gravacao");
fclose(pf);
exit(1);
}
}
fclose(pf);
}
/* Programa arq_ler */
#include <stdio.h>
#include <conio.h>
main()
{
FILE *pf;
char palavra[30];
pf = fopen("arquivo.txt", "r");
while(fgets(palavra, 30, pf) != NULL)
{
printf("%s", palavra);
}
fclose(pf);
getch();
}
Bibliografia
Lista de Recursos:
Suporte a compiladores baseados em GCC.
Depuração integrada (usando GDB).
Navegador de classes.
Recurso de completar códigos.
Navegador de depuração de variáveis.
Gerenciador de Projetos.
Editor com destaque de sintaxe personalizável.
Suporte a modelos para criação dos seus próprios projetos.
Edição e compilação de arquivos de recursos.
Gerenciador de Ferramentas.
Suporte a impressão.
Facilidades de encontrar e substituir.
Gerenciador de pacotes para facilitar a instalação e adição de
bibliotecas.
Suporte CVS.
Lista de coisas a fazer.
Janela de CPU.
Nesta tela devemos clicar em no menu File -> New -> Source File para
podermos escrever um novo código-fonte. Também podemos usar o
mnemônico Ctrl + N ou clicar no 3º botão da barra Main. Quando fizermos essa
operação, abrirá no compilador uma área onde poderemos escrever nossos
programas como na tela abaixo:
stdio.h
Stream properties
Streams have some properties that define which functions can be used on
them and how these will treat the data input or output through them. Most of
these properties are defined at the moment the stream is associated with a file
(opened) using the fopen function:
Read/Write Access
Specifies whether the stream has read or write access (or both) to the
physical media they are associated with.
Text / Binary
Text streams are thought to represent a set of text lines, each one ending
with a new-line character. Depending on the environment where the application
is run some character translation may occur with text streams to adapt some
special characters to the text file specifications of the environment. A binary
stream, on the other hand, is a sequence of characters written or read from the
physical media with no translation, having a one-to-one correspondence with
the characters read or written to the stream.
Buffer
A buffer is a block of memory where data is accumulated before being
physically read or written to the associated file or device. Streams can be either
fully buffered, line buffered or unbuffered. On fully buffered streams, data is
read/written when the buffer is filled, on line buffered streams this happens
when a new-line character is encountered, and on unbuffered streams
characters are intended to be read/written as soon as possible.
Indicators
Streams have certain internal indicators that specify their current state and
which affect the behavior of some input and output operations performed on
them:
Error indicator
This indicator is set when an error has occurred in an operation related to
the stream. This indicator can be checked with the ferror function, and can be
reset by calling either to clearerr or to any repositioning function (rewind, fseek
and fsetpos).
End-Of-File indicator
When set, indicates that the last reading or writing operation performed
with the stream reached the End of File. It can be checked with the feof
function, and can be reset by calling either to clearerr or to any repositioning
function (rewind, fseek and fsetpos).
Position indicator
It is an internal pointer of each stream which points to the next character
to be read or written in the next I/O operation. Its value can be obtained by the
ftell and fgetpos functions, and can be changed using the repositioning
functions rewind, fseek and fsetpos.
Functions
Operations on files:
remove Remove file (function)
rename Rename file (function)
tmpfile Open a temporary file (function)
tmpnam Generate temporary filename (function)
File access:
fclose Close file (function)
fflush Flush stream (function)
fopen Open file (function)
freopen Reopen stream with different file or mode (function)
setbuf Set stream buffer (function)
setvbuf Change stream buffering (function)
Formatted input/output:
fprintf Write formatted output to stream (function)
fscanf Read formatted data from stream (function)
printf Print formatted data to stdout (function)
scanf Read formatted data from stdin (function)
sprintf Write formatted data to string (function)
sscanf Read formatted data from string (function)
vfprintf Write formatted variable argument list to stream (function)
vprintf Print formatted variable argument list to stdout (function)
vsprintf Print formatted variable argument list to string (function)
Character input/output:
fgetc Get character from stream (function)
fgets Get string from stream (function)
Direct input/output:
fread Read block of data from stream (function)
fwrite Write block of data to stream (function)
File positioning:
fgetpos Get current position in stream (function)
fseek Reposition stream position indicator (function)
fsetpos Set position indicator of stream (function)
ftell Get current position in stream (function)
rewind Set position indicator to the beginning (function)
Error-handling:
clearerr Clear error indicators (function)
feof Check End-of-File indicator (function)
ferror Check error indicator (function)
perror Print error message (function)
Macros
EOF End-of-File (constant)
FILENAME_MAX Maximum length of file names (constant)
NULL Null pointer (constant)
TMP_MAX Number of temporary files (constant)
Types
FILE Object containing information to control a stream (type)
fpos_t Object containing information to specify a position within a file
(type)
size_t Unsigned integral type (type)
string.h
Functions
Copying:
memcpy Copy block of memory (function)
memmove Move block of memory (function)
strcpy Copy string (function)
strncpy Copy characters from string (function)
Concatenation:
strcat Concatenate strings (function)
strncat Append characters from string (function)
Comparison:
memcmp Compare two blocks of memory (function)
strcmp Compare two strings (function)
strcoll Compare two strings using locale (function)
strncmp Compare characters of two strings (function)
strxfrm Transform string using locale (function)
Searching:
memchr Locate character in block of memory (function)
strchr Locate first occurrence of character in string (function)
strcspn Get span until character in string (function)
strpbrk Locate character in string (function)
strrchr Locate last occurrence of character in string (function)
strspn Get span of character set in string (function)
strstr Locate substring (function)
strtok Split string into tokens (function)
Other:
memset Fill block of memory (function)
strerror Get pointer to error message string (function)
strlen Get string length (function)
Macros
NULL Null pointer (macro)
Types
size_t Unsigned integral type (type)
stdlib.h
Functions
String conversion:
atof Convert string to double (function)
atoi Convert string to integer (function)
atol Convert string to long integer (function)
strtod Convert string to double (function)
strtol Convert string to long integer (function)
strtoul Convert string to unsigned long integer (function)
Environment:
abort Abort current process (function)
atexit Set function to be executed on exit (function)
exit Terminate calling process (function)
getenv Get environment string (function)
system Execute system command (function)
Integer arithmethics:
abs Absolute value (function)
div Integral division (function)
labs Absolute value (function)
ldiv Integral division (function)
Multibyte characters:
mblen Get length of multibyte character (function)
mbtowc Convert multibyte character to wide character (function)
wctomb Convert wide character to multibyte character (function)
Multibyte strings:
mbstowcs Convert multibyte string to wide-character string (function)
wcstombs Convert wide-character string to multibyte string (function)
Macros
EXIT_FAILURE Failure termination code (macro)
EXIT_SUCCESS Success termination code (macro)
MB_CUR_MAX Maximum size of multibyte characters (macro)
NULL Null pointer (macro)
Types
div_t Structure returned by div (type)
ldiv_t Structure returned by div and ldiv (type)
size_t Unsigned integral type (type)
math.h
Trigonometric functions:
cos Compute cosine (function)
sin Compute sine (function)
tan Compute tangent (function)
acos Compute arc cosine (function)
asin Compute arc sine (function)
atan Compute arc tangent (function)
atan2 Compute arc tangent with two parameters (function)
Hyperbolic functions:
cosh Compute hyperbolic cosine (function)
sinh Compute hyperbolic sine (function)
tanh Compute hyperbolic tangent (function)
Power functions
pow Raise to power (function)
sqrt Compute square root (function)
time.h
C Time Library. This header file contains definitions of functions to get and
manipulate date and time information.
Functions
Time manipulation
clock Clock program (function)
difftime Return difference between two times (function)
mktime Convert tm structure to time_t (function)
time Get current time (function)
Conversion:
asctime Convert tm structure to string (function)
ctime Convert time_t value to string (function)
gmtime Convert time_t to tm as UTC time (function)
localtime Convert time_t to tm as local time (function)
strftime Format time to string (function)
Macros
CLOCKS_PER_SEC Clock ticks per second (macro)
NULL Null pointer (macro)
Types
clock_t Clock type (type)
size_t Unsigned integral type (type)
time_t Time type (type)
struct tm Time structure (type)