Você está na página 1de 10

RESUMO LINGUAGEM C

Autor: Everton M. Messias

O C nasceu na dcada de 70. Seu inventor, Dennis Ritchie, implementou-o pela primeira vez
usando um DEC PDP-11 rodando o sistema operacional UNIX. O C derivado de uma outra
linguagem: o B, criado por Ken Thompson. O B, por sua vez, veio da linguagem BCPL, inventada
por Martin Richards. O ANSI C o C padronizado pela ANSI.

Ex. de Algoritmo bsico:


incio
declare Nota1, Nota2, Media: numrico;
escreva(Digite as duas notas);
leia(Nota1, Nota2);
Media (Nota1 + Nota2)/2;
se Media 5
ento escreva(Aprovado);
seno escreva(Reprovado);
fim

Mapa de Memria de C: Um programa C compilado cria e usa quatro regies de memria: O


Cdigo propriamente dito, as Variveis Globais, a Pilha (variveis locais e end. de funes) e o
Heap (regio de memria livre usada pelo programa para alocao dinmica, listas e rvores)

C Versus C++ : C++ um superconjunto de C , com orientao a objetos.

Variveis : Um ou mais caracteres - nmeros, letras (maisculas ou minsculas) uma posio


nomeada de memria que representa um valor. Se estiver fora de qualquer funo varivel
global.

Constantes : Valor fixo que no se modifica durante execuo do programa.

Diretivas : Substitui toda ocorrncia de um nome especificado por um valor determinado


(constantes). Ex: #define PI 3.14159

Obs: Hoje sistemas de 64bits tem 4bytes para int ou float, diferem apenas na preciso.

Operadores : Aritmtico de atribuio .


Ex.
x++ ; incremento de 1 . x-- decremento de 1 (ou ++x . --x ; o mesmo efeito x=x+1)
i += 2; equivale a i = i + 2
x *= y + 1 equivale a x = x (y + 1)
t /= 2.5; equivale a t = t/2.5
p %= 5; equivale a p = p % 5

1
Barras: \n nova linha ... \0 nulo ... \t tab. ... \a beep etc ...

Operadores Relacionais :
Sada: 0 = falso ; 1 = verdadeiro
> Maior,
>= Maior ou igual
< Menor
<= Menor ou igual,
== igual (nota q 1 = atribuio)
! = Diferente

Operadores Lgicos:

Bibliotecas de Cabealho:

Entrada e Sada de Dados:

2
Exemplo bsico de entrada e sada de dados (I/O) :

#include <stdio.h>
#include <conio.h> /* Este programa usa conio.h e no funciona no Unix */
int main ()
{
char letra;
letra=getch(); // No Unix usar: scanf("%c", & letra). Desvantagem; tem q pressionar <ENTER>
printf ("Voce pressionou a tecla %c",letra);
}

Operador ? : Exp1 ? Exp2 : Exp3; ==> V:F


Ex : x=10;
y = x>9 ? 100 : 200 // y recebe 100 pois x>9 verdadeiro
(x>9) ? printf (verdadeiro) : printf (falso);

Condio:

if (condio) {
}
else {
}

switch (op) { // repete blocos (case) conforme opo (op tem q ser char ou int)
case 1:
####
break; // quebra loop
case 2:
####
break;
default:
####
}

Repetio:

while (condio) { // testa e depois faz o loop..


}

do { // primeiro faz um loop e depois testa..


}
while (condio);

for (cont=0; cont < 20; cont ++) { // ( incio ; condio ; incremento )
}

goto use apenas em ltimo caso Ex.: REFAZ: ###; goto REFAZ;

3
Vetores: So variveis compostas homogneas unidimensionais (seu nome seu end) . Ex:

int notas[5]; // cinco elementos inteiros ( contados de 0 at 4)

int vetor[5] = {0,1, 2, 3, 4};

for (i=0; i<5; i++){ printf ("Digite um valor:"); scanf ("%d", &valores[i]); }

Matrizes: So variveis compostas homogneas bidimensionais ( Linha x Coluna ).

int matriz[2] [3] = {0,1,2,3,4,5} == {{0,1,2} , {3,4,5}} ; // numeros das colunas

# include <stdio.h>
main()
{
int L,C,matriz[2][3];
for (L=0;L<2;L++){
for (C=0;C<3;C++){
printf ("Digite um valor:");
scanf ("%d",& matriz[L][C]);}}

for (L=0;L<2;L++){
for (C=0;C<3;C++){
printf ("%d ", matriz[L][C]);}printf ("\n");}
}

Strings: No existe na linguagem C um tipo de dado string . Utiliza-se um vetor de caracteres


