fui fazendo para aprender. Na época de uma internete discada exemplos assim
eram difíceis e encontrar. Ainda mais quando não se sabia Inglês.
Espero que ainda possa servir à alguem.
1 - imprime de 1 a té 100 ------------------------------------------- numeros.cpp
2 - tabuada de um numero -------------------------------------------- tabuada.cpp
3 - indica se é jovem, adulto ou idoso -------------------------------- idade.cpp
4 - fatorial do numero -------------------------------------------- fatorial1.cpp
5 - fatorial do numero usando a RECURSIVIDADE --------------------- fatorial2.cpp
6 - Triangulo / da a classificacao do triangulo ------------------- trinagulo.cpp
7 - PONTEIROS STDARG / va_list --------------------------------------- stdarg.cpp
8 - SWITCH e CASE ------------------------------------------------------ case.cpp
9 - DECLARANDO FUNCOES1 --------------------------------------------- funcao1.cpp
10- DECLARANDO FUNCOES2 --------------------------------------------- funcao2.cpp
11- DECLARANDO FUNCOES3 --------------------------------------------- funcao3.cpp
12- uso de "IF" ------------------------------------------------------ ifelse.cpp
13- WHILE / Pede o numero 100 para devolver comando -------------------- qual.cpp
14- BREAK / Inerronpendo loop FOR com o uso de BREAK ------------------ break.cpp
15- CONTINUE ------------------------------------------------------- continue.cpp
16- GOTO --------------------------------------------------------------- goto.cpp
17- DO WHILE, BREAK e (SWITCH e CASE) ------------------------------- acumula.cpp
18- CHAR, SCANF e WHILE ----------------------------------------------- scanf.cpp
19- STR-INGS ( strlen - strcpy - strcat ) ------------------------------- str.cpp
20- MATRIZ / Declarando matriz -------------------------------------- matriz1.cpp
21- MATRIZ DECLARADA PELO USUARIO ----------------------------------- matriz2.cpp
22- MATRIZ EM UMA TABUADA ------------------------------------------- matriz3.cpp
23- imprime o menor numero de uma matriz ------------------------------ menor.cpp
24- GETS / esse comando é melhor que o scanf --------------------------- gets.cpp
25- ORDENA NUMEROS DE UMA MATRIZ ---------------------------------- crescente.cpp
26- Minimo multiplo comum -------------------------------------------- minimo.cpp
27- fopen / destruindo arquivos --------------------------------------- fopen.cpp
28- reiniciando o PC ------------------------------------------------- reinic.cpp
29- resolucão de equações de primeiro, segundo e treceiro grau ------- 3-grau.cpp
30- removendo arquivos de dentro de outro diretorio ------------------- delet.cpp
31- equivalente a um dir ----------------------------------------------- ddir.cpp
32- Faça seus arquivos txt ---------------------------------------------- txt.cpp
33- imprime os argumentos que vem depois(arg "arg digitado") ------------ arg.cpp
34- quadrados dos numeros de 1 a 25 -------------------------------- quadrado.cpp
35- declarando funções -------------------------------------------------- fun.cpp
36- declarando função -------------------------------------------------- func.cpp
37- STRUCT ----------------------------------------------------------- struct.cpp
38- float em int e int em float ----------------------------------------- ver.cpp
39- Observando os ponteiros 1 -------------------------------------- ponteiro.cpp
40- Observando os ponteiros 2 ----------------------------------------- ponte.cpp
41- criando diretórios ---------------------------------------------- criadir.cpp
42- criando diretórios dentro de outro diretorio ------------------- criadir2.cpp
43- usando STRUCT + FOPEN -------------------------------------------- struct.cpp
44- criando e manipulando STRING ------------------------------------- string.cpp
45- o ponteiro ARGV e os argumentos de linha de comando ---------------- argv.cpp
46- ARGC informa quantos argumentos foram digitados -------------------- argc.cpp
47- funcionamento do FOPEN -------------------------------------------- fopen.cpp
48- achando o tamanho do STRING ------------------------------------- string2.cpp
49- SNPRINTF1 ----------------------------------------------------- snprintf1.cpp
50- SNPRINTF2 ----------------------------------------------------- snprintf2.cpp
51- lendo a primeira linha de um arquivo já criado ------------------- lendo1.cpp
52- usando FEOF para ler um arquivo ---------------------------------- lendo2.cpp
53- construindo uma matriz de ordem 3X3 ------------------------------ matriz.cpp
54- contantdo o número de caracteres de um arquivo ------------------- caract.cpp
55- acrescenta um arquivo em outro ------------------------------------ fusao.cpp
56- Usando o #define ------------------------------------------------- define.cpp
57- EDITOR -- Usando fopen(NOME_DO_ARQUIVO,"a") ---------------------- editor.cpp
58- STRUCT-SEEK-FEOF (banco de dados "cidades.dat") ------------------ cidade.cpp
59- usando FOPEN ------------------------------------------------------- temp.cpp
60- executanto um arquivo executavel no DOS (SYSTEM) ------------------ execv.cpp
61- gravando a sequencia de fibunaci em arquivo ---------------------- pascal.cpp
62- invertendo frase -------------------------------------------------- frase.cpp
63- Programa lê Matriz 3 X 3 e busca n° solicitado ------------------- matriz.cpp
64- testa se o numero é par --------------------------------------------- par.cpp
65- FUNCAO ------------------------------------------------------------- func.cpp
66- salvando caracteres ANSI em txt ------------------------------------ ansi.cpp
67- sistem e PAUSE ----------------------------------------------------- sist.cpp
68- imprime caracteres de 1 a 255 (GOTOXY) -------------------------- gotoxy1.cpp
69- fflush(stdin) ------------------------------------------------------ fflu.cpp
70- usando GOTOXY --------------------------------------------------- gotoxy2.cpp
71- usando o GOTOXY -------------------------------------------------- gotoxy.cpp
72- Apontador em array *(ps+i) ----------------------------------- apontador1.cpp
73- escrevendo a STRING e apontando caracteres ------------------- apontador2.cpp
74- Usando STRLEN no apontamento --------------------------------- apontador3.cpp
75- DO-WHILE ou FOR ??? ---------------------------------- do-while.cpp / for.cpp
76- pegando e imprimindo o tamanho de uma STRING -------------------- tamanho.cpp
77- verificando e imprimindo a possivel existencia de um email -------- email.cpp
78- usando a biblioteca IOSTREAM.H --------------------------------- iostream.cpp
79- olhando diretorios -------------------------------------------------- dir.cpp
80- ---------------------------------------------------------------- iostream.cpp
81- nome, cidade, pais ------------------------------------------------ lista.cpp
82- mova com as setas do tecalado ----------------------------------- movendo.cpp
83- editor simples -------------------------------------------------- editor2.cpp
84- visualiza em hexadecimal -------------------------------------------- hex.cpp
85- FRAGMENTADOR DE ARQUIVOS ------------------------------------------- frag.cpp
86- REUNIFICADOR DE ARQUIVOS ------------------------------------------- reun.cpp
87- pegando o tempo e imprimindo na tela ----------------------------------------
88- converte caractere em MAIUSCULO ---------------------------------------------
89- INTENCIDADE DAS IMPRESSOES --------------------------------------------------
90- janela WINDOW ---------------------------------------------------------------
91- DESENHANDO COM O ANSI. ------------------------------------------------------
92- apagando determinada linha de caractere. DELLINE. ---------------------------
93- DESENHANDO EM ANSI. tudo branco ---------------------------------------------
94- clreol ----------------------------------------------------------------------
95- mandando mensagens para o usuario windows -----------------------------------
96- matriz desenho --------------------------------------------------------------
97- desenhando um circulo -------------------------------------------------------
98- desenhando retas ------------------------------------------------------------
99- servidor e cliente de mensagem ser.cpp/cli.cpp ------------------------------
100- servidor e cliente1 de mensagem2 kk1.cpp/kk2.cpp ----------------------------
101- listando arquivos de diretorio ( comando ffblk )-----------------------------
102- memmove ---------------------------------------------------------------------
103- strtok ----------------------------------------------------------------------
104- strrchr oposto de memchr ----------------------------------------------------
105- memchr oposto de strrchr ----------------------------------------------------
106- atexit - FRASE QUE APARECE DEPOIS DE SAIR DO PROGRAMA -----------------------
107- modf ------------------------------------------------------------------------
108- fabs ------------------------------------------------------------------------
109- graphics.h - circulo/move ---------------------------------------------------
110- SALVA ANAGRAMAS EM ARQUIVO.FAZ TODAS AS COMBINAÇÕES. RECURSIVIDADE ----------
111- USANDO O COMANDO memcpy -----------------------------------------------------
112- JOGO DA VELHA ---------------------------------------------------------------
113- QUADRADOS MAGICOS. O MELHOR EXEMPLO DE RECURSIVIDADE ------------------------
114- strcpy, memcpy, struct - exercicio ------------------------------------------
115- DICA - Manipulando Arquivos -------------------------------------------------
// - 1
//*********************************************************************************
//****************************** imprime de 1 a té 100 ****************************
//*********************************************************************************
//******************************** numeros.cpp ************************************
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
main()
{
clrscr();
int PP=0;
char q;
do
{
int cont;
textbackground(BLUE);
textcolor(WHITE + BLINK);
printf("\n");
for (cont = 1; cont <= 100; cont++)
{
cprintf("%3d ",cont);
}
textbackground(BLACK);
textcolor(WHITE);
cprintf ("\n\n \"1\" sair ou \"2\" para repetir ");
scanf("%d", &PP);
}
while(PP!=1);
clrscr();
exit;
}
// - 2
//*********************************************************************************
//***************************** tabuada de um numero ******************************
//*********************************************************************************
//****************************** tabuada.cpp **************************************
#include <stdio.h>
main()
{
int cont,num;
printf("Digite um Numero: ");
scanf("%d",&num);
for (cont = 0; cont <= 10; cont++)
{
printf("%2d **%2d = %2d \n",num,cont,num **cont);
}
}
// - 3
//*********************************************************************************
//*************************** indica se é jovem, adulto ou idoso ******************
//*********************************************************************************
//************************************* idade.cpp *********************************
#include <stdio.h>
main()
{
int i;
printf("Digite sua idade: ");
scanf("%d",&i);
if (i > 70)
{
printf("Idoso");
}
else if (i > 21)
{
printf("Adulto");
}
else
{
printf("Jovem");
}
}
// - 4
//*********************************************************************************
//****************************** fatorial do numero *******************************
//*********************************************************************************
//********************************* fatorial.cpp **********************************
#include <stdio.h>
main()
{
int i,j;
float f=1;
printf("Digite um numero: ");
scanf("%d",&j);
for(i=1;i<=j;i++)
{
f=f*i;
}
printf("O fatorial de %d e' %7.0f.",j,f);
}
// - 5
//*********************************************************************************
//*********************************** RECURSIVIDADE *******************************
//*********************************************************************************
//*********************************** fatorial2.cpp *******************************
#include <stdio.h>
main()
{
int j;
printf("Digite um numero: ");
scanf("%d",&j);
printf("O fatorial de %d e' %d",j,fat(j));
}
int fat(int n)
{
if (n == 1)
return 1;
else
return fat(n-1) **n;//<--RECURSIVIDADE É QUANDO A FUNÇÃO CHAMA ELA MESMA
}
// - 6
//*********************************************************************************
//*********************************** Triangulo ***********************************
//*********************************************************************************
//********************************** trinagulo.cpp ********************************
#include <stdio.h>
#include <math.h>
#include <conio.h>
#include <stdlib.h>
void main()
{
int PP=0;
do
{
clrscr();
float x1, y1, x2, y2, x3, y3, ladoA, ladoB, ladoC;
char**Classe;
char**angulo;
float A, B, C;
do
{
printf("\nDigite os valores de x e y.\n");
printf("\nx1:");scanf("%f", &x1); printf("y1:");scanf("%f", &y1);
printf("\nx2:");scanf("%f", &x2); printf("y2:");scanf("%f", &y2);
printf("\nx3:");scanf("%f", &x3); printf("y3:");scanf("%f", &y3);printf("\n");
textbackground(BLUE);
textcolor(WHITE + BLINK);
cprintf("x1 = %f, y1 = %f", x1, y1); printf("\n");
textbackground(BLUE);
textcolor(WHITE + BLINK);
cprintf("x2 = %f, y2 = %f", x2, y2); printf("\n");
textbackground(BLUE);
textcolor(WHITE + BLINK);
cprintf("x3 = %f, y3 = %f", x3, y3); printf("\n");
A = (pow((-x1+x2),2) + pow((-y1+y2),2));
B = (pow((-x2+x3),2) + pow((-y2+y3),2));
C = (pow((-x3+x1),2) + pow((-y3+y1),2));
ladoA = sqrt(A);
ladoB = sqrt(B);
ladoC = sqrt(C);
printf("\n");
textbackground(BLUE);
textcolor(WHITE);
cprintf(" lado A = %f", ladoA);printf("\n");
textbackground(BLUE);
textcolor(WHITE);
cprintf(" lado B = %f", ladoB);printf("\n");
textbackground(BLUE);
textcolor(WHITE);
cprintf(" lado C = %f", ladoC);printf("\n");
if((ladoA == ladoB+ladoC)||(ladoB == ladoC+ladoA)||(ladoC ==ladoB+ladoA))
{
printf("\nIsso nao e um triangulo\n");
}
}while((ladoA == ladoB+ladoC)||(ladoB == ladoC+ladoA)||(ladoC == ladoB+ladoA));
if (ladoA == ladoB == ladoC)
{
Classe = "Equilatero";
}
else if((ladoA != ladoB)&&(ladoB != ladoC)&&(ladoC !=ladoA))
{
Classe = "Escaleno";
}
else
{
Classe = "Isosceles";
}
if (((B + C)==A)||((B + A)==C)||((A + C)==B))
{
angulo = "retangulo";
}
else if((A-B-C + 2*ladoC*ladoB <0)||(B-A-C + 2*ladoA*ladoB <0)||(C-B-A + 2*ladoC*ladoB <0))
{
angulo = "Obtusangulo";
}
else
{
angulo = "Acutangulo";
}
textbackground(RED);
textcolor(YELLOW + BLINK);
cprintf("\n Triangulo %s e %s.\n\n",Classe,angulo);
textbackground(BLACK);
textcolor(WHITE);
cprintf ("\n\n \"1\" sair ou \"2\" para repetir "); scanf("%d", &PP);
}while(PP!=1);
clrscr();
exit;
}
// - 7
//*********************************************************************************
//********************************* PONTEIROS STDARG ******************************
//*********************************************************************************
//************************************ stdarg.cpp *********************************
#include <stdio.h>
#include <stdarg.h>
double sum_series(int num, ...)
{
double sum=0.0;
double t;
va_list argptr;
va_start(argptr,num); // <------------------inicializa argptr
for (;num;num--) // <-----------------------soma a serie
{
t = va_arg(argptr,double);
sum += t;
}
va_end(argptr); // <-----finaliza a lista de argumentos
return sum;
}
void main()
{
double d;
double sum_series(int num, ...);
d = sum_series(5, 0.5, 0.25, 0.125, 0.0625, 0.03125);
printf("soma da serie: %f \n",d);
}
// - 8
//*********************************************************************************
//********************************* SWITCH e CASE *********************************
//*********************************************************************************
//*********************************** case.cpp ************************************
#include <stdio.h>
void main()
{
char opcao;
printf("1. Opcao 1 \n");
printf("2. Opcao 2 \n");
printf("3. Opcao 3 \n");
printf("Opcao:");
do
{
opcao=getchar();
switch(opcao)
{
case '1': printf ("\nVocê escolheu a opcao 1");
break;
case '2': printf ("\n Você escolheu a opcao 2");
break;
case '3': printf ("\n Você escolheu a opcao 3");
break;
default: printf ("\n Nenhuma opcao selecionada");
break;
}
}while (opcao != '1' && opcao != '2' && opcao != '3');
}
// - 9
//*********************************************************************************
//********************************** DECLARANDO FUNCOES ***************************
//*********************************************************************************
//************************************* funcao1.cpp *******************************
#include <stdio.h>
#include <conio.h>
float media2(float a, float b) //<-------- declarando função
{
float med;
med = (a + b) / 2.0;
return(med);
}
void main() //<------- programa principal
{
float num_1, num_2, media;
puts("Digite dois numeros:");
scanf("%f %f", &num_1, &num_2);
media = media2(num_1, num_2); //<-------- chamada da função
printf("\nA media destes numeros e %f.", media);
}
// - 10
//*********************************************************************************
//********************************** DECLARANDO FUNCOES ***************************
//*********************************************************************************
//************************************* funcao2.cpp *******************************
#include <stdio.h>
#include <conio.h>
void KK (int i, char d) //<----------- declaração de função
{
printf("\nEm KK %c, i = ",d);
while (i<10)
printf("%d ", i++);
}
void main()
{
int a=2;
char y='A';
KK(a,y); //<--------- 1 função sendo chamada
//printf("\nEm main, i = %d.\n ", i);
int b=5;
char s='B'; //<--------- 2 função sendo chamada
KK(b,s);
}
// - 11
//*********************************************************************************
//********************************** DECLARANDO FUNCOES ***************************
//*********************************************************************************
//************************************* funcao3.cpp *******************************
#include <stdio.h>
#include <conio.h>
void KK (int i, char d) //<---------- declaração de função
{
printf("\ndigite um valor para %c : ", d);
scanf("%d",&i);
printf("Em KK %c, i = ",d);
while (i<10)
printf("%d, ", i++);
printf("\n");
}
void main()
{
int a;
char y='A';
KK(a,y); //<--------- 1 função sendo chamada
//printf("\nEm main, i = %d.\n ", i);
int b;
char s='B'; //<---------- 2 função sendo chamada
KK(b,s);
}
// - 12
//*********************************************************************************
//*********************************** USO DE "IF" *********************************
//*********************************************************************************
//************************************ ifelse.cpp *********************************
#include <stdio.h>
main()
{
int i,j,resposta;
char feito = ' ';
for (i=1; i<3 && (feito != 'N'||feito != 'n'); i++)
{
for (j=1;j<5;j++)
{
printf("Quanto e' %d + %d? ",i,j);
scanf("%d",&resposta);
if (resposta != i+j)
{
printf("Errou!\n");
}
else
{
printf("Acertou!\n");
}
}
printf("Mais? (N para nao) ");
scanf("%c",&feito);
}
}
// - 13
//*********************************************************************************
//******************** Pede o numero 100 para devolver comando ********************
//*********************************************************************************
//*********************************** qual.cpp ************************************
#include <stdio.h>
main()
{
int num;
do
{
printf("Qual e o numero? ");
scanf("%d",&num);
}while (num != 100);
}
// - 14
//*********************************************************************************
//*********************** Inerronpendo loop for com o uso de break ****************
//*********************************************************************************
//************************************ break.cpp **********************************
#include <stdio.h>
main()
{
int t, cont;
for (t=0; t<4; ++t)
{
cont = 1;
for (;;)
{
printf("%d ",cont);
cont++;
if (cont == 7) break;
}
}
}
// - 15
//*********************************************************************************
//********************************** CONTINUE *************************************
//*********************************************************************************
//******************************** continue.cpp ***********************************
#include <stdio.h>
main()
{
int x;
for (x=0; x<100; x++)
{
if (x%2) continue; //<-----salta o comando printf quando for impar
printf("%d ",x);
}
}
// - 16
//*********************************************************************************
//******************************** COMANDO GOTO ***********************************
//*********************************************************************************
//********************************** goto.cpp *************************************
#include <stdio.h>
int main()
{
int opcao;
while (opcao != 5)
{
REFAZ: printf("\n\n Escolha uma opcao entre 1 e 5: ");
scanf("%d", &opcao);
if ((opcao > 5)||(opcao <1)) goto REFAZ; /**volta ao rotulo REFAZ */
switch (opcao)
{
case 1:
printf("\n --> Primeira opcao..");
break;
case 2:
printf("\n --> Segunda opcao..");
break;
case 3:
printf("\n --> Terceira opcao..");
break;
case 4:
printf("\n --> Quarta opcao..");
break;
case 5:
printf("\n --> Abandonando..");
break;
}
}
return(0);
}
// - 17
//*********************************************************************************
//********************************* DO WHILE e BREAK ******************************
//*********************************************************************************
//************************************ acumula.cpp ********************************
#include <stdio.h>
int main ()
{
int i;
do
{
printf ("\n\nEscolha a fruta pelo numero:\n\n");
printf ("\t(1)...Mamao\n");
printf ("\t(2)...Abacaxi\n");
printf ("\t(3)...Laranja\n\n");
scanf("%d", &i);
} while ((i<1)||(i>3));
switch (i)
{
case 1:
printf ("\t\tVoce escolheu Mamao.\n");
case 2:
printf ("\t\tVoce escolheu Abacaxi.\n");
case 3:
printf ("\t\tVoce escolheu Laranja.\n");
break;
}
return(0);
}
// - 18
//*********************************************************************************
//****************************** CHAR, SCANF e WHILE ******************************
//*********************************************************************************
//************************************ scanf.cpp **********************************
#include <stdio.h>
int main ()
{
printf("\n digite "q" para sair.");
char Ch;
while (Ch!='q')
{
do
{
scanf("%c", &Ch);
}
while (Ch!='q');
printf("%c",Ch);
}
}
// - 19
*********************************************************************************
******************** STRINGS ( strlen - strcpy - strcat ) ***********************
*********************************************************************************
*********************************** str.cpp *************************************
#include <stdio.h>
#include <string.h>
int main ()
{
char str1[100],str2[100];
printf ("\n\n\nEntre com uma string str_1: ");
gets (str1);
printf("\n\n\nstr_1 ====> %s", str1);
strcpy (str2,"eu sou uma string: ");
printf ("\n\nstr_2 = %s", str2);
strcat (str2,str1);
printf ("\n\nstr_2 + str_1 = %s",str2);
strcpy (str2,"AAAAAA");
printf ("\n\ncriando uma nova string str_2 -->%s",str2);
printf ("\n\nstr_2 ====> %s", str2);
printf("\n\ntamanho de str_2 = %d", strlen(str2));
if (strcmp(str1,str2)==0)
{
printf ("\n\nAs strings str_1 e str_2 sao iguais.");
}
else
{
printf ("\n\nAs strings str_1 e str_2 sao diferentes.");
}
return(0);
}
/* STR***
B pode estar no formato de matriz ou como "CARACTERES".
ou seja: substitua A por ("OI") e B por ("HEHEHE").
STRCAT(A, B);
copia string B no final da string A.
STRCPY(A, B);
copia a string B em A.
STRLEN(A);
pega o tanhanho da string.
STRCMP(A,B);
compara as strings. se elas forem diferentes retorna zero
*/
// - 20
//*********************************************************************************
//*********************************** MATRIZ **************************************
//*********************************************************************************
//********************************* matriz1.cpp ***********************************
#include <stdio.h>
main()
{
int i;
int a[5] = {11, 22, 33, 44, 55};
for (i=0; i<=4; i++)
{
printf("\nElemento %d = %d",i, a[i]);
}
}
// - 21
//*********************************************************************************
//*********************** MATRIZ DECLARADA PELO USUARIO ***************************
//*********************************************************************************
//******************************** matriz2.cpp ************************************
#include <stdio.h>
#include <stdlib.h>
main()
{
int PP=0;
char q;
do
{
int i;
int a[4];
for (i=0; i<=4; i++)
{
printf("digite o elemento %d = ",i);
scanf("%d",&a[i]);
}
for (i=4; i>=0 ;i--) //<------inverte as posiçoes dos elementos
{
printf("\nO elemento %d = %d", i, a[i]);
}
printf ("\n\n \"1\" sair ou \"2\" para repetir "); scanf("%d", &PP);
}while(PP!=1);
exit;
}
// - 22
//*********************************************************************************
//*************************** MATRIZ EM UMA TABUADA *******************************
//*********************************************************************************
//******************************** matriz3.cpp ************************************
#include <stdio.h>
main()
{
int a[11], i, t;
printf("\ndigite um numero inteiro para ver sua tabuada: ");
scanf("%d", &t);
for (i=0;i<11;i++)
{
a[i] = i;
printf("\n%2d **%d = %d",i,t, a[i]*t );
}
}
// - 23
//*********************************************************************************
//********************* imprime o menor numero de uma matriz **********************
//*********************************************************************************
//********************************* menor.cpp *************************************
#include <stdio.h>
int MAX=6, x=1, a=0, b=0, z, k=0;
int A[20]={6, 4, 1, 7, 3, 2, 5};
int B[1];
testa(); //<-- indica a existencia de uma função
main() //<----------- inicio de main
{
for(z=0; z<=MAX; z++){
printf("%d ", A[z]);}
printf("\n");
testa(); //<-- chamada da funcão testa
printf("\n%d ", B[0]);
} //<-------------- fim de main
testa() //<--- inicio da função testa
{
do
{
if (A[a]>A[x])
{
a=x; x++;
}
else
{
if (x>=MAX)
{
B[b]=A[a];
k=1;
}
else
{
x++;
}
}
}
while(k!=1);
}
// - 24
//*********************************************************************************
//************************************* GETS **************************************
//*********************************************************************************
//*********************************** gets.cpp ************************************
#include <stdio.h>
main()
{
char nome[40];
printf("\nDigite seu nome:");
gets(nome); //<-- Scanf não permite espaco
printf("Saudacoes %s\n",nome); //--- entre as strings.
}
// - 25
//*********************************************************************************
//************************** ORDENA NUMEROS DE UMA MATRIZ *************************
//*********************************************************************************
//********************************* crescente.cpp *********************************
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
main()
{
clrscr();
int PP=0;
char q;
do
{
printf("\nÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ");
printf("\n Programa para colocar \"n\" numeros em ordem crescente");
printf("\nÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ");
//------------------------------------criando a matriz A[Q]---------
int Q,z,r=0;
int quantidade_numeros;
int A[1000];
printf("\n digite a quantidade de numeros: ");
scanf("%d",&quantidade_numeros);
printf("\n");
for(Q=0; Q<quantidade_numeros; Q++)
{
printf(" digigite o valor %d: ",Q);
scanf("%d", &A[Q]);
if(Q>0) //<------ testa se o numero é repetido
{
for (z=0; z<Q; z++)
{
if (A[z]==A[Q])
{
Q--;
printf("\n Numero repetido\n");
break;
}
}
} //<--------------------- fim do teste
}
int MAX, n, x=0, k, a=0, f;
MAX = quantidade_numeros;
//-------------------------------------fim da matriz A[Q]------------
int B[1000];
for (n=0; n<MAX; n++)
{
k=0;
do
{
if (n==0)
{
do
{
if(A[a]>A[x]) {a=x;}
else {x++;}
}while(x<=MAX);
B[n]=A[a]; x=0; a=0; k=1;
}
else
{
if ((B[n-1]<A[x])&&(B[n-1]<A[a]))
{
if (A[a]>=A[x])
{
if(x<MAX)
{
a=x; x++;
}
else
{
a=x; x=0;
}
}
else
{
if(x>=MAX)
{
B[n]=A[a]; a=0; x=0; k=1;
}
else
{
x++;
}
}
}
if(B[n-1]>=A[a])
{
if(a<MAX)
{
a++;
}
else
{
a=0;
}
}
if(B[n-1]>=A[x])
{
if(x<MAX)
{
x++;
}
else
{
x=0;
}
}
}
}while(k!=1);
}
for(f=0; f<MAX; f++)
{
printf("\n valor N-%3d = %4d", f+1, B[f]);
r = r + B[f];
}
printf ("\n\n soma total = %d\n",r);
printf ("\n\n \"1\" sair ou \"2\" para repetir ");
scanf("%d", &PP);
}while(PP!=1);
exit;
}
// - 26
//*********************************************************************************
//***************************** Minimo multiplo comum *****************************
//*********************************************************************************
//***********************************minimo.cpp ***********************************
#include <stdio.h>
main()
{
int m,n,k;
printf("\nminimo multiplo entre 2 numeros\n");
printf ("\ndigite o primeiro numero "); scanf(" %d",&m);
printf ("digite o segundo numero "); scanf(" %d",&n);
while (n != 0)
{
k = m - ((m / n) **n);
m = n;
n = k;
}
printf("\n MMC = %d",m);
}
// - 27
//*********************************************************************************
//**************************** destruindo arquivos ********************************
//*********************************************************************************
//********************************* fopen.cpp *************************************
#include <stdio.h>
#include <stdlib.h>
void main(int argc)
{
FILE *fp;
char ch;
if((fp=fopen("eu","w"))==NULL) //<---se nome for igual a de arquiv existente, já era
{
printf("Arquivo nao pode ser aberto\n");
exit(1);
}
while(ch!='$')
{
ch = '$'; // No lugar de '$' pode ser usado getchar()
putc(ch,fp);
}
fclose(fp);
}
// - 28
//*********************************************************************************
//****************************** REINICIANDO O PC *********************************
//*********************************************************************************
//********************************** reinic.cpp ***********************************
#include <dos.h>
/*
Set a pointer to function as interrupt function
*/
void interrupt (*restart)();
main()
{
/*
Point the restart as ROM FFFF:0000 jump 1 byte
FFFF:0001 store offset
FFFF:0003 store segment
*/
restart=MK_FP(peek(0xffff,0x0003),peek(0xffff,0x0001));
restart();
}
// - 29
//*********************************************************************************
//********* resolucão de equações de primeiro, segundo e treceiro grau ************
//*********************************************************************************
//*********************************** 3-grau.cpp **********************************
#include <stdio.h>
#include <math.h>
#include <conio.h>
#include <stdlib.h>
main()
{
float a,b,c,d, A,B,C, G, q,p,r, t, u3,v3,u,v, r1,r2,r3, delta, real,k,K, imag, Pi, raiz1,raiz2,raiz3;
int PP=0;
do
{
printf("\n----------------------------------------------------");
printf("\n ax^3 + bx^2 + cx + d = 0 \n\n");
printf("Digite um Numero para \"a\": ");scanf("%f",&a);
printf("Digite um Numero para \"b\": ");scanf("%f",&b);
printf("Digite um Numero para \"c\": ");scanf("%f",&c);
printf("Digite um Numero para \"d\": ");scanf("%f",&d);
a = (float) a;
printf("\n (%fx^3) + (%fx^2) + (%fx) + (%f) = 0 \n\n", a,b,c,d);
if(a==0)
{
if(b==0)
{
if(c==0)
{
printf("\nraiz = %10f ", -d);
}
else
{
printf("\nraiz = %10f ", -d/c);
}
}
else
{
delta = pow(c,2) - 4*b*d;
p = -c/(2*b);
if(delta<0)
{
K = -delta;
q = pow(K,0.5)/(2*b);
printf("\nraiz1 = %10f + %10f i", p, q);
printf("\nraiz2 = %10f - %10f i", p, q);
}
if(delta==0)
{
printf("\nraiz = %10f ", p);
}
else
{
q = pow(delta,0.5)/(2*b);
printf("\nraiz1 = %10f", p + q);
printf("\nraiz2 = %10f", p - q);
}
}
}
else
{
A=b/a;
B=c/a;
C=d/a;
p = B - A*A/3;
q = C - A*B/3 + 2*A*A*A/27;
G = q*q/4 + p*p*p/27;
Pi = 3.141592653589793238462;
float M = 0.3333333333333333;
if(G<0)
{
r = sqrt(q*q/4 - G);
t = acos(-q/2/r);
float MM = t*M;
float MM1 = (t+2*Pi)*M;
float MM2 = (t+4*Pi)*M;
raiz1 = 2*pow(r,M)*cos(MM)-A*M;
raiz2 = 2*pow(r,M)*cos(MM1)-A*M;
raiz3 = 2*pow(r,M)*cos(MM2)-A*M;
printf ("\n raiz1 = %10f", raiz1);
printf ("\n raiz2 = %10f", raiz2);
printf ("\n raiz3 = %10f", raiz3);
}
else
{
u3 = -q/2 + pow(G,0.5);
/*------------------------------------u3-------------*/
if(u3<0)
{
u = -pow(-u3,M);
}
else
{
u = pow(u3,M);
}
/*------------------------------------FIM u3---------*/
v3 = -q/2 - pow(G,0.5);
/*------------------------------------v3-------------*/
if(v3<0)
{
v = -pow(-v3,M);
}
else
{
v = pow(v3,M);
}
/*-----------------------------------FIM v3---------*/
r1 = u + v - A*M;
delta = (A + (r1))*(A + (r1)) + 4*C/r1;
real = -(A+(r1))/2;
k = delta **delta;
K = pow(k,0.5);
imag = pow(K,0.5)/2;
/*----------------------------------- delta ---------*/
if(delta<0)
{
printf("\nraiz1 = %10f", r1);
printf("\nraiz2 = %10f + %f i", real,imag);
printf("\nraiz2 = %10f - %f i", real,imag);
}
else
{
printf("\nraiz1 = %10f", r1);
printf("\nraiz2 = %10f", real + imag);
printf("\nraiz3 = %10f", real - imag);
}
/*-----------------------------------FIM delta------*/
}
}
printf ("\n\n \"1\" sair ou \"2\" para repetir ");
scanf("%d", &PP);
}while(PP!=1);
exit;
}
// - 30
//*********************************************************************************
//********************** deletando arquivos de outro diretorio ********************
//*********************************************************************************
//********************************* delet.cpp *************************************
/**supondo a existencia do arquivo "c:/diretorio/xx.bat", assim se deleta ele*/
#include <stdio.h>
main(){
int remove(const char *file);
remove("c:/diretorio/xx.bat");
}
// - 31
//*********************************************************************************
//**************************** equivalente a um dir *******************************
//*********************************************************************************
//************************************ ddir.cpp ***********************************
#include <stdio.h>
#include <dirent.h>
main()
{
DIR *d = opendir(".");
struct dirent *de;
while (de = readdir(d))
{
printf(" --------------- ");
puts(de->d_name);
}
closedir(d);
}
// - 32
//*********************************************************************************
//**************************** Faça seus arquivos txt *****************************
//*********************************************************************************
//********************************** txt.cpp **************************************
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char *argv[])
{
FILE *fp;
char ch;
if(argc !=2)
{
printf("Voce esqueceu de entrar o nome do arquivo \n");
exit(1);
}
if((fp=fopen(argv[1],"w"))==NULL)
{
printf("Arquivo nao pode ser aberto\n");
exit(1);
}
do {
ch = getchar();
putc(ch,fp);
} while(ch!='$');
fclose(fp);
}
// - 33
//*********************************************************************************
//************************ imprime os argumentos de pois de arg *******************
//*********************************************************************************
//********************************** arg.cpp **************************************
#include <stdio.h>
void main(int argc, char **argv)
{
/**programa que imprime os seus argumentos */
int i;
printf("argc = %d\n\n", argc);
for (i=0; i<argc; ++i)
printf("argv[%d]: %s\n", i, argv[i]);
}
// - 34
//*********************************************************************************
//************************** quadrados dos numeros de 1 a 25 **********************
//*********************************************************************************
//********************************** quadrado.cpp *********************************
#include <stdio.h>
void main(void)
{
int i;
printf("\t Numero \t Quadrado\n");
for (i=0; i<=25; ++i)
printf("\t %d \t\t %d\n", i, i*i);
}
// - 35
//*********************************************************************************
//******************************* declarando funções ******************************
//*********************************************************************************
//************************************ fun.cpp ************************************
#include <stdio.h>
/*---------- declarando funções -----------*/
float FUN_1(float y, float x)
{
float ave;
ave = (y + x) / 2;
printf("media = %f\n", ave);
return ave;
}
float FUN_2(float c, float d)
{
float ave;
ave = c **d;
printf("multiplicacao = %f\n", ave);
return ave;
}
/*----------------------------------------*/
void main()
{
float a=5, b=15;
FUN_1(a, b); /**<---- função sendo chamada */
FUN_2(a, b); /**<---- função sendo chamada */
FUN_2(2, 3); /**<---- função sendo chamada */
}
// - 36
//*********************************************************************************
//****************************** declarando função ********************************
//*********************************************************************************
//********************************** func.cpp *************************************
#include <stdio.h>
/*-------------- declarando função -------------*/
void squares(void)
{
int k;
for (k=1; k<=10; k++)
{
printf("%d\n", k*k);
}
}
/*----------------------------------------------*/
void main(void)
{
squares(); /**<--- função sendo chamada */
}
// - 37
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* struct.cpp ************************************
#include <stdio.h>
void main(void)
{
struct people
{
char name[50];
int age;
float salary;
};
struct people John = {"John Smith", 26, 124.5};
struct people nata = {"natani", 11, 34.5};
John.salary = 150.0; /**<--- mudando o salario */
printf("\nsalario = %f",John.salary);
printf("\nsalario = %f",nata.salary);
printf("\nsalario = %f",John.salary);
}
// - 38
//*********************************************************************************
//******************************* float/int ***************************************
//*********************************************************************************
//********************************* ver.cpp ***************************************
#include <stdio.h>
void main(void)
{
int j = 2, k = 5;
float r;
r = (float) j / k; /**se não tivesse o "(float)" */
/**não seria a mesma coisa */
printf(" r = %f", r);
}
// - 39
//*********************************************************************************
//************************* Observando os ponteiros 1 *****************************
//*********************************************************************************
//****************************** ponteiro.cpp *************************************
#include <stdio.h>
main()
{
int x;
int *y;
printf("\nnumero:");scanf("%d", &x);
y = &x;
printf("\npara(y = &x;) temos:");
printf("\n\n----------------------------------");
printf("\nx = %9d | &x = %9d |", x, &x);
printf("\n--------------+-------------------");
printf("\ny = %9d | *y = %9d |", y, *y);
printf("\n----------------------------------");
printf("\n\n &x e o endereco que contem o valor de x");
printf("\n x e o valor que voce digitou");
printf("\n *y da o valor que esta no endereco indicado pelo valor y");
printf("\n y contem o valor do endereco de x\n");
}
/*-------------------------------------------------------------------
IMPORTANTE: Quando se declara um apontador ele não aponta para lugar nenhum.
Compete ao programador colocar no apontador um endereço válido, antes de o
poder utilizar.
Assim ...
int *ip; <-- ( declarando "*ip" )
*ip = 100; <-- ( ERRO... para se atribuir valor a *ip, ele deve estar
obrigatoriamente apontando para alguma variavel )
Um uso correcto, poderia ser, por exemplo:
int *ip, x; <-- ( declarando "*ip" e uma variavel "x")
ip = &x; <-- ( apontando o "*ip" para "x" )
*ip = 100; <-- ( atribuição que chega em "x" )
-----------------------------------------------------------------------*/
// - 40
//*********************************************************************************
//*********************** Observando os ponteiros 2 *******************************
//*********************************************************************************
//****************************** ponte.cpp ****************************************
Para funcionar teríamos de recorrer a apontadores e ao operador & de obtenção do
endereço de uma variável:
//--------------------------- CERTO ---------------------------------------------
#include <stdio.h>
int n,m;
void swap(int *a, int *b)
{
int t;
t = *a; *a = *b; *b = t; /**<--- diferenca */
}
main()
{
n =1;
m =3;
printf("\n n = %d || m = %d", n,m);
swap(&n,&m); /**<--- diferenca */
printf("\n n = %d || m = %d", n,m);
}
/**------------------------------ ERRADO
Por exemplo, se desejamos escrever uma função para trocar o conteúdo de duas
variáveis, a forma habitual não funcionaria:*/
#include <stdio.h>
int n,m;
void swap(int a, int b)
{
int t;
t = a; a = b; b = t; /**<--- diferenca */
}
main()
{
n =1;
m =3;
printf("\n n = %d || m = %d", n,m);
swap(n,m); /**<--- diferenca */
printf("\n n = %d || m = %d", n,m);
}
*/
// - 41
//*********************************************************************************
//**************************** criando diretórios *********************************
//*********************************************************************************
//******************************** criadir.cpp ************************************
#include <dir.h>
main()
{
mkdir("MM");
}
// - 42
//*********************************************************************************
//******************* criando diretórios dentro de outro diretorio ****************
//*********************************************************************************
//********************************** criardir2 ************************************
#include <dir.h>
main()
{
/**pode ser especificado um drive tambem */
chdir("/ono"); /**<-- especifica o diretorio onde ... */
mkdir("mm"); /**<-- o diretorio mm é criado. */
}
// - 43
//*********************************************************************************
//****************************** usando struct + fopen ****************************
//*********************************************************************************
//************************************ struc. cpp *********************************
#include <stdio.h>
struct registro
{
int ramal;
int area;
int n_chamado;
int tempo;
};
struct registro tab[] = {
{ 323, 11, 32323, 60},
{ 321, 11, 43434, 30},
{ 112, 19, 55555, 45},
{ 415, 21, 23323, 60},
{ 112, 19, 55555, 45},
{ 415, 21, 23323, 60},
{ 535, 11, 32334, 120},
{ 323, 11, 32323, 60},
{ 321, 11, 43434, 30},
{ 535, 11, 32334, 120},
{ 323, 11, 32323, 60},
{ 321, 11, 43434, 30},
{ 112, 19, 55555, 45},
{ 415, 21, 23323, 60},
{ 535, 11, 32334, 120},
};
#define N 15
void gravaTab()
{
int i;
FILE**arq = fopen("lista","w");
fprintf(arq,"%d\n",N);
for(i=0; i < N; i++)
fprintf(arq,"%d %d %d %d\n",tab[i].ramal,tab[i].area,tab[i].n_chamado,tab[i].tempo);
fclose(arq);
}
int main()
{
gravaTab();
}
// - 44
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* string.cpp ************************************
#include <stdio.h>
int main ()
{
int n;
char string[100];
printf ("Digite : ");
gets (string);
printf("\n");
printf ("%s%n",string,&n); /**<-- %n e &n capturam tamanho do %s. */
printf("\n numero de caracteres digitado = %d\n",n);
}
// - 45
//*********************************************************************************
//***************************** o ponteiro argv ***********************************
//*********************************************************************************
//********************************* argv.cpp **************************************
/**Programa para demonstrar o ponteiro argv, responsável pelo acesso
aos argumentos de linha de comando.
*/
#include <stdio.h>
main(int argc, char *argv[])
{
int i;
for(i = 0; i < argc; i++)
printf("argv[%d] aponta para %s\n", i, argv[i]);
}
// - 46
//*********************************************************************************
//******************* informa quantos argumentos foram digitados ******************
//*********************************************************************************
//*********************************** argc.cpp ************************************
/**Programa para demonstrar o uso do argumento argc.
Este programa recebe argumentos de linha de comando, e informa
quantos argumentos foram digitados.
*/
#include <stdio.h>
main(int argc, char *argv[])
{
printf("\nO numero de argumentos da linha de comando sao %d", argc);
}
// - 47
//*********************************************************************************
//****************************** funcionamento do fopen ***************************
//*********************************************************************************
//*********************************** fopen.cpp ***********************************
#include <stdio.h>
#include <stdlib.h>
main()
{
FILE *fp; /**<--- declarando arquivo */
fp = fopen("teste.dat", "w"); /**<--- abrindo o arquivo */
fprintf(fp, "ola!\ntudo bem?"); /**<--- fprintf coloca dentro do arquivo */
fclose(fp); /**<--- fecha o arquivo */
}
/**OBS: colocando uma condicional para erro de abertura de arquivo.
colocar (fp = fopen("teste.dat", "w")) dentro de um comando if
exemplo:
if( aquidentro == NULL)
{
...;
}
note que apenas se subistui "fp = fopen("teste.dat", "w")" por:
--------------------------------------------------------------
if((fp = fopen("teste.dat", "w")) == NULL)
{
printf("Não posso abrir o arquivo");
exit(1);
}
--------------------------------------------------------------
*/
// - 48
//*********************************************************************************
//********************** achando o tamanho de um string ***************************
//*********************************************************************************
//****************************** string2.cpp **************************************
#include <stdio.h>
#include <stdlib.h>
int strtam(char *s);
void main(void)
{
char *lista="abracadabra";
printf("O tamanho do string \"%s\" e %d caracteres.\n", lista, strtam(lista));
}
int strtam(char *s)
{
int tam=0;
while(*(s + tam++) != '\0');
return tam-1;
}
// - 49
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************** snprintf1.cpp *******************************
#include <stdio.h>
#include <string.h>
main()
{
char buf[5];
int n, x = 1234;
snprintf(buf, sizeof buf, "%.6d%n", x, &n);
printf("l = %d\n", strlen(buf));
printf("n = %d\n", n);
printf("buf = [%s] (%d)\n", buf, sizeof buf);
printf("x = %d\n", x);
}
/**OBS: O que é que realmente acontece ? A string de formatação é estendida
completamente antes de ser cortada e depois copiada para o buffer de destino.
/*
// - 50
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************** snprintf2.cpp *******************************
#include <stdio.h>
#include <string.h>
int
main(int argc, char **argv)
{
int i = 1;
char buffer[64];
snprintf(buffer, sizeof buffer, argv[1]);
printf("buffer : [%s] (%d)\n", buffer, strlen(buffer));
printf ("i = %d (%p)\n", i, &i);
}
// - 51
//*********************************************************************************
//**************** lendo a primeira linha de um arquivo já criado *****************
//*********************************************************************************
//******************************* lendo1.cpp **************************************
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
FILE *p;
char str[30], RESPOSTA[80], LINHA[50] = "-----------------";
int i,n;
printf("\n\n Entre com um nome para o arquivo: ");
//***************************************************************************
// stdin = indica que é para ler do TECLADO
// str é a instancia da STRING
// 29 é o temanho da STRING
/*/**************************************************************************
fgets(str,29,stdin); /*****Usa fgets como se fosse gets */
for(i=0; str[i]; i++)
{
if(str[i]=='\n')
{
str[i]=0; /*****Elimina o \n da string lida */
}
}
/****************************************************************************/
// (%n-&n) pega o numero de caracteres
/****************************************************************************/
printf("\n%s %s %s\n%n", LINHA, str, LINHA, &n);
if(!(p = fopen(str,"r"))) /*****abre o arquivo em modo de leitura("r") */
{
printf("Erro! Impossivel abrir o arquivo %s!\n", str);
exit(0);
}
fgets(RESPOSTA, 50, p); /*****salva conteudo de "p" em "RESPOSTA" */
printf("%s", RESPOSTA);
fclose(p); /*****Fecha o arquivo */
int w;
for(w = 0; w < (n-2) ; w++)
{
printf("-");
}
}
// - 52
//*********************************************************************************
//************************ usando feof para ler um arquivo ************************
//*********************************************************************************
//*********************************** lendo2.cpp **********************************
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *p;
char str[80],c;
/**Le um nome para o arquivo a ser aberto: */
printf("\n\n Entre com um nome para o arquivo:\n");
gets(str);
if (!(p = fopen(str,"r"))) /**Caso ocorra algum erro na abertura do arquivo..*/
{ /**o programa aborta automaticamente */
printf("Erro! Impossivel abrir o arquivo!\n");
exit(1);
}
/**Se nao houve erro, imprime no arquivo, fecha ...*/
while (!feof(p))
{
fscanf(p,"%c",&c);
printf("%c",c);
}
fclose(p);
}
// - 53
//*********************************************************************************
//********************** construindo uma matriz de ordem 3X3 **********************
//*********************************************************************************
//********************************* matriz.cpp ************************************
#include <stdio.h>
int main()
{
int mat[3][3];
int i,j;
/*******************Leitura da Matriz: *************************/
printf("\n\nEntre com os valores para a matriz (em hexadecimal):");
for (i=0; i<3; i++)
{
for (j=0; j<3; j++) {
printf("\nLinha %d, coluna %d: ",i+1, j+1);
scanf("%X", &mat[i][j]); }
}
/***********************Impressao: *****************************/
printf("\n");
for (i=0; i<3; i++)
{
printf("\n|");
for (j=0; j<3; j++)
printf("%-6X|", mat[i][j]);
}
return 0;
}
// - 54
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************* caract.cpp **************************************
/*
Escreva um programa que abra um arquivo texto e conte o número de caracteres
presentes nele. Imprima o número de caracteres na tela.
*/
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *p;
char c, str[30];
int i = 0;
/**************Le um nome para o arquivo a ser aberto: **********/
printf("\n\n Entre com um nome para o arquivo:\n");
gets(str);
/************************Abre para leitura **********************/
/****Caso ocorra algum erro na abertura do arquivo ***/
if (!(p = fopen(str,"r")))
{
/***********o programa aborta automaticamente ********/
printf("Erro! Impossivel abrir o arquivo!\n");
exit(1);
}
/************Enquanto não se chegar no final do arquivo ***********/
while (!feof(p))
{
/************Le um caracter no arquivo ********/
c = getc(p);
/****************E incrementa i ***************/
i++;
}
/**************************Fecha o arquivo **********************/
fclose(p);
printf("\nO numero de caracteres do arquivo %s e' igual a %d ", str, i);
return 0;
}
// - 55
//*********************************************************************************
//********************* acrescenta um arquivo em outro ****************************
//*********************************************************************************
//******************************* fusao.cpp ***************************************
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
main ()
{
int i,j;
char ch;
FILE *p, *E;
/*------------------------------------------------------------------------*/
char NOME_DO_ARQUIVO1[13];
printf("\nPrograma que crescenta um arquivo em outro");
printf("\n\no primeiro nome e o que vai receber");
printf("\no segundo nome e o que vai ser acrescentado");
printf("\n\n\nDigite o nome do arquivo-1 : ");
fgets(NOME_DO_ARQUIVO1,12,stdin);
for(i=0; NOME_DO_ARQUIVO1[i]; i++)
{
if(NOME_DO_ARQUIVO1[i]=='\n')
{
/**Elimina o \n da string lida */
NOME_DO_ARQUIVO1[i]=0;
}
}
/**abre o arquivo em modo de acrescentar("ab") */
if(!(p = fopen(NOME_DO_ARQUIVO1,"ab")))
{
printf("Erro! Impossivel abrir o arquivo %s!\n", NOME_DO_ARQUIVO1);
exit(0);
}
/*------------------------------------------------------------------------*/
char NOME_DO_ARQUIVO2[13];
printf("Digite o nome do arquivo-2 : ");
fgets(NOME_DO_ARQUIVO2,12,stdin);
for(j=0; NOME_DO_ARQUIVO2[j]; j++)
{
if(NOME_DO_ARQUIVO2[j]=='\n')
{
/**Elimina o \n da string lida */
NOME_DO_ARQUIVO2[j]=0;
}
}
/**abre o arquivo em modo de ler("rb") */
if(!(E = fopen(NOME_DO_ARQUIVO2,"rb")))
{
printf("Erro! Impossivel abrir o arquivo %s!\n", NOME_DO_ARQUIVO2);
exit(0);
}
/*------------------------------------------------------------------------*/
int re=0;
while(!feof(E))
{ re++;
ch = getc (E);
if(ferror(E))
{
printf("erro lendo o arquivo");
break;
}
}
rewind(E);
int xx=0;
while(xx<re-1)
{
xx++;
ch = getc (E);
if(ferror(E))
{
printf("erro lendo o arquivo");
break;
}
putc (ch, p);
if(ferror(p))
{
printf("erro na gravacao do arquivo");
break;
}
}
fclose(p);
fclose(E);
clrscr();
}
// - 56
//*********************************************************************************
//**************************** Usando o #define ***********************************
//*********************************************************************************
//******************************* define.cpp **************************************
#include <stdio.h>
#define max(A, B) ((A) > (B) ? (A) : (B))
main ()
{
float x,n,m;
printf("digite n:");
scanf("%f", &n);
printf("digite m:");
scanf("%f", &m);
x = max( n , m );
printf (" n = %f, m = %f, x = %f", n,m,x);
}
// - 57
//*********************************************************************************
//**************************** escrevendo em um arquivo ***************************
//*********************************************************************************
//*********************************** editor.cpp **********************************
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
main ()
{
int i;
char ch;
char NOME_DO_ARQUIVO[13];
FILE *p;
printf("\n --- EDITOR ------------( para sair use \"*\" e <ENTER> )\n");
printf("\nDigite o nome do arquivo : ");
fgets(NOME_DO_ARQUIVO,12,stdin);
for(i=0; NOME_DO_ARQUIVO[i]; i++)
{
if(NOME_DO_ARQUIVO[i]=='\n')
{
/**Elimina o \n da string lida */
NOME_DO_ARQUIVO[i]=0;
}
}
/**abre o arquivo em modo de acrescentar("a") */
if(!(p = fopen(NOME_DO_ARQUIVO,"a")))
{
printf("Erro! Impossivel abrir o arquivo %s!\n", NOME_DO_ARQUIVO);
exit(0);
}
system("cls.exe");
printf("\n --- EDITOR ------------ ( para sair use \"*\" e <ENTER> )\n");
printf("\n ---------------------------------------------------------\n\n\n");
do
{
ch = getchar();
if(ch == '*')
{
break;
}
putc(ch,p);
} while( 1 );
fclose(p);
clrscr();
}
/**pode-se usar este codigo no lugar do DO-WHILE:
------------------------------------------------------------------
for( ; ch!='*' ; ch=getchar() )
{
putc(ch,p);
}
----------------------------- OU ENTÃO ---------------------------
ch = '\n';
while(ch!='*')
{
putc(ch,p);
ch=getchar();
}
*/
// - 58
//*********************************************************************************
//******************************* STRUCT-SEEK-FEOF ********************************
//*********************************************************************************
//********************************** cidade.cpp ***********************************
/**-------- fread - rewind - fflush - fseek -------------*/
#include <stdio.h>
#include <stdlib.h>
/*----------------------------- STRUCT -----------------------------*/
struct cidades
{
int codigo;
char nome[50],uf[3];
}
cidade;
/*------------------------- FIM STRUCT -----------------------------*/
/*----------------------------- MAIN -----------------------------*/
int main(void)
{
FILE *arquivo;
int achou, cod_temp;
if ((arquivo=fopen("cidades.dat","r+b"))==NULL)
{
if ((arquivo=fopen("cidades.dat","w+b"))==NULL)
{
fprintf(stderr,"\n\tNão consegui criar o arquivo das Cidades\n");
exit(1);
}
}
do
{
printf("\nCodigo: ");
scanf("%d",&cod_temp);
fflush(stdin); // <-- OBS-1!!!!
if (cod_temp==0) break;
rewind(arquivo); // <-- OBS-2!!!!
achou=0;
while(fread(&cidade,sizeof(cidade),1,arquivo)==1 && !feof(arquivo)) //<--OBS!!!
{
if (cidade.codigo==cod_temp)
{
printf("\n---- Codigo ja cadastrado ----");
printf("\ncodigo %d", cidade.codigo);
printf("\nnome = %s", cidade.nome);
printf("\nUF = %s", cidade.uf);
printf("\n------------------------------");
printf("\n");
printf("\nTecle algo . . .");
getchar();
achou=1;
break;
}
}
if (!achou)
{
cidade.codigo=cod_temp;
printf("Nome..: ");
scanf("%s",&cidade.nome);
printf("Estado..: ");
scanf("%s",&cidade.uf);
fseek(arquivo,0,SEEK_END); //<-- OBS-3!!!
fwrite(&cidade,sizeof(cidade),1,arquivo);
}
} while(1);
fclose(arquivo);
return(0);
}
/*----------------------------- FIM MAIN -----------------------------*/
// - 59
//*********************************************************************************
//***************************** usando fopen **************************************
//*********************************************************************************
//******************************** temp.cpp ***************************************
/**Escrever um programa que crie um ficheiro de texto contendo 4 nomes
de cidades e respectivas temperaturas médias num dado dia. */
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
char *cidade[4]={"Porto", "Aveiro", "Coimbra", "Lisboa"};
float temp[4]={12.5, 11.8, 12.2, 14};
FILE *fout;
if(!(fout=fopen("exp.dat","w")))
{
printf("impossivel");
exit(1);
}
for (i=0; i<4; i++)
{
fprintf(fout,"%s %f\n", cidade[i], temp[i]);
}
fclose(fout);
printf("Escrita do ficheiro terminada\n");
}
// - 60
//*********************************************************************************
//****************** executanto um arquivo executal externo ***********************
//*********************************************************************************
//********************************* execv.cpp *************************************
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv)
{
system("C:\\path\\NOME_DO_EXECUTAVEL(pode ser com/exe");
return 0;
}
// - 61
//*********************************************************************************
//******************* gravando a sequencia de fibunaci em arquivo *****************
//*********************************************************************************
//********************************** pascal.cpp ***********************************
#include <stdio.h>
#include <stdlib.h>
main()
{
FILE *p;
if (!(p = fopen("str.txt","w")))
{
printf("Erro! Impossivel abrir o arquivo!\n");
exit(1);
}
int i, z, n;
int numero;
printf("digite o valor maximo:");
scanf(" %11d", &numero);
for(i=0, n=1; i<=n; i+n)
{
fprintf(p,"%11d ", i);
z = i;
i = n;
n = z+n;
if(numero < n)
{
break;
}
}
fclose(p);
printf("concluido");
}
// - 62
//*********************************************************************************
//****************************** invertendo frase *********************************
//*********************************************************************************
//********************************* frase.cpp *************************************
#include <stdio.h>
#include <string.h>
int main ()
{
int i=0, tamanho,j=0;
char frase [20], invertida [20];
printf("Programa inverte string com ate 20 caracteres\n");
printf("Entre com a string a ser invertida :");
gets (frase);
tamanho = strlen(frase); /*devolve o tamanho da string lida*/
for (i=tamanho;i>=0;i--)
{
invertida[j]=frase[i];
printf ("%c", invertida[j]);
j = j + 1;
}
printf("\n");
return(0);
}
// - 63
//*********************************************************************************
//***************** Programa lê Matriz 3 X 3 e busca n° solicitado ****************
//*********************************************************************************
//********************************** matriz.cpp ***********************************
#include <stdio.h>
int main ()
{
int m[3][3], l, c, busca;
/**Lendo a Matriz */
printf ("Entre com os elementos da Matriz: ");
for (l=0; l<3; l++)
{
for (c=0; c<3; c++)
{
printf ("\n Digite o elemento m[%d][%d] :", l+1, c+1);
scanf ("%d", &m[l][c]);
}
}
/**Lendo o número desejado e procurando na Matriz */
printf ("\n Digite o número a procurar: ");
scanf ("%d", &busca);
for (l=0; l<3; l++)
{
for (c=0; c<3; c++)
{
if (m[l][c] == busca)
{
printf ("\n Linha %2d e Coluna %2d", l+1, c+1);
}
}
}
}
// - 64
//*********************************************************************************
//***************************** testa se o numero é par ***************************
//*********************************************************************************
//************************************ par.cpp ************************************
#include <stdio.h>
main()
{
int NUMERO;
printf("digite um numero para saber se ele e' par: ");
scanf("%d", &NUMERO);
if (!(NUMERO % 2))
{
printf ("O numero %d e' par", NUMERO);
}
else
{
printf ("O numero %d e' impar", NUMERO);
}
}
// - 65
//*********************************************************************************
//************************************ FUNCAO *************************************
//*********************************************************************************
//*********************************** func.cpp ************************************
#include<stdio.h>
void g (void)
{
printf("g\n");
}
void f (void)
{
printf("F\n");
g();
}
int main(void)
{
f();
}
// - 66
//*********************************************************************************
//************************ salvando caracteres ANSI em txt ************************
//*********************************************************************************
//*********************************** ansi.cpp ************************************
#include<stdio.h>
#include<stdlib.h>
main()
{
FILE *p;
if(!(p=fopen("ansi.txt", "w")))
{
printf("impossivel!");
exit(1);
}
int a;
for (a=0; a!=8; a++)
fprintf(p,"%3d -- %c \t",a,a);
for (a=14; a!=26; a++)
fprintf(p,"%3d -- %c \t",a,a);
fprintf(p," 26 -- SK\t");
for (a=27; a!=259; a++)
fprintf(p,"%3d -- %c \t",a,a);
fclose(p);
}
// - 67
//*********************************************************************************
//******************************** sistem e PAUSE *********************************
//*********************************************************************************
//********************************** sist.cpp *************************************
#include <stdio.h>
#include <stdlib.h>
int main()
{
char cod;
printf("Trabalhando com ASCII =-P\n\n");
printf("Digite qualquer coisa ae:\n\n");
scanf("%c", &cod);
printf("Esse eh codigo em ASCII referente ao caractere %d: %c \n\n",cod,cod);
system("PAUSE");
return(0);
}
// - 68
//*********************************************************************************
//******************* imprime caracteres de 1 a 255 (GOTOXY) **********************
//*********************************************************************************
//********************************* gotoxy1.cpp ***********************************
#include<stdio.h>
#include<conio.h>
void main(void)
{
int cont, tela, controle=1;
clrscr();
for(tela=1, cont=1; cont<=255; cont++, tela++)
{
printf("ALT+%d = %c\n",cont,cont);
if(tela%21 == 0)
{
gotoxy(20,24); printf("Tela %d - Tecle ENTER",controle++);
getch();
clrscr();
}
}
}
// - 69
//*********************************************************************************
//******************************* fflush(stdin) ***********************************
//*********************************************************************************
//********************************** fflu.cpp *************************************
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
#define MAX 100
main(void)
{
char letras[MAX];
int cont=-1;
int maiusculas=0, total=0, minusculas=0;
clrscr();
printf("Fique livre para digitar o que quiser:\n");
printf("Para sair tecle $ e em seguida tecle <ENTER> \n\n");
do
{
cont++;
//se eu colocar fflush(stdin);
//limpa-se <enter>
scanf("%c",&letras[cont]);
++total;
if(letras[cont] >= 'A' && letras[cont] <='Z')
{
++maiusculas;
}
if(letras[cont] >='a' && letras[cont] <='z')
{
++minusculas;
}
} while(letras[cont]!='$');
printf("Numero de caracteres digitados incluindo ENTER's e ESPACOS EM BRANCO= %d",total);
printf("\nMaiusculas digitadas = %d",maiusculas);
printf("\nMinusculas digitadas = %d",minusculas);
getch();
}
// - 70
//*********************************************************************************
//***************************** usando GOTOXY *************************************
//*********************************************************************************
//****************************** gotoxy2.cpp **************************************
#include <stdio.h>
#include <conio.h>
int main()
{
clrscr();
gotoxy(10,10);
printf("Oi, estou vivo");
gotoxy(40,5);
printf("Continuo vivo, em outra posicao");
getch();
return 0;
}
// - 71
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************** gotoxy.cpp ***********************************
#include <stdio.h>
#include <conio.h>
int main()
{
clrscr();
gotoxy(10,10);
printf("Oi, estou vivo");
gotoxy(40,5);
printf("Continuo vivo, em outra posicao");
getch();
return 0;
}
// - 72
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************** apontador1.cpp *********************************
#include <stdio.h>
main()
{
char s[]= "abcd";
char *ps = s;
int i;
for (i=3; i>=0; i--)
{
printf(" apontado = %c\n", *(ps+i));
printf("!apontado = %d\n\n", (ps+i));
}
}
// - 73
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************** apontador2.cpp *********************************
#include <stdio.h>
main()
{
char STRING[100];
int n;
char *ps = gets(STRING);
printf("%s%n\n", STRING, &n);
int i=0;
for (; i<n; i++)
{
printf(" apontado = %c\n", *(ps+i));
printf("!apontado = %d\n\n", (ps+i));
}
}
// - 74
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************** apontador2.cpp ******************************
#include <stdio.h>
#include <string.h>
main()
{
char STRING[100];
char *ps = gets(STRING);
int n = strlen(STRING);
int i=0;
for (; i<n; i++)
{
printf(" apontado = %c\n", *(ps+i));
printf("!apontado = %d\n\n", (ps+i));
}
}
// - 75
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
/**--------------------- DO-WHILE.cpp ------------------*/
#include <stdio.h>
main()
{
char ch;
// se mudarmos o valor de "char ch" para "int ch"
// aparecera' uma carinha no caractere inicial
while(ch!='*')
{
printf("%c",ch);
ch=getchar();
}
}
/**--------------------- FOR.cpp ------------------*/
#include <stdio.h>
main()
{
int ch;
for( ; ch!='*' ; ch=getchar() )
{
printf("%c",ch);
}
}
// - 76
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* tamanho.cpp ***********************************
#include <stdio.h>
#include <string.h>
main()
{
int tamanho;
char STRING[100];
tamanho = strlen(gets(STRING));
printf ("tamanho da palavra é = %d", tamanho);
}
// - 77
//*********************************************************************************
//************** verificando e imprimindo a possivel existencia de um email *******
//*********************************************************************************
//************************************** email.cpp ********************************
#include <stdio.h>
#include <stdlib.h>
int main ()
{
char s[500], x[35];
int i=0, j=0;
printf("Entre com o texto: ");
gets(s);
while(s[i] != '@') /**procura pela caractere @ */
i++;
while(s[i] != ' ') /**volta procurando um espaço */
i--;
++i;
while(s[i] != ' ') /**avança lendo o e-mail */
{
x[j]=s[i];
++j;
++i;
}
printf("\n\n%s\n\n", x);
system("pause");
return (0);
}
// - 78
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* iostream.cpp **********************************
include<iostream.h>
main()
{
char t[30];
cin>>t;
cout<<t;
return(0);
}
// - 79
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <dir.h>
#include <stdlib.h>
int main()
{
chdir("c:/");
system("dir");
}
// - 80
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* iostream.cpp **********************************
#include <iostream.h>
void sample(char *s, int i=5)
{
cout << "parameter 1 = "<< s << endl ;
cout << "parameter 2 = "<< i << endl;
}
main()
{
sample("test1");
sample("test2",10);
return 0;
}
// - 81
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************** lista.cpp **************************************
#include <iostream.h>
#include <string.h>
typedef struct
{
char nome[20];
char cidade [20];
char pais[20];
}estrutura_entrada;
const int MAX=10;
estrutura_entrada lista[MAX];
int numInLista;
void entrada_nome()
{
if (numInLista < MAX)
{
cout << "Nome: ";
cin >> lista[numInLista].nome;
cout << "Cidade: ";
cin >> lista[numInLista].cidade;
cout << "Estado: ";
cin >> lista[numInLista].pais;
numInLista++;
}
else
{
cout << "Lista cheia\n";
}
}
void nome_escolhido(int i)
{
cout << endl;
cout << lista[i].nome << endl;
cout << lista[i].cidade << endl;
cout << lista[i].pais << endl;
}
void mostra_lista()
{
int i;
for (i=0; i < numInLista; i++)
{
nome_escolhido(i);
}
cout << endl;
}
void busca_nome()
{
char s[20];
int i;
int found=0;
if (numInLista==0)
{
cout << "\nLista vazia\n";
}
else
{
cout << "Entre com o nome: ";
cin >> s;
for (i=0; i < numInLista; i++)
{
if (strcmp(s,lista[i].nome)==0)
{
nome_escolhido(i);
found=1;
}
}
if (!found)
{
cout << "\nNÆo consta.\n\n";
}
}
}
void Menu_entrada()
{
cout << "\n--- Menu da lista de endereços ---\n";
cout << " 1 - Adicionar a lista\n";
cout << " 2 - Mostrar a lista\n";
cout << " 3 - Procurar nome\n";
cout << " 4 - Sair\n\n";
cout << "Entre com sua escolha: ";
}
void main()
{
char escolha[10];
int sair=0;
numInLista=0;
while (!sair)
{
Menu_entrada();
cin >> escolha;
switch(escolha[0])
{
case '1':
entrada_nome();
break;
case '2':
mostra_lista();
break;
case '3':
busca_nome();
break;
case '4':
sair=1;
break;
default:
cout << "\nEscolha inv lida.\n\n";
}
}
}
// - 82
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************* movendo.cpp *******************************
#include <stdio.h>
#include <conio.h>
#define CIMA 72
#define BAIXO 80
#define ESQ 77
#define DIR 75
void main ( )
{
int i,x,y;
char c;
char g=1;
_setcursortype(_NOCURSOR);
clrscr();
x=15;
y=10;
gotoxy(x,y);
printf("%c",g);
do
{
c = getch();
if (c == 0)
{
c=getch();
switch (c)
{
case CIMA:
gotoxy(x,y);
printf(" ");
if(y != 1)
{
y--;
}
gotoxy(x,y);
printf("%c",g);
break;
case BAIXO:
gotoxy(x,y);
printf(" ");
if (y != 24)
{
y++;
}
gotoxy(x,y);
printf("%c",g);
break;
case ESQ:
gotoxy(x,y);
printf(" ");
if (x != 80)
{
x++;
}
gotoxy(x,y);
printf("%c",g);
break;
case DIR:
gotoxy(x,y);
printf(" ");
if (x != 1)
{
x--;
}
gotoxy(x,y);
printf("%c",g);
break;
}
}
}while(c !='a');
}
// - 83
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ editor2.cpp ********************************
#include <stdio.h>
#include <stdlib.h>
void main(int argc, char *argv[])
{
FILE *fp;
char ch;
if(argc !=2)
{
printf("Voce esqueceu de entrar o nome do arquivo \n");
exit(1);
}
if((fp=fopen(argv[1],"w"))==NULL)
{
printf("Arquivo nao pode ser aberto\n");
exit(1);
}
do
{
ch = getchar();
putc(ch,fp);
} while(ch!='$');
fclose(fp);
}
// - 84
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************** hex.cpp **************************************
//mostra o que tem dentro de um arquivo em hexadecinal
#include <stdio.h>
#include <stdlib.h>
#include <alloc.h>
#ifndef __cplusplus
typedef enum { false, true } bool;
#endif
typedef unsigned char byte;
void PrintLine(const byte *line, int linesize, long pos)
{
int c;
printf("%04lX : ", pos);
for(c = 0; c < linesize; c++)
printf("%02X ", line[c]);
printf("- ");
for(c = 0; c < linesize; c++)
printf("%c", line[c] < 32 ? '.' : line[c]);
printf("\n");
}
bool ReadFromFile(const char *filename)
{
byte buffer[17];
long size, total;
FILE *file = fopen(filename, "rb");
if(!file)
return false;
total = 0;
while(!feof(file))
{
size = fread(buffer, sizeof(byte), sizeof(buffer), file);
PrintLine(buffer, size, total);
total += size;
}
fclose(file);
return true;
}
void main(int argc, char *argv[])
{
if(argc < 2)
{
printf("Uso: readfile arquivo.ext.\n");
return;
}
if(!ReadFromFile(argv[1]))
{
printf("Erro lendo arquivo %s.\n", argv[1]);
return;
}
}
// - 85
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************* frag.cpp **********************************
/**--------------------- fragmentador de arquivo ---------------------
devido a um problema que tive em colocar no dico-virtual um arquivo muito grande,
tive que bolar uma maneira de fragmenta-lo em partes menores para
pudesse reconstrui-lo mais tarde. após a fragmentação, garde os arquivos em ZIP,
pois assim evitará a auto-correção da transferencia pela ineternet.
Essa foi a solução:
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
int main()
{
FILE *ai;
char ch,g;
char arq1[20];
printf("\ndigite o nome do arquivo para dividir:");
gets(arq1);
if((ai=fopen(arq1,"rb"))==NULL)
{
printf("\nArquivo nao pode ser aberto\n");
exit(1);
}
while(!feof(ai))
{
FILE *af;
char arq2[20];
printf("\napenas <enter> para sair\n");
printf("arquivo numero:");
gets(arq2);
if((af=fopen(arq2,"wb"))==NULL)
{
printf("\nArquivo nao pode ser aberto\n");
exit(1);
}
int t=0;
while(t<=1400000)
{
ch = getc (ai);
if(ferror(ai))
{
printf("erro lendo o arquivo");
break;
}
if(feof(ai))
{
break;
}
putc (ch, af);
if(ferror(af))
{
printf("erro na gravacao do arquivo");
break;
}
t++;
}
fclose(af);
}
fclose(ai);
return(0);
}
// - 86
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ reun.cpp ***********************************
/**-------------------- reunificador de arquivo ---------------------------
- OBS: uma união de cada vez
- complemento de frag.cpp
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>
main ()
{
int i,j;
char ch;
FILE *p, *E;
/*------------------------------------------------------------------------*/
char NOME_DO_ARQUIVO1[13];
printf("\nPrograma que crescenta um arquivo em outro");
printf("\n\no primeiro nome e o que vai receber");
printf("\no segundo nome e o que vai ser acrescentado");
printf("\n\n\nDigite o nome do arquivo-1 : ");
fgets(NOME_DO_ARQUIVO1,12,stdin);
for(i=0; NOME_DO_ARQUIVO1[i]; i++)
{
if(NOME_DO_ARQUIVO1[i]=='\n')
{
/**Elimina o \n da string lida */
NOME_DO_ARQUIVO1[i]=0;
}
}
/**abre o arquivo em modo de acrescentar("ab") */
if(!(p = fopen(NOME_DO_ARQUIVO1,"ab")))
{
printf("Erro! Impossivel abrir o arquivo %s!\n", NOME_DO_ARQUIVO1);
exit(0);
}
/*------------------------------------------------------------------------*/
char NOME_DO_ARQUIVO2[13];
printf("Digite o nome do arquivo-2 : ");
fgets(NOME_DO_ARQUIVO2,12,stdin);
for(j=0; NOME_DO_ARQUIVO2[j]; j++)
{
if(NOME_DO_ARQUIVO2[j]=='\n')
{
/**Elimina o \n da string lida */
NOME_DO_ARQUIVO2[j]=0;
}
}
/**abre o arquivo em modo de ler("rb") */
if(!(E = fopen(NOME_DO_ARQUIVO2,"rb")))
{
printf("Erro! Impossivel abrir o arquivo %s!\n", NOME_DO_ARQUIVO2);
exit(0);
}
/*------------------------------------------------------------------------*/
int re=0;
while(!feof(E))
{ re++;
ch = getc (E);
if(ferror(E))
{
printf("erro lendo o arquivo");
break;
}
}
rewind(E);
int xx=0;
while(xx<re-1)
{
xx++;
ch = getc (E);
if(ferror(E))
{
printf("erro lendo o arquivo");
break;
}
putc (ch, p);
if(ferror(p))
{
printf("erro na gravacao do arquivo");
break;
}
}
fclose(p);
fclose(E);
clrscr();
}
// - 87
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include<time.h>
#include<stdio.h>
int main(void)
{
time_t timer;
timer=time(NULL);
printf("A hora local é %s.\n",asctime(localtime(&timer)));
return 0;
}
// - 88
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
/*
A função toupper usa-se para converter letras minúsculas (lower case) para
maiúsculas (upper case). Isso simplifica a sintaxe da operação de teste
de comparação do caracter digitado:
*/
#include <conio.h>
#include <ctype.h>
#include <stdio.h>
int main()
{
char c;
c = toupper(getch());
cprintf("%c",c);
return 0;
}
// - 89
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <conio.h>
int main()
{
clrscr();
cprintf( "Exemplo de \"highvideo\" y \"lowvideo\"\r\n\r\n" );
cprintf( "Este texto tem sua propria intensidade.\r\n" );
cprintf( "agora troquemos a intensidade.\r\n" );
highvideo();
cprintf( "a intensidade apartir de agora é maior.\r\n" );
cprintf( "agora trocaremos para uma menor menor.\r\n" );
lowvideo();
cprintf( "tecle algo para continuar...\r\n" );
getch();
return 0;
}
// - 90
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <conio.h>
#include <windows.h>
int main()
{
clrscr();
cprintf( "Exemplo de \"window\"\r\n\r\n" );
cprintf( "A janela será de tamanho (10,10) á (50,20).\r\n" );
window( 10, 10, 50, 20 );
cprintf( "ESTOU DENTRO DE UMA JANELA DE TEXTO.\r\n" );
cprintf( "tecle algo para continuar..." );
getch();
return 0;
}
// - 91
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <conio.h>
main()
{
clrscr();
int x, y, z=0;
for(x=0; x<80; x++)
{
for(y=0;y<25;y++)
{
unsigned char tcdesk[]=
{
x,y
};
puttext( x+1 , y+1 , x+1 , y+1 , tcdesk );
}
}
getch();
}
// - 92
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <conio.h>
int main()
{
clrscr();
cprintf( "Exemplo de \"delline\"\r\n\r\n" );
cprintf( "Esta línha será apagada\r\n" );
cprintf( "tecle para continuar..." );
getch();
gotoxy( 1, 3 );
delline();
return 0;
}
// - 93
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define ENTER 13
main()
{
clrscr();
int x, y;
for(x=0; x<80; x++)
{
for(y=0;y<25;y++)
{
unsigned char tcdesk[]=
{
219,255
};
puttext( x+1 , y+1 , x+1 , y+1 , tcdesk );
}
}
unsigned char ch;
textbackground(WHITE);
textcolor(BLACK + BLINK);
cprintf("digite **para sair.");
while(ch!='*')
{
ch=getch();
textbackground(WHITE);
textcolor(BLACK + BLINK);
if(ch==ENTER){cprintf("\n%c",ch);}else{cprintf("%c",ch);}
}
}
// - 94
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <conio.h>
#include <stdio.h>
int main()
{
clrscr();
printf( "Exemplo de \"clreol\"\n\n" );
printf( "Esta e uma mensagem\nescrita em varias linhas.\n" );
printf( "Usaremos \"gotoxy\"para coloca o cursor\n");
printf( "em uma destas linhas, para apaga-la.\n" );
printf( "tecle para continuar...\n" );
getch();
gotoxy( 1, 4 );
clreol();
getch();
return 0;
}
// - 95
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
main()
{
if (MessageBox(NULL,"certo?","titulo1",MB_YESNO | MB_ICONEXCLAMATION)==IDYES)
{
MessageBox(NULL,"voce apertou sim.","titulo2",MB_OK | MB_ICONINFORMATION);
}
else
{
MessageBox(NULL,"Fechando o programa.","titulo2",MB_OK | MB_ICONSTOP);
ShowCursor(FALSE);
}
exit(1);
}
// - 96
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* matriz_des.cpp ********************************
#include <stdio.h>
#include <stdlib.h>
main()
{
int array[100][100];
int x,y,n,i,j=0;
char l[20];
n=1;
do
{
printf ("digite o tamanho da matriz:");
scanf("%s",&l);
j = atoi(l);
}while ( j>80 );
int f = j;
for ( x=0, y=j ; x<=y ; x++, y--, n++ )
{
for ( i=x ; i<y ; i++ )
{
for ( j=x ; j<y ; j++ )
{
array[i][j] = n;
}
}
}
for ( i=0 ; i<f ; i++ )
{
for ( j=0 ; j<f ; j++)
{
printf ("%c", array[i][j]+47);
}
printf ("\n");
}
}
// - 97
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************** circulo.cpp ************************************
#include <stdio.h>
#include <stdlib.h>
#include<math.h>
main()
{
float XA, XB, yA, yB;
int A,B,K,D,n;
int array[80][80];
int x,y,i,j, R;
char l[20];
do
{
printf ("digite o raio do circulo <40:");
scanf("%s",&l);
R = atoi(l);
}while ( R>39 );
for ( x=0 ; x<78 ; x++ )
{
for ( y=0 ; y<78 ; y++ )
{
array[x][y] = 177;
}
}
for ( y=(39-R) ; y<(39+R) ; y++ )
{
XA = (39 + sqrt(R*R - pow((y-39),2)))/1.6;
XB = (39 - sqrt(R*R - pow((y-39),2)))/1.6;
A = XA;
B = XB;
K = A*1.6;
D = B*1.6;
n = y/1.6;
array[A][y] = 219;
array[B][y] = 219;
array[n][K] = 219;
array[n][D+1] = 219;
}
for ( i=0 ; i<50 ; i++ )
{
for ( j=0 ; j<79 ; j++)
{
printf ("%c", array[i][j]);
}
printf ("\n");
}
}
// - 98
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ reta.cpp ***********************************
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int a,b;
int i;
float x[100], y[100];
coordenada( int s1, int s2, int i )
{
x[i] = s1;
y[i] = s2;
}
main()
{
int mm;
int nn;
int array[100][100];
for ( mm=0 ; mm<50 ; mm++ )
{
for ( nn=0 ; nn<78 ; nn++ )
{
array[mm][nn] = 219;
}
}
//-------------------------- CORPO ----------------
int fx, fy;
// gg = numero de pontas
int gg=2;
for ( i=0 ; i<gg ; i++ )
{
printf ("digite x%d: ",i); scanf("%d",&a);
printf ("digite y%d: ",i); scanf("%d",&b);
coordenada(a,b,i);
}
int mx, my;
// --- eixo X ---
for ( i=0, mx=x[i], my=y[i] ; ; )
{
if (( y[i] - y[i+1] )!=0)
{
mx = ( (-1*my)*( x[i+1] - x[i] ) - ( x[i]*y[i+1] - x[i+1]*y[i] ) )/( y[i] - y[i+1] );
}
else
{
break;
}
if ( mx>=0 )
{
array[my][mx] = 255;
}
if ( y[i] > y[i+1] )
{
my--;
if ( my<y[i+1])
{
break;
}
}
if ( y[i] < y[i+1] )
{
my++;
if ( my>y[i+1])
{
break;
}
}
}
// --- eixo Y ---
for ( i=0, mx=x[i], my=y[i] ; ; )
{
if (( x[i] - x[i+1] )!=0)
{
my = ( (-1*mx)*( y[i] - y[i+1] ) - ( x[i]*y[i+1] - x[i+1]*y[i] ) )/( x[i+1] - x[i] );
}
else
{
break;
}
if ( my>=0 )
{
array[my][mx] = 255;
}
if ( x[i] > x[i+1] )
{
mx--;
if ( mx<x[i+1])
{
break;
}
}
if ( x[i] < x[i+1] )
{
mx++;
if ( mx>x[i+1])
{
break;
}
}
}
//-------------------- fim de CORPO ------------------
for ( mm=0 ; mm<50 ; mm++ )
{
for ( nn=0 ; nn<78 ; nn++ )
{
printf ("%c", array[mm][nn]);
}
printf ("\n");
}
}
// - 99
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* ser.cpp / cli.cpp *****************************
#include <winsock2.h>
#include <stdio.h>
main ( int argc, char *argv[] )
{
// - testando os parametros -
if ( argc < 2 )
{
printf ("Use %s <host>\n\n", argv [0]);
exit (0);
}
// - iniciando o ws_32.dll -
printf ("iniciando WSAStartup\n");
WSAData info;
WORD versao;
versao= MAKEWORD(2,2);
if ( WSAStartup ( versao, &info ) != 0 )
{
printf("erro na WSAStartup\n");
exit(1);
}
// - testando configuração de IP -
printf("verificando endereco IP ou host\n");
struct hostent *he;
he = gethostbyname (argv [1]);
if (he == NULL)
{
printf("erro no nome do host\n");
WSACleanup();
exit(1);
}
printf("IP = %s\n", inet_ntoa(*(struct in_addr *)he->h_addr));
// - declarando e criando SOCKET -
SOCKET meu_sock;
if ( ( meu_sock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf (" erro na criaao de socket\n");
WSACleanup();
exit(1);
}
printf("socket criado");
// - declarando e criando estrutura de sock -
printf("montando estrutura de socket\n");
int porta = atoi( argv[2] );
sockaddr_in meu_local;
memset(&meu_local, 0x00, sizeof(meu_local));
meu_local.sin_family = AF_INET;
meu_local.sin_port = htons( porta );
meu_local.sin_addr.s_addr = inet_addr (inet_ntoa(*(struct in_addr *)he->h_addr));
printf("estrutura de socket feita\n");
// - ligando nome de socket a estrutura -
printf ("iniciando bind local\n");
if ( bind( meu_sock, (struct sockaddr *)&meu_local,sizeof(meu_local)) == SOCKET_ERROR )
{
closesocket(meu_sock);
printf ("erro no bind\n");
WSACleanup();
exit(1);
}
printf ("bind feito\n");
// - listen -
printf ("iniciando escuta");
if ( listen (meu_sock, 1 ) == SOCKET_ERROR )
{
closesocket(meu_sock);
printf ("erro no listen\n");
WSACleanup();
exit(1);
}
printf ("detectando conexao.\n");
// - aceitando a conexão -
SOCKET clientes_sock;
sockaddr clientes_local;
int clientes_local_size = sizeof( clientes_local );
if ( ( clientes_sock = accept ( meu_sock, &clientes_local, &clientes_local_size)) == INVALID_SOCKET )
{
closesocket(meu_sock);
printf ("erro no accept\n");
WSACleanup();
exit(1);
}
// - recebendo com o recv -
printf ("enviar mensagem: \n");
char buffer[80];
do
{
gets(buffer);
if(!send(clientes_sock,buffer,80,0))
{
printf ("erro no send");
exit(1);
}
}while( strcmp(buffer,"FIN") );
// - fechando o sochet -
shutdown (meu_sock, SD_SEND);
WSACleanup();
printf ("finalizando WSAStartup");
closesocket(clientes_sock);
closesocket(meu_sock);
}
// --- CORTE ------------ cli. cpp ---------------------
#include <winsock2.h>
#include <stdio.h>
main ( int argc, char *argv[] )
{
// - testando os parametros -
if ( argc < 2 )
{
printf ("Use %s <host>\n\n", argv [0]);
exit (0);
}
// - iniciando o ws_32.dll -
printf ("iniciando WSAStartup\n");
WSAData info;
WORD versao;
versao= MAKEWORD(2,2);
if ( WSAStartup ( versao, &info ) != 0 )
{
printf("erro na WSAStartup\n");
exit(1);
}
// - testando configuração de IP -
printf("verificando endereco IP ou host\n");
struct hostent *he;
he = gethostbyname (argv [1]);
if (he == NULL)
{
printf("erro no nome do host\n");
WSACleanup();
exit(1);
}
printf("IP = %s\n", inet_ntoa(*(struct in_addr *)he->h_addr));
// - declarando e criando SOCKET -
SOCKET meu_sock;
if ( ( meu_sock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf (" erro na criaao de socket\n");
WSACleanup();
exit(1);
}
printf("socket criado");
// - declarando e criando estrutura de sock -
printf("montando estrutura de socket\n");
int porta = atoi( argv[2] );
sockaddr_in meu_local;
memset(&meu_local, 0x00, sizeof(meu_local));
meu_local.sin_family = AF_INET;
meu_local.sin_port = htons( porta );
meu_local.sin_addr.s_addr = inet_addr (inet_ntoa(*(struct in_addr *)he->h_addr));
printf("estrutura de socket feita\n");
// - ligando nome de socket a conexao -
printf ("iniciando connect\n");
if ( connect( meu_sock, (struct sockaddr *)&meu_local, sizeof(meu_local) ) == SOCKET_ERROR )
{
closesocket(meu_sock);
printf ("erro no connect\n");
WSACleanup();
exit(1);
}
printf ("connect feito\n");
// - recebebendo com o recv -
printf ("mensagem recebida: \n");
char buffer[80];
do
{
if ( !(recv(meu_sock,buffer,80,0)))
{
printf ("erro no recv");
exit(1);
}
printf("%s\n",buffer);
}while ( strcmp(buffer,"FIN") );
// - fechando o sochet -
shutdown (meu_sock, SD_SEND);
WSACleanup();
printf ("finalizando WSAStartup");
closesocket(meu_sock);
}
// - 100
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
// ----------------- kkser.cpp
#include <winsock2.h>
#include <stdio.h>
void main(void)
{
// - iniciando o ws_32.dll -
printf ("iniciando WSAStartup\n");
WSAData info;
WORD versao;
versao= MAKEWORD(2,2);
if ( WSAStartup ( versao, &info ) != 0 )
{
printf("erro na WSAStartup\n");
exit(1);
}
struct sockaddr_in me, target;
SOCKET sock;
sock=socket(AF_INET,SOCK_DGRAM,0);
char linha[81];
memset((char *)&me,0,sizeof(me));
me.sin_family=AF_INET;
me.sin_addr.s_addr=htonl(INADDR_ANY); /**endereco IP local */
me.sin_port=htons(0); /**porta local (0=auto assign) */
bind(sock,(struct sockaddr *)&me,sizeof(me));
memset((char *)&target,0,sizeof(target));
target.sin_family=AF_INET;
target.sin_addr.s_addr=inet_addr("127.0.0.1"); /**host local */
target.sin_port=htons(8450); /**porta de destino */
do
{
gets(linha);
sendto(sock,linha,81,0,(struct sockaddr *)&target,sizeof(target));
}
while(strcmp(linha,"exit"));
// - fechando o sochet -
shutdown (sock, SD_SEND);
WSACleanup();
printf ("finalizando WSAStartup");
closesocket(sock);
}
// --- CORTA ------- kkcli.cpp
#include <winsock2.h>
#include <stdio.h>
void main(void)
{
// - iniciando o ws_32.dll -
printf ("iniciando WSAStartup\n");
WSADATA info;
WORD versao;
versao= MAKEWORD(2,2);
if ( WSAStartup ( versao, &info ) != 0 )
{
printf("erro na WSAStartup\n");
exit(1);
}
struct sockaddr_in me, from;
SOCKET sock;
sock=socket(AF_INET,SOCK_DGRAM,0);
int adl=sizeof(me);
char linha[81];
memset((char *)&me,0,sizeof(me));
me.sin_family=AF_INET;
me.sin_addr.s_addr=htonl(INADDR_ANY); /**endereco IP local */
me.sin_port=htons(8450); /**porta local */
if(SOCKET_ERROR!=bind(sock,(struct sockaddr *)&me,sizeof(me)))
do
{
recvfrom(sock,linha,81,0,(struct sockaddr *)&from,&adl);
puts(linha);
}
while(strcmp(linha,"exit"));
else puts("Porta ocupada");
// - fechando o sochet -
shutdown (sock, SD_SEND);
WSACleanup();
printf ("finalizando WSAStartup");
closesocket(sock);
}
// - 101
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************* lista.cpp ***************************************
//struct ffblk {
// long ff_reserved;
// long ff_fsize; /**file size */
// unsigned long ff_attrib; /**attribute found */
// unsigned short ff_ftime; /**file time */
// unsigned short ff_fdate; /**file date */
// char ff_name[256]; /**found file name */
// };
#include <dir.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main(void)
{
struct ffblk ff;
int done;
int total=0;
int pause = 0;
done = findfirst("*.exe",&ff,0);
while ( !done )
{
total++;
printf(" %s\n", ff.ff_name);
done = findnext(&ff);
pause++;
if (pause == 20)
{
printf ("\n");
system("pause");
printf ("\n");
pause = 0;
}
}
printf("---------------------------------\n");
printf(" total de arquivos = %d", total);
printf ("\n");
return total;
}
// - 102
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ memmove.cpp ********************************
#include <stdio.h>
#include <string.h>
int main()
{
char a[8] = "abcdefg";
char *ptr;
int i;
memmove( ptr, a, 5 );
for( i=0; i<7; i++ )
{
printf( "a[%d]=%c\n", i, a[i] );
}
printf( "\n\n\n" );
for( i=0; i<5; i++ )
{
printf( "ptr[%d]=%c\n", i, ptr[i] );
}
printf( "\n" );
return 0;
}
// - 103
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ strtok.cpp *********************************
#include <stdio.h>
#include <string.h>
int main()
{
char s1[15] = "abcd efgh ijlme";
char *s2 = "ha"; //<--------------- letras escolhidas para serem excluidas
char *ptr;
printf( "s1=%s\n", s1 );
ptr = strtok( s1, s2 );
do
{
printf( "-%s", ptr );
}while( (ptr = strtok( NULL, s2 )) != NULL );
return 0;
}
// - 104
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************** strrchr.cpp ************************************
/*
pega a ultima string depois do 'a'
- strrchr -
oposto de (memchr)
*/
#include <stdio.h>
#include <string.h>
int main()
{
char s[11] = "Ola amigos";
char c = 'a';
printf( "s=%s\t", s );
printf( "c=%c\n", c );
printf( "strrchr=%s\n", strrchr( s, c ) );
return 0;
}
// - 105
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//******************************** memchr.cpp *************************************
/*
pega a primeira string antes do 'a'
- memchr -
oposto de (strrchr)
*/
#include <stdio.h>
#include <string.h>
int main()
{
char str[] = "Erase uma vez...";
char *pontero;
pontero = (char *)memchr( str, 'a', 5 );
printf( "%s\n", str);
printf( "%s\n", pontero );
return 0;
}
// - 106
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ atexit.cpp *********************************
#include <stdio.h>
#include <stdlib.h>
void antes_de_salir(void)
{
puts( "vamos..." );
}
int main( void )
{
atexit( antes_de_salir );
puts( "digite algo antes de sair." );
getchar();
return 0;
}
// - 107
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//********************************* modf.cpp **************************************
/*
pega a parte decimal
*/
#include <stdio.h>
#include <math.h>
int main()
{
double valor = 6.54321, *iptr, resultado;
resultado = modf( valor, iptr );
printf( "modf( %f, %f ) = %f\n", valor, *iptr, resultado );
return 0;
}
// - 108
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//************************************ fabs.cpp ***********************************
/**- modulo de um valor - */
#include <stdio.h>
#include <math.h>
int main()
{
float x = -6.54321;
printf( "fabs( %f ) = %f\n", x, fabs(x) );
return 0;
}
// - 109
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include<stdio.h>
#include<conio.h>
#include<graphics.h>
#define LEFT 75
#define RIGHT 77
#define UP 72
#define DOWN 80
#define ESC 27
#define PASSO 5
#define RAIO 50
void opengraph(void);
main()
{
int key, x, y;
key = 0;
x = 100;
y = 100;
opengraph();
do
{
circle(x, y, RAIO);
key = getche();
cleardevice();
if(key == LEFT) x = x - PASSO;
if(key == RIGHT) x = x + PASSO;
if(key == UP) y = y - PASSO;
if(key == DOWN) y = y + PASSO;
}while(key != ESC);
closegraph();
return(0);
}
void opengraph(void)
{
int driver, mode;
detectgraph(&driver, &mode);
initgraph(&driver, &mode, "");
}
// - 110
//*********************************************************************************
//********************************** PERMUTA.C ************************************
//*********************************************************************************
//*********************************************************************************
#include <stdio.h>
#include <stdlib.h>
char *cresc[50];
int fim,n,maximo,pot,nume=1;
FILE *fp;
char *recebidos;
//******************************************************
int potencia(int valor)
{
if(valor>1)
{
valor*= potencia( valor-1 );
}
return (valor);
}
//******************************************************
int se(int i, int a)
{
if(a>0)
{
int novamente = se(i, a-1);
if( (cresc[i]!=cresc[a]) && (novamente) )
{
fim = 1 ;
}
else
{
fim = 0 ;
}
}
if(a==0)
{
if(cresc[i]!=cresc[a])
{
fim = 1 ;
}
else
{
fim = 0 ;
}
}
if(a==-1)
{
fim = 1 ;
}
return (fim);
}
//******************************************************
void proxima(int i, int maximo)
{
int r;
i++;
for(r=0; r<=maximo-1; r++ )
{
cresc[i]=&recebidos[r];
if(se(i, i-1))
{
proxima(i,maximo);
if(i==maximo-1)
{
for(n=0; n<=maximo-1; n++)
{
putc(*cresc[n],fp);
}
fprintf(fp, "= sequencia num-%i \n", nume );
if((nume==pot)&&(maximo!=0))
{
fprintf(fp,"fim");
}
nume++;
}
}
}
}
//******************************************************
void main()
{
int entrada;
int r,i;
printf("de a quantidade de letras:");
scanf("%d", &maximo);
printf("agora digite os caracteres.\n");
if( (fp=fopen("permuta.txt", "w"))==NULL )
{
printf("nao foi possivel abrir esse arquivo.");
exit (1);
}
for(entrada=0; entrada<maximo; entrada++)
{
printf("\nValor:");
recebidos[entrada]=getche();
}
printf("\n");
pot=potencia(maximo);
for( i=0, r=0; r<=maximo-1; r++ )
{
cresc[i]=&recebidos[r];
if((maximo!=1)&&(maximo!=0))
{
proxima(i,maximo);
}
else
{
fprintf(fp, " %c = sequencia num-1 \nfim ", *cresc[i]);
}
}
fclose(fp);
}
// - 111
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
#include <stdio.h>
#include <string.h>
#define SIZE 80
void main(void)
{
char buf1[SIZE], buf2[SIZE];
strcpy(buf1, "Quando, no curso do ...");
memcpy(buf2, buf1, SIZE);
printf(buf2);
}
// - 112
//*********************************************************************************
//*********************************************************************************
//******************************** JOGO DA VELHA **********************************
//*********************************************************************************
#include <stdio.h>
#include <stdlib.h>
//*********************variaveis globais ********************
char tecla[9]={'1','2','3','4','5','6','7','8','9'};
struct image
{
char caractere;
int valor;
};
struct image posicao[9];
char quem_comeca,contra_quem;
int vez=0;
char computador;
//***********************************************************
char primeira_jogada()
{
printf("\nvoce comeca? (S/N) ");
quem_comeca=getch();
if((quem_comeca=='S')||(quem_comeca=='s'))
{
computador='X';
}
else
{
computador='O';
}
}
//***********************************************************
char inicio()
{
printf("\n\njogar contra o computador? (S/N)");
contra_quem=getch();
if((contra_quem=='S')||(contra_quem=='s'))
{
primeira_jogada();
}
else
{
computador='Z';
}
}
//***********************************************************
void tabuleiro()
{int x;
printf(" use os numeros para jogar ou \"Q\" para sair\n\n");
printf(" \x37\xb3\x38\xb3\x39 %c\xb3%c\xb3%c\n",posicao[6].caractere,posicao[7].caractere,posicao[8].caractere);
printf(" \xc4\xc5\xc4\xc5\xc4 \xc4\xc5\xc4\xc5\xc4\n");
printf(" \x34\xb3\x35\xb3\x36 %c\xb3%c\xb3%c\n",posicao[3].caractere,posicao[4].caractere,posicao[5].caractere);
printf(" \xc4\xc5\xc4\xc5\xc4 \xc4\xc5\xc4\xc5\xc4\n");
printf(" \x31\xb3\x32\xb3\x33 %c\xb3%c\xb3%c\n",posicao[0].caractere,posicao[1].caractere,posicao[2].caractere);
printf("\n\n\n");
for(x=0; x<9; x++)
printf("valor-%i = %i\n", x, posicao[x].valor);
}
//***********************************************************
char ver_quem_joga(int vezz)
{
char quem_joga_e;
if(vezz%2)
{
quem_joga_e='X';
}
else
{
quem_joga_e='O';
}
return (quem_joga_e);
}
//***********************************************************
char jogada(char kk,int quem_joga_e,int peso)
{
int ii, marca=0;
for(ii=0; ii<9; ii++)
{
if((kk==tecla[ii])&&(posicao[ii].caractere==' '))
{
posicao[ii].caractere=quem_joga_e;
posicao[ii].valor=peso;
marca=1;
}
}
if(marca==0)
{
kk='N';
}
else
{
kk=quem_joga_e;
}
return (kk);
}
//***********************************************************
char escolha_do_PC(int peso)
{
char *livres, *testes, *casas_totais, *marcados;
int maximo=0, i, maximo2=0;
for(i=0; i<9; i++)
{
casas_totais[i]=posicao[i].caractere;
}
for(i=0; i<9; i++)
{
if(casas_totais[i]==' ')
{
livres[maximo]=casas_totais[i];
maximo++;
}
else
{
marcados[maximo2]=casas_totais[i];
maximo2++;
}
}
/* maximo--;
maximo2--;
return(livres[maximo]);*/
}
//***********************************************************
void pega_jogada(int peso, char quem_joga_e)
{
char kk;
do
{
if(quem_joga_e==computador)
{
kk=escolha_do_PC(peso);
}
else
{
kk=getch();
}
if((kk=='q')||(kk=='Q'))
{
exit (1);
}
kk=jogada(kk,quem_joga_e,peso);
}while(kk== 'N');
}
//***********************************************************
int julgamento(int peso)
{
if((
((posicao[0].valor+posicao[1].valor+posicao[2].valor)!=3*peso )&&
((posicao[3].valor+posicao[4].valor+posicao[5].valor)!=3*peso )&&
((posicao[6].valor+posicao[7].valor+posicao[8].valor)!=3*peso )&&
((posicao[0].valor+posicao[4].valor+posicao[8].valor)!=3*peso )&&
((posicao[2].valor+posicao[4].valor+posicao[6].valor)!=3*peso )&&
((posicao[0].valor+posicao[3].valor+posicao[6].valor)!=3*peso )&&
((posicao[1].valor+posicao[4].valor+posicao[7].valor)!=3*peso )&&
((posicao[2].valor+posicao[5].valor+posicao[8].valor)!=3*peso )
)&&!(
(posicao[0].caractere!=' ')&&
(posicao[1].caractere!=' ')&&
(posicao[2].caractere!=' ')&&
(posicao[3].caractere!=' ')&&
(posicao[4].caractere!=' ')&&
(posicao[5].caractere!=' ')&&
(posicao[6].caractere!=' ')&&
(posicao[7].caractere!=' ')&&
(posicao[8].caractere!=' ')
))
{
return (1);
}
else
{
return (0);
}
}
//***********************************************************
int objetivo(int peso)
{
if(
((posicao[0].valor+posicao[1].valor+posicao[2].valor)==3*peso )||
((posicao[3].valor+posicao[4].valor+posicao[5].valor)==3*peso )||
((posicao[6].valor+posicao[7].valor+posicao[8].valor)==3*peso )||
((posicao[0].valor+posicao[4].valor+posicao[8].valor)==3*peso )||
((posicao[2].valor+posicao[4].valor+posicao[6].valor)==3*peso )||
((posicao[0].valor+posicao[3].valor+posicao[6].valor)==3*peso )||
((posicao[1].valor+posicao[4].valor+posicao[7].valor)==3*peso )||
((posicao[2].valor+posicao[5].valor+posicao[8].valor)==3*peso ))
{
return (1);
}
else
{
return (0);
}
}
//***********************************************************
void main()
{
char kk;
char quem_joga_e;
int peso,i;
for(i=0; i<9; i++)
{
posicao[i].caractere=' ';
posicao[i].valor=0;
}
clrscr();
inicio();
clrscr();
tabuleiro();
do
{
quem_joga_e=ver_quem_joga(vez);
if(quem_joga_e=='X')
{
peso=1;
}
else
{
peso=-1;
}
pega_jogada(peso, quem_joga_e);
clrscr();
tabuleiro();
vez++;
}while( julgamento(peso) );
if(objetivo(peso))
{
if(vez%2)
{
printf("\n vitoria de \"O\"!\n");
}
else
{
printf("\n vitoria de \"X\"!\n");
}
}
else
{
printf("\n EMPATE!\n");
}
}
// - 113
//*********************************************************************************
//******************************* QUADRADOS MAGICOS *******************************
//*********************************************************************************
//*********************************************************************************
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
int n,maximo,fim;
int planetario;
int **quadrado;
int *cresc;
int raiz;
FILE *fp;
//******************************************************
int *aloca_cresc()
{
cresc = (int )malloc(sizeof(int) **16);
if(!cresc)
{
printf("erro na alocacao de *aloca_cresc");
return 0;
}
}
//******************************************************
void deleta_cresc(int *cresc)
{
if(cresc)
{
free(cresc);
}
}
//******************************************************
void deleta_quadrado(int **quadrado)
{
int cy;
for(cy = 0; cy < 4; cy++)
if(quadrado[cy])
{
free(quadrado[cy]);
}
if(quadrado)
{
free(quadrado);
}
}
//******************************************************
int **aloca_quadrado()
{
int cy;
int **quadrado;
quadrado = (int **)malloc(sizeof(int *) **4);
if(!quadrado)
{
printf("erro na alocacao de *aloca_quadrado");
return 0;
}
for(cy = 0; cy < 4; cy++)
{
quadrado[cy] = (int *)malloc(sizeof(int) **4);
if(!quadrado[cy])
{
deleta_quadrado(quadrado);
printf("erro na alocacao de **aloca_quadrado");
return 0;
}
}
return quadrado;
}
//******************************************************
int linha(int ih)
{
int jh;
int valorh;
valorh = 0;
for(jh=0; jh<raiz; jh++)
{
valorh += quadrado[ih][jh];
}
return (valorh);
}
//******************************************************
int todas_linhas(int ih)
{
if(ih<raiz)
{
if( (linha(ih)==planetario)&&(todas_linhas(ih+1)) )
{
return (1);
}
else
{
return (0);
}
}
else
{
return (1);
}
}
//******************************************************
int coluna(int jh)
{
int ih;
int valorh;
valorh = 0;
for(ih=0; ih<raiz; ih++)
{
valorh += quadrado[ih][jh];
}
return (valorh);
}
//******************************************************
int todas_colunas(int jh)
{
if(jh<raiz)
{
if( (coluna(jh)==planetario)&&(todas_colunas(jh+1)) )
{
return (1);
}
else
{
return (0);
}
}
else
{
return (1);
}
}
//******************************************************
int diagonal1()
{
int ih, valorh=0;
for(ih=0; ih<raiz; ih++)
{
valorh+=quadrado[ih][ih];
}
if(valorh==planetario)
{
return (1);
}
else
{
return (0);
}
}
//******************************************************
int diagonal2()
{
int ih, valorh=0;
for(ih=0; ih<raiz; ih++)
{
valorh+=quadrado[ih][raiz-ih-1];
}
if(valorh==planetario)
{
return (1);
}
else
{
return (0);
}
}
//******************************************************
void iguala_aos_permutados()
{
int nn, jj, n=0;
for(nn=0; nn<raiz; nn++)
{
for(jj=0; jj<raiz; jj++)
{
quadrado[nn][jj]=cresc[n];
n++;
}
}
}
//******************************************************
void imprime()
{
int mh,nh;
for(nh=0; nh<raiz; nh++)
{
for(mh=0; mh<raiz; mh++)
{
fprintf(fp,"- %i ", quadrado[nh][mh]);
}
fprintf(fp,"\n");
}
fprintf(fp,"\n\n");
}
//******************************************************
void compara()
{
if((todas_colunas(0))&&(todas_linhas(0))&&(diagonal2())&&(diagonal1()))
{
imprime();
}
}
//******************************************************
int se(int i, int a)
{
if(a>0)
{
if( (cresc[i]!=cresc[a]) && (se(i, a-1)) )
{
fim = 1 ;
}
else
{
fim = 0 ;
}
}
if(a==0)
{
if(cresc[i]!=cresc[0])
{
fim = 1 ;
}
else
{
fim = 0 ;
}
}
if(a==-1)
{
fim = 1 ;
}
return (fim);
}
//******************************************************
void proxima(int i, int maximo)
{
int n=0,nn,jj;
i++;
for(cresc[i]=1; cresc[i]<=maximo; cresc[i]++ )
{
if(se(i, i-1))
{
proxima(i,maximo);
if(i==maximo-1)
{
iguala_aos_permutados();
compara();
}
}
}
i--;
}
//******************************************************
main()
{
int i;
if( (fp=fopen("permuta.txt", "w"))==NULL )
{
printf("nao foi possivel abrir esse arquivo.");
exit (1);
}
i=0;
printf("achando todos os possiveis quadrados magicos de 3x3.\n");
printf(" aguarde...\n");
raiz=3;//******************aqui foi colocado o valor da matriz
maximo=raiz*raiz;
planetario= (((raiz*raiz*raiz)+raiz)/2);
cresc=aloca_cresc();
quadrado=aloca_quadrado();
for(cresc[i]=1; cresc[i]<=maximo; cresc[i]++ )
{
if(maximo>1)
{
proxima(i,maximo);
}
else
{
printf("%i = sequencia num-%i\nfim", cresc[0], 1);
}
}
deleta_quadrado(quadrado);
deleta_cresc(cresc);
fclose(fp);
printf("Feito!");
}
// - 114
//*********************************************************************************
//************************************* exercicio *********************************
//*********************************************************************************
//******************************* strcpy, memcpy, struct **************************
#include <stdio.h>
#include <string.h>
#include <mem.h>
#define SIZE 80
struct teste
{
char letra;
int numero;
};
struct teste luiz;
void main(void)
{
char buf1[SIZE], buf2[SIZE], buf3[SIZE];
strcpy(buf1, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
memcpy(buf2, buf1, SIZE);
printf("%s\n\n",buf2);
luiz.numero = 0;
luiz.letra = 'd';
memset(&luiz,'g',0);
printf("%c\n",luiz.letra);
printf("%i\n\n",luiz.numero);
memset(buf2, '0', 27);
strcpy(buf3, "Quando, no curso do ...");
memcpy(buf2, buf3, 23);
printf("%s\n",buf2);
}
// - 115
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
//*********************************************************************************
DICA - Manipulando Arquivos
O C/C++ possibilita a total manipulação de grandes arquivos de uma maneira altamente
eficaz através de comandos e funções. Dominá-los é pré-requisito para aqueles que
pretendem programar nessa linguagem. Veja como executar as principais ações de
manipulação de arquivos:
Gravação de Dados
Os dados podem ser gravados em arquivos de três maneiras diferentes: formatados, como
conjunto de caracteres ou como estruturas.
Arquivos Formatados:
Neles, você deve utilizar a função fprintf(), que é uma derivação da função printf() e
que possui a seguinte sintaxe:
fprintf(nome_do_ponteiro_de_arquivo, "tipo_de_dados", dados);
Para iniciar a abertura do arquivo, você pode utilizar a função fopen(), cuja sintaxe é
a seguinte:
poteiro_de_arquivo = fopen("nome_do_arquivo", "codigo");
Onde:
O nome do arquivo deve ser uma string de caracteres que compreende um nome de arquivo
válido e onde possa ser incluída uma especificação de caminho (path). Já o código deve
ser uma string contendo o estado desejado para abertura.
Veja a tabela com os valores que poderão ser colocados no código e o seu significado:
Código Significado
"r" Abre um arquivo para leitura.
"w" Cria um arquivo para escrita.
"a" Acrescenta dados para um arquivo existente.
"rb" Abre um arquivo binário para leitura.
"wb" Cria um arquivo binário para escrita.
"ab" Acrescenta dados a um arquivo binário existente.
"r+" Abre um arquivo para leitura/escrita.
"w+" Cria um arquivo para leitura/escrita
"a+" Acrescenta dados ou cria um arquivo para leitura/escrita.
"r+b" Abre um arquivo binário para leitura/escrita.
"w+b" Cria um arquivo binário para leitura/escrita.
"a+b" Acrescenta ou cria um arquivo binário para leitura/escrita.
"rt" Abre um arquivo texto para leitura.
"wt" Cria um arquivo texto para ecrita.
"at" Acrescenta dados a um arquivo texto.
"r+t" Abre um arquivo texto para leitura/escrita.
"w+t" Cria um arquivo texto para leitura/escrita.
"a+t" Acrescenta dados ou cria um arquivo texto para leitura/escrita.
Exemplo de uso da função:
------------------------------------------
#include <stdio.h>
#include <conio.h>
void main()
{
FILE *fp; // Ponteiro do arquivo
char texto[] = {"Turbo C++ Page"}; // Armazena string na variável
fp = fopen("Arq.txt", "w"); // Abre o arquivo como modo escrita
fprintf(fp, "%s", texto); // imprime string de texto dentro do arquivo
fclose(fp); // Fecha ponteiro do arquivo
getch(); // Espera uma tecla ser pressionada
}
------------------------------------------------
Entenda: Neste programa foi declarada uma string constante chamada texto, que recebeu o tipo de
formatação "%s" na função fprintf.
No diretório padrão, foi criado um arquivo ASCII chamado Arq.txt, que recebeu a string
Turbo C++ Page. A função fclose foi usada para fechar o arquivo.
Conjunto de caracteres
Neles, você deve utilizar a função puts no lugar de fprintf. Para isso, utilize a sintaxe:
puts(caracter, ponteiro_para_o_arquivo);
Estruturas
Nesse caso, substitua essas funções pale fwrite. Veja a sua sintaxe:
fwrite(estrutura, tamanho(estrutura), índice, ponteiro_do_arquivo);
Acompanhe o exemplo:
----------------------------
#include <stdio.h>
#include <conio.h>
#include <string.h>
typedef struct entrada
{
char nome[20];
float deve;
};
void main()
{
FILE *fp;
entrada meus_dados[15];
strcpy(meus_dados[0].nome, "Luiz");
meus_dados[0].deve = 0.001;
strcpy(meus_dados[1].nome, "Elaine");
meus_dados[1].deve = 13.89;
fp = fopen("escritor.dat", "w");
fwrite(meus_dados, sizeof(meus_dados), 1, fp);
fclose(fp);
getch()
}
--------------------
Leitura de Arquivos
Existem três formas diferentes de se ler um arquivo. Ele pode estar formatado,
unido em um conjunto ou com a estrutura inteira. No primeiro caso, você deve
utilizar a função fscanf, que possui a sintaxe:
fscanf(ponteiro_de_arquivo, "tipo das variáveis", variáveis);
No segundo caso, utilize a função getc e, para o terceiro, a função fread que
possui a sintaxe:
fread(estrutura, tamanho(estrutura), índice, ponteiro_do_arquivo);
