Вы находитесь на странице: 1из 10

RESUMÃO LINGUAGEM C

Autor: Everton M. Messias

O C nasceu na década 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 básico:

início

declare Nota1, Nota2, Media: numérico;

escreva(“Digite as duas notas”); leia(Nota1, Nota2); Media ← (Nota1 + Nota2)/2;

se Media ≥ 5

então escreva(“Aprovado”); senão escreva(“Reprovado”);

fim

Mapa de Memória de C: Um programa C compilado cria e usa quatro regiões de memória: O Código propriamente dito, as Variáveis Globais, a Pilha (variáveis locais e end. de funções) e o Heap (região de memória livre usada pelo programa para alocação dinâmica, listas e árvores)

C Versus C++ : C++ é um superconjunto de C , com orientação a objetos.

Variáveis : Um ou mais caracteres - números, letras (maiúsculas ou minúsculas) – É uma posição nomeada de memória que representa um valor. Se estiver fora de qualquer função é variável global.

Constantes : Valor fixo que não se modifica durante execução do programa.

Diretivas : Substitui toda ocorrência de um nome especificado por um valor determinado (constantes). Ex: #define PI 3.14159

um valor determinado (constantes). Ex: #define PI 3.14159 Obs: Hoje sistemas de 64bits tem 4bytes para

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

Operadores : Aritmético de atribuição .

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

Barras: \n – nova linha \0 – nulo \t – Operadores Relacionais : Saída: 0

Barras: \n – nova linha

\0 – nulo

\t –

Operadores Relacionais :

Saída: 0 = falso ; 1 = verdadeiro > Maior, >= Maior ou igual < Menor <= Menor ou igual, == igual (nota q 1 = é atribuição) ! = Diferente

Operadores Lógicos:

\a – beep … etc

! = Diferente Operadores Lógicos: \a – beep … etc Bibliotecas de Cabeçalho: Entrada e Saída

Bibliotecas de Cabeçalho:

! = Diferente Operadores Lógicos: \a – beep … etc Bibliotecas de Cabeçalho: Entrada e Saída

Entrada e Saída de Dados:

! = Diferente Operadores Lógicos: \a – beep … etc Bibliotecas de Cabeçalho: Entrada e Saída

Exemplo básico de entrada e saída de dados (I/O) :

#include <stdio.h>

#include <conio.h> /* Este programa usa conio.h e não 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”);

Condição:

if (condição) {

}

else {

}

switch (op) { case 1:

// repete blocos (case) conforme opção (op tem q ser char ou int)

#### break; // quebra loop

case 2:

 

####

break;

default:

 

####

}

Repetição:

while (condição) {

}

// testa e depois faz o loop

do {

}

// primeiro faz um loop e depois testa

while (condição);

for (cont=0; cont < 20; cont ++) {

}

// ( início ; condição ; incremento )

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

Vetores: São variáveis compostas homogêneas 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: São variáveis compostas homogêneas 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: Não 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 – não admite espaços ; gets e fgets admitem espaços e fazem a contagem até \0 Principais funções de manipulação 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

Struct : São variáveis compostas heterogêneas (com : int, char, float Struct aluno { char nome [30]; int idade;

}; struct aluno dados; //ou diretamente: struct aluno dados = {“Fulano”,38};

e outra struct).

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 variável 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

Variáveis ficam assim :

int idade == inteiro idade; struct aluno dados == gente dados (não 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;}

Funções: tipo nome (parametros) { conj de declarações e comandos }

Pode-se declarar antes ou depois do main() utilizando protótipos antes.

Pode-se passar parametros ou não: () ou (void).

Recursão: Uma funcão dentro da outra, como o printf dentro do main()

Ex1: // função 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 referência == 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 são passadas = vetor

Ex5: // passagem de campos da struct : pode ser por valor ou referência #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;}

Ex6: // passagem da struct inteira – tem q ser por referência. #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;}

Modularização : Arquivos de cabeçalho podem conter funções . Ex. # include “equacao2g.h”

Ponteiros : São variáveis cujo conteúdo é um endereço de memória. (int,char,float,struct,doble )

Inicializando

int *p = NULL; // ponteiro vazio int *p; // ponteiro para int char *pc; // ponteiro para char void *g; // ponteiro genérico – aponta para qualquer coisa

Ex1: Conteúdos #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: Operações (+ 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 precisão.

Ex3: Ponteiros genericos #include <stdio.h> main() { void *pp;

int p = 10; pp = &p; printf ("Conteudo: %d\n", *(int*)pp);}

// como é genérico tem q converter antes de exibir

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 nível é o valor

Alocação Dinâmica: 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 posições 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

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 posições

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 também aloca colocando zeros nas posições, MALLOC coloca lixo de mem. int *i = calloc (50,4); – 50 posições de 4bytes cada (porque decorei q int é 4bytes) char *c = calloc (30,1); – 30 posições de 1byte cada (porque decorei q char é 1byte) ou int *i = calloc (50,sizeof(int)); – sem decorar - 50 posições de 4bytes cada char *c = calloc (30,sizeof(char)); – sem decorar - 30 posições 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 posições

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 posições int de 4bytes int *p = realloc (v,400) – realoquei para 100 posições 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

Compilação 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] é próprio programa

No terminal do linux :

> gcc teste.c -o teste // compila

> ./teste everton

> 2 – everton

// executa o programa com o argumento everton

// resultados: argc=2 e argv[1]=everton pois argv[0]=teste

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 específico. Ex.:

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

FILE *ponteiro; ponteiro = fopen (nome_do_arquivo, modo) Principais funções para uso com arquivos: fopen() - Abre

Principais funções 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 espaço 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 gravação. 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}