(tipo char) que termina com um caractere de controle \0 (colocado pelo
compilador). Ex: char nome[8]={ 'e' , 'v' , 'e' , 'r' , 't' , 'o' , 'n' }; ou char nome[8] = everton; //+facil

# include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
char string[100];
printf ("\nDigite um nome completo: ");
scanf ("%s", string);
printf ("\nImprimindo com scanf ==> %s ",string);
__fpurge(stdin); // LIMPAR O BUFFER; para windows use: fflush(stdin);
printf ("\n\nDigite outro nome completo: ");
fgets (string,100,stdin); // simplesmente: gets (string); para windows
printf ("\nImprimindo com fgets ==> %s",string); }
Obs.: scanf no admite espaos ; gets e fgets admitem espaos e fazem a contagem at \0
Principais funes de manipulao definidas em string.h

Biblioteca string.h

strcpy (destino,origem) copia


strcat (destino,origem) anexa no fim da destino
strlen (palavra) tamanho da string
strcmp (palavra1,palavra2) compara , se forem iguais retorna 0

4
Struct : So variveis compostas heterogneas (com : int, char, float... e outra struct).
Struct aluno {
char nome [30];
int idade;
};
struct aluno dados; //ou diretamente: struct aluno dados = {Fulano,38};

OBS: So pode atribuir dados1 = dados se for estrutura igual, isto : struct aluno

Ex. struct com array

# include <stdio.h>
# include <stdlib.h>
# define MAX 2 // vetor com MAX campos

struct aluno { // estrutura tipo aluno com campos nome e idade


char nome [30];
int idade;
};

main() {
struct aluno dado[MAX]; // declarando varivel dado[MAX] do TIPO struct aluno
int i;
for (i=0;i<MAX;i++){
fflush(stdin);
printf ("\nDigite o nome do aluno %d : ", i+1);
gets (dado[i].nome);
printf ("\nDigite a idade do aluno %d : ", i+1);
scanf ("%d", & dado[i].idade); }
printf ("\n\nLISTA DE ALUNOS\n\n");
for (i=0;i<MAX;i++){
printf ("%s : %d anos\n", dado[i].nome,dado[i].idade); }
printf ("\n");
system ("pause");
return 0; }

typedef: Define apelidos aos tipos (struct, int, char, float, etc). Ex

typedef int inteiro;


typedef struct aluno gente

Variveis ficam assim :

int idade == inteiro idade;


struct aluno dados == gente dados (no pecisa mais escrever struct aluno)

enum: Lista de identificadores q transformam quaquer coisa pra ser atribuido Ex.

Ex.:
# include <stdio.h>
enum escapes {retrocesso='\b',tabulacao='\t',novalinha='\n'};
main(){
enum escapes e = novalinha;
printf ("Everton%cMendes%cMessias%c",e,e,e);
system ("pause");return 0;}

5
Funes: tipo nome (parametros) { conj de declaraes e comandos }
Pode-se declarar antes ou depois do main() utilizando prottipos antes.
Pode-se passar parametros ou no: () ou (void).
Recurso: Uma funco dentro da outra, como o printf dentro do main() ...

Ex1: // funo recursiva (empilhar chamadas e desempilhar resultados) pausa uma e exec outra
# include <stdio.h>
int fatorial (int n) {
if (n == 0)return 1;
else return n*fatorial(n-1);}
main(){
int numero,resposta;
printf ("\nDigite um numero: ");
scanf ("%d", & numero);
resposta=fatorial(numero);
printf ("\nA resposta eh: %d: \n\n",resposta);
system ("pause");return 0;}

Ex2: // passagem por valor , == printf


float temperatura (float fahrenheit ) {
float celsius
celsius = (( fahrenheit -32)*5)/9;
return celsius ;
}

Ex3: // por referncia == scanf


void equacao2g (float a, float b, float c, float *x1, float *x2) {
float delta;
delta=(b*b)-(4*a*c);
*x1=(((-1)*b)+(sqrt(delta)))/(2*a);
*x2=(((-1)*b)-(sqrt(delta)))/(2*a); }

Ex4: // passagem de vetores == scanf sem & (como na string pois o nome do vetor o end dele)
#include <stdio.h>
void imprime (int *v, int tamanho) { // tem q indicar o tamanho do vetor
int i;
for (i=0;i<tamanho;i++)
printf ("%d \n",v[i]);} // nao precisa do * pois o vetor ja ponteiro
int main () {
int v[5] = {1,2,3,4,5};
imprime (v,5); // nao precisa do & mas indicar o tamanho do vetor
system ("pause");
return 0;}

//OBS: matriz (int m[L] [C] , int Linhas) // tem q indicar as colunas, as Linhas so passadas = vetor

Ex5: // passagem de campos da struct : pode ser por valor ou referncia


#include <stdio.h>
struct ponto{int x,y;};
void imprime (int *n ,int *m) {printf ("Valores = %d , %d \n" ,*n ,*m);}
int main () {
struct ponto p1 = {10,20};
imprime (&p1.x , &p1.y);
system ("pause");return 0;}

6
Ex6: // passagem da struct inteira tem q ser por referncia.
#include <stdio.h>
struct ponto{int x,y;};
void atribui (struct ponto *p) { // passada a struct inteira
(*p).x = 10; p->y = 20;} // tem q ser (*p).x ou p->x pois s agora est acessando os campos
int main () {
struct ponto p1;
atribui(&p1); // passa a struct inteira pela variavel
printf ("x = %d ; y = %d\n",p1.x,p1.y);
system ("pause");
return 0;}

Modularizao : Arquivos de cabealho podem conter funes . Ex. # include equacao2g.h

Ponteiros : So variveis cujo contedo um endereo de memria. (int,char,float,struct,doble..)

Inicializando
int *p = NULL; // ponteiro vazio
int *p; // ponteiro para int
char *pc; // ponteiro para char
void *g; // ponteiro genrico aponta para qualquer coisa

Ex1: Contedos
#include <stdio.h>
int main() {
int x=10,*p=NULL;
p = &x;
printf ("x = %d\n",x); // 10, o valor em x
printf ("*p = %d\n",*p); // 10 , aponta para o end de x que contem 10
printf ("&x = %d\n",&x); // 2293532, o end de x
printf ("p = %d\n",p); // 2293532, o end de x pois ele recebeu o end de x
printf ("&p = %d\n",&p); } // 2293528 o end do ponteiro ==> 4 bytes menos pois inteiro

Ex2: Operaes (+ ou -)
#include <stdio.h>
main() {
float x = 10 , *p;
p = &x;
printf ("p = %d\n",p); // 2293528
p++; // somou 4bytes, como no inteiros, veja :
printf ("p = %d\n",p); // 2293532
}// hoje, sistemas de 64bits tem 4bytes para int ou float, difere apenas na preciso.

Ex3: Ponteiros genericos


#include <stdio.h>
main() {
void *pp;
int p = 10;
pp = &p;
printf ("Conteudo: %d\n", *(int*)pp);}
// como genrico tem q converter antes de exibir

7
Ex4: Ponteiros e vetores.
#include <stdio.h>
main() {
int i, *p, vet[5] = {1,2,3,4,5};
p = vet; // nao precisa colocar & pois o nome do vetor seu end
for (i=0;i<5;i++){
printf ("%d\n", p[i]); // ou
printf ("%d\n", *(p+i));}}

//Obs.: *v = 33; o mesmo que v[0] = 33; *(v+2) = 44; o mesmo que v[2] = 44;
//Obs2.: int *vet[x] um vetor de ponteiros

Ex5.: Ponteiros para Ponteiros


#include <stdio.h>
main() {
int x=10,*p=&x,**p2=&p;
printf ("p2 : %d\n", p2);// &p
printf ("*p2 : %d\n",*p2); //&x
printf ("**p2 : %d\n",**p2);} //x

//OBS.: O ultimo nvel o valor ...

Alocao Dinmica: Antes associamos o nome do vetor a um ponteiro, agora associaremos um


ponteiro a um vetor de tamanho indefinido

SIZEOF retorna o tamanho de um tipo

Ex1.:
# include <stdio.h>
int main() {
int x = sizeof (int);
printf ("x = %d\n",x);} // x = 4bytes

Ex2.: Tamanho dos dados


# include <stdio.h>
struct s {int x,y,z,w;};
main() {
printf ("char = %d\n",sizeof (char)); // 1 byte
printf ("int = %d\n",sizeof (int)); // 4 bytes
printf ("float = %d\n",sizeof (float)); // 4 bytes
printf ("double = %d\n",sizeof (double)); // 8 bytes
printf ("struct = %d\n",sizeof (struct s)); // 4*4 = 16 bytes}

MALLOC Memoria alloc ; se der erro ele retorna NULL

Forma 1: int *v = (int*) malloc (200); - cria um vetor de inteiros de 50 posies pois 200/4=50
Forma 2: int v = (int*) malloc (50 * sizeof(int)); - aqui o sizeof conta os bytes do tipo

Ex3.:
# include <stdio.h>
main() {
char *c = (char*) malloc(50 * sizeof(char)); // 50 * tamanho char = 50bytes
int *i = (int*) malloc(50 * sizeof(int));} // 50 * tamanho int = 200bytes

8
Ex4.:
# include <stdio.h>
# define T 5 // esse valor pode ser pedido em scanf
main() {
int *p , i;
p = (int*) malloc(T * sizeof(int)); // criando um vetor de T posies
if (p==NULL){printf ("ERRO");exit(1);} // se der erro sai fora
for (i=0;i<T;i++){printf ("Digite o num %d : ", i+1); scanf ("%d", &p[i]);} // tratando o vetor
free(p);} // liberando memoriano final

CALLOC semelhante ao MALLOC s q identifica quantidade e tamanho de cada um;

OBS.: O CALLOC tambm aloca colocando zeros nas posies, MALLOC coloca lixo de mem.
int *i = calloc (50,4); 50 posies de 4bytes cada (porque decorei q int 4bytes)
char *c = calloc (30,1); 30 posies de 1byte cada (porque decorei q char 1byte)
ou
int *i = calloc (50,sizeof(int)); sem decorar - 50 posies de 4bytes cada
char *c = calloc (30,sizeof(char)); sem decorar - 30 posies de 1byte cada

Ex5.:
# include <stdio.h>
# define T 5 // esse valor pode ser pedido em scanf
main() {
int i;
int *p = calloc(T,sizeof(int)); // criando um vetor de T posies
if (p==NULL){printf ("ERRO");exit(1);} // se der erro sai fora
for (i=0;i<T;i++){printf ("Digite o num %d : ", i+1); scanf ("%d", &p[i]);} // tratando o vetor
free(p);} // liberando memoriano final

REALLOC realoca um ponteiro previamente criado.

int *p = malloc (200) 50 posies int de 4bytes


int *p = realloc (v,400) realoquei para 100 posies int de 4bytes

OBS:
int *p = malloc(50*sizeof(int)) == int p = calloc(50,sizeof(int)) == int *p = realloc(null, 50*sizeof(int));
int *p = realloc (p,0) == free (p)

MATRIZES:
Ex.: int **p = malloc (N * sizeof(int*));
for (i=0;i<N;i++) { p[i] = malloc(N * sizeof(int)); // matriz quadrada pois N== C e L

Compilao via linha de comando & argumentos no main() :

Ex1: teste.c

# include <stdio.h>
main(int argc, char *argv[])
{ printf ("%d - %s\n", argc, argv[1]); }// argv[0] prprio programa ...

No terminal do linux :
> gcc teste.c -o teste // compila
> ./teste everton // executa o programa com o argumento everton
> 2 everton // resultados: argc=2 e argv[1]=everton pois argv[0]=teste

9
Ex. 2:
# include <stdio.h>
main(int argc, char *argv[]){
int mes;
char*nomemes[]={"Janeiro","Fevereiro","Marco","Abril","Maio","Junho","Julho","Agosto","Setembro
","Outubro","Novembro","Dezembro"};
if (argc == 4){ // testa a qdade de parametros esta OK ,, o 1o o proprio programa
mes=atoi(argv[2]); // transforma a string argv em int
if (mes<1 || mes>12){ printf ("Mes invalido");}
else { printf ("\n\n%s de %s de 19%s\n\n", argv[1], nomemes[mes-1],argv[3]);}
}else { printf ("Erro devido a qdade de argumentos"); }}
TESTE > gcc arquivo.c -o programa > ./programa 25 5 76 > 25 de Maio de 1976

Arquivos: Para trabalhar com arquivos, C precisa de um ponteiro especfico. Ex.:

FILE *ponteiro;
ponteiro = fopen (nome_do_arquivo, modo)

Principais funes para uso com arquivos:

fopen() - Abre um arquivo.


fclose() - Fecha um arquivo.

fprintf() - Escreve uma string num arquivo.


fputs () - Escreve uma string num arquivo.

fscanf() - Le uma string num arquivo ate encontrar um espao em branco.


fgets () - Le uma string num arquivo .
feof() - Indica o fim de um arquivo.

Ex 1 .:
#include <stdio.h>
int main(){
FILE *ponteiro; // declara um ponteiro do tipo FILE
ponteiro = fopen ("lista_alunos.txt", "wt"); // CRIA um arquivo txt para gravao.
ponteiro = fopen ("lista_alunos.txt", "at"); // Abre um arquivo para gravar no final.
char aluno[]={"Everton RA xxxxxx\n"};
fprintf (ponteiro, "%s", aluno); // escreve a string no ponteiro
fputs (aluno,ponteiro); // escreve a string aluno no ponteiro.
fclose (ponteiro); // fecha}

10