Programação Orientada a Objeto.

A priore a compreensão do que é uma classe não é nada complicado. Para provar isso vamos usar o seguinte exemplo: Você está no meio de um projeto e recebe a função de criar uma "coisa" que imprima qual a percentagem de um valor x em relação a um valor y. Essa coisa que você vai criar pode ser uma classe, uma classe que vai ter 3 variáveis(atributos), x, y e resultado, dos quais 2 deles(x e y) seram passados pelo usuário e possuirá 3 funções(métodos), que nesse caso seram, setXY(), getXY(), showXY() .

Montando uma classe
Iremos fazer uso de um pseudocódigo para criação da estrutura dessa classe.

percentagem
-------------------------------
x : Integer
y : Integer
resultado : Integer
-------------------------------
setXY(x : Integer , y : Integer) : Integer
getXY(x : Integer , y : Integer) : Integer
showXY(x : Integer , y : Integer) : void

Temos aí o que seria uma representação de uma classe percentagem usando UML.

Conclusão
As classes por si só são simples, na verdade, é um tipo de dados não primário. Elas possibilitam a organização de grandes projetos com pouco esforço, em comparação com as linguagens que são restritamente estruturadas.

Jogo dos Quadradinhos em C

Esse joguinho foi um trabalho em equipe da disciplina de Programação Estruturada do 2o semestre do curso de Eng. de Tele. Espero que o código-fonte possa ser útil para aqueles que estão iniciando na linguagem e querem entender um pouco de como funciona a estruturação do código.


#include
#include
#include


int VetTab[] = { 1, 2, 3, 4, 5, 6, 7, 8, 0 }; // "Tabuleiro"
int VetPos[][5] = {
4, 2, 0, 0, 0, // Posição 1 (possiveis movimentações)
1, 3, 5, 0, 0, // Posição 2
6, 2, 0, 0, 0, // Posição 3
7, 1, 5, 0, 0, // Posição 4
2, 4, 6, 8, 0, // Posição 5
3, 5, 9, 0, 0, // Posição 6
4, 8, 0, 0, 0, // Posição 7
7, 5, 9, 0, 0, // Posição 8
6, 8, 0, 0, 0 // Posição 9
} ;


/* Retorna a posição em que se encontra o elemento 0, que no caso é o termo
usado como referencia para indicar onde não temos um quadro. */

int APosicao()
{
int i = 0;
for(i = 0; i< i =" 0," opcoes =" 0;" i =" 0;" i ="=" i =" 0;" i =" 0;" i =" 0;" i =" 1" i =" 0;" ok =" 0," i =" 0;" ok ="=" escolha =" 0," sorteios =" 0," jogadas =" 0;" escolha =" escolharandomica(APosicao());" escolha2 =" getch();" escolha =" escolha2-48;" escolha =" 0;" jogadas ="="> 0 && jogadas <= 10) printf("Qm sabe se tentasse um pouco mais.\nNumero de jogadas: %d", jogadas+1); if(jogadas > 10 ) printf("Qm sabe se tivesse tentando um pouco mais?\nNumero de jogadas: %d", jogadas+1);
if(jogadas > 1000) printf("Imagine se fosse um CUBO MAGICO hein?\n Pode colocar vidas e vidas pra terminar.\n Numero de jogadas: %d", jogadas+1);
}
else {
MostrarTab();
printf("Parabens, voce ganhou com %d jogadas.\n", jogadas);
}
printf("\n\n\nAte a proxima!\n\n\n\n");
system("pause");
}

N primeiros números primos.

#include< stdio.h>
#include< stdlib.h>

int main() {

int i = 0;
int i2 = 0;
int primo = 0;
int nprimo = 0;

printf("digite o numero");
scanf("%d", &nprimo);

while(primo != nprimo){
int divisor = 0;
i+=1;
for(i2 = i; i2>= 1; i2--) {
if((i%i2) == 0) { divisor++;
}
}
if(i == 1) {
divisor = 2;
}
if(divisor == 2) {
printf("%d - ", i);
primo ++;
}
}
system("Pause");
}

Open GL

Open GL + Glut

glut.h -> para a pasta /include/GL/
glut32.dll -> /windows e /windows/system
glut32.lib -> /lib

obs: não esqueçer de linkar as seguintes dlls ao seu projeto.
Alt + P -> Parameters -> Linker e adicione: -lopengl32 -lglu32 -lglut32

Fibonacci

int Fibonacci(int n) {
if ((n ==1) || (n == 2) { return 1; }
else { return Fibonacci(n-2) + Fibonacci(n-1); }
}

fonte: Primeiro Curso de Porgramação em C (2a Edição)

resolução muito elegante e concisa.

Trabalho com lista encadeada.

/*
Name: Trabalho da disciplina, introdução a linguagem de programação com C
Author: David B., Ana Márcia, Priscilia.
Date: 28/03/07 22:06
Description: Lista encadeada com as funções: adicionar, pesquisar, inserir
e excluir registros.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct cliente {
int codigo;
char nome[35];
struct cliente *proximo;

} *inicio, *ultimo, *novo; // cria 3 ponteiros q iram apontar para a struct.

typedef cliente client;

int cadastrado(char str[35], int k);

int inserir()
{
int j = 0;
char nome2[35];
client p; // crio um ponteiro dentro da função inserir q aponta para a struct(escopo dele se resume a essa funcao,q uandoe la eh finalizada, ele deixa de existir, ao contrario dos outros 3 (inicio, ultimo e novo).
novo = (client *)malloc(sizeof(client)); // armazena espaço na memória para a nova struct.

if(novo == NULL) {
printf("Erro ao tentar alocar memoria.\n");
return 0;
}

printf("Digite o cod do cliente: ");
scanf("%d", &novo->codigo); //copia string q foi entrada pelo usuário no campo nome da struct apontada por novo(cliente)

printf("Digite o nome do novo cliente: ");
scanf("%s", &novo->nome); // atriubui ao campo codigo da struct client o valor q foi digitado pelo usuário

if(cadastrado(novo->nome, novo->codigo) == 1){
printf("Erro ao tentar cadastrar cliente.\nCodigo ou nome já estão em uso.\n");
return 0;
}
novo->proximo = NULL; // garante q o campo proximo da struct client esteja NULL

if(inicio == NULL) /* verifica se o ponteiro para o primeiro elemento da lista foi setado
caso esse if seja verdadeiro, então significa q o ponteiro para a
'cabeça'(primeiro elemento) não foi setado, sendo assim, esses
dados q foram inseridos ainda agora passam a ser apontados pelo
ponteiro(do tpw struct) *inicio(q tem escopo global). */
{
inicio = novo; // atribui um valor para ser o primeiro elemento da lista.
ultimo = novo; // atribui para q o *ultimo aponte para inicio;
}

else // caso o ponteiro inicio nào seja null, logo significa q inicio jah está apontando para
// o primeiro elemento da lista.
{
ultimo->proximo = novo; /* caso esteja sendo a segunda vez q vc chamou essa função
o ponteiro ultimo, continua apontando para a mesma struct
q o ponteiro inicio apontada, sendo assim, mudamos o valor
da primeira struct q foi criar para apontar para a nova struct
q acabou se ser criada
*/
novo->proximo = NULL; /* garantimos q a struct q acabo de ser criada vai apontar
para um valor null, indicando ser o ultimo elemento da lista
*/
ultimo = novo; // as ultimas informacoes digitas são atribuidas ao ponteiro ultimo q tem escopo global,,

}
return 1;

}
int limparmemoria()
{
client *p, *p2;
p2 = p = inicio;
if( inicio != NULL ){ // so liberar se tiver apontando para algum lugar(conhecido(struct))
do {
p2 = p;
p = p->proximo; // aponta para o segundo elemento;
free(p2); // libera posição q p2 está usando
}while(p != NULL);
}
exit(0);
}

int listar()
{
client *p; //cria um ponteiro para a struct cliente
p = inicio; //o ponteiro p agora aponta para o mesmo local q o *inicio está apontando.
if(inicio == NULL){ // se algum usuário jah foi adicionado
printf("Nao há clientes adicionaros\n");
}
else
{
printf("\n\n*** Listando clientes cadastrados ***\n");
do {
printf(" - Codigo: %d\n", p->codigo);
printf(" - Nome: %s\n", p->nome);
printf(" - - - - - -\n");
p = p->proximo; /*pula de uma lista para a outra,,
p agora vai apontar para a struct(client) q o campo proximo dele está apontando.
*/
}while(p != NULL);
}
system("pause");
}

int buscar(char str[35])
{
client *p; //cria um ponteiro para a struct cliente
int v = 0; // variável de verificação, se for setada em 1(cliente foi encontrado), 0(cliente nào foi encontrado);
p = inicio; // ponteiro p, do tpw client, aponta para o primeiro elemento da lista(inicio).
if(inicio == NULL){
printf("Nao há clientes cadastrados\n");
return 0;
}
else {
do {
if(!strcmp(p->nome,str)){ /*strcmp, retorna 0, caso as string seja
iguais,, o modificado !, altera, para q
se sela sejam iguais, o retorno passe a
ser 1 ao inves de 0. */
v++; // incrementa v, q sera verificado posteriormente
break;
}
p = p->proximo; // faz com q o ponteiro p aponte para a próxima struct q o campo proximo esta indicando.
} while(p != NULL);
}
if(v > 0){ // > 0 como foi mencionado,, significa q cliente procura foi encontrado.
printf("Codigo do cliente: %d\n", p->codigo);
printf("Nome do cliente: %s\n", p->nome);
return 1; // retorna 1, foi encontrado
}
else {
printf("Cliente nao encontrado.\n");
return 0;
}
}
int cadastrado(char str[35], int k)
{
client *p; //cria um ponteiro para a struct cliente
int v = 0; // variável de verificação, se for setada em 1(cliente foi encontrado), 0(cliente nào foi encontrado);
p = inicio; // ponteiro p, do tpw client, aponta para o primeiro elemento da lista(inicio).
if(inicio != NULL){
do {
if(!strcmp(p->nome,str) || p->codigo == k){
v++;
break;
}
p = p->proximo; // faz com q o ponteiro p aponte para a próxima struct q o campo proximo esta indicando.
} while(p != NULL);
}
if(v > 0){
return 1; // retorna 1, foi encontrado
}
else {
return 0;
}
}
int alterar(char str[35]) // usa o mesmo principio da funcao bucsar,,
{
client *p;
int v = 0; // variável de verificação.
p = inicio; // ponteiro p, do tpw client, aponta para o primeiro elemento da lista(inicio).
if(inicio == NULL){
printf("Nao há clientes cadastrados\n");
return 0;
}
else {
do {
if(!strcmp(p->nome,str)){
v=1;
break;
}
p = p->proximo; // faz com q o ponteiro p aponte para a próxima struct
} while(p != NULL);
}
if(v > 0){ // caso tenha sido encontrado,, permitie q o usuario entre com novos dados para o cliente.
printf(" - Codigo: %d \n - Cliente: %s\n", p->codigo, p->nome); /* o break foi usado no if() logo
quando a condição se torna verdade,
isso garante q *p está ainda apontando
para a struct da lista q o cliente
foi encontrado.
*/
printf("Alterar codigo do cliente para: \n");
scanf(" %d",&p->codigo);
printf("Alterar nome do cliente para: \n");
scanf(" %s",&p->nome);
return 1;
}
else {
printf("Cliente nao encontrado.\n");
return 0;
}
}
int deletar(char str[35]) {
int r = 0;
client *antes, *atual, *ultimoo, *pass = NULL;
antes = atual = inicio;
do {
if(!strcmp(atual->nome,str)) { // verifica se str está na struct apontada por atual

if (atual == inicio && ultimo == NULL) { // verifica se o q vai ser exlcuido eh o primeiro registro e unico da lista
free(atual); // como eh o único registro, basta usar o free.
inicio = NULL; // inicio agora recebe NULL;
r = 1;
break;
}
else if(atual == inicio) { // verifica se o q vai ser excluido eh o primeiro registro..
inicio = atual->proximo; /* como o atual esta apontando para inicio, antes
de usar o free para esse ponteiro(atual), precisamos garantir
q o inicio continue apontando para o topo da lista,
e o topo da lista agora vai ser a struct q inicio
esta apontando,, logo,, "dizemos" para q o ponteiro
*inicio, aponte para a struct q está indicada pelo
seu campo *proximo
*/
free(atual);
r = 1; // serve para fazer uma verificação,, 1, foi excluído, 2, nào foi excluído.
break;
}
else if (atual->nome == ultimo->nome) { // verifica se é o ultimo elemento da lista
ultimo->proximo = antes; /* garante q o ultimo proximo agora aponte para estruct
antes(a struct q está apontando para ultimo), verificar
fim do "do{}" para maiores detalhes.
*/
antes->proximo = NULL; /* antes passa a ser o ultimo,, por isso o campo antes
agora vai ser alterado para NULL, antes, antes estava
apontando para ultimo, sendo q ultimo vai ser deletado,
opr isso antes vai passar a a pontar para null, */
free(atual);

r = 1;

ultimo = antes;
break;
}
else { // usado quando o registro, não eh o ultimo, não eh o primeiro e não eh o único elemento da lista.
pass = atual; // pass agora aponta para o mesma struct q atual esta apontando.
pass = atual->proximo; // pass passa a apontar para a struct q o campo proximo está indicando.
antes->proximo = pass; /* antes proximo, aponta para pass e pass não está + apontando para atual e
sim para a struct q atual está apontando,, logo,,
antes->proximo q apontava para a struct atual passa a
apontar para pass(q é a struct apontada por atual)
*/
r = 1;
free(atual);
break;
}
}
else {
antes = atual; // depois q esse bloco {} eh executado uma vez,, antes eh sempre a struct q aponta para a struct atual
atual = atual->proximo; // e atual aqui passa a apontar para a struct cliente q o seu campo proximo aponta

}
} while(antes != ultimo);
if(r > 0){ return 1; } else { return 0; }
}

int main()
{
char str[35];
int a;
inicio = ultimo = novo = NULL; // garante q todos os ponteiros seja inicializado como NULL
for(;;)
{
system("cls");
printf("1. Adicionar cliente\n");
printf("2. Listar clientes cadastrados\n");
printf("3. Pesquisar por cliente\n");
printf("4. Excluir cliente\n");
printf("5. Alterar dados do cliente\n");
printf("6. Sair\nOpcao: ");
scanf("%d", &a);
switch(a)
{
case 1 : {
if(inserir() == 1) {
printf("\n\n - Cliente cadastrado com sucesso \n\n\n");
}
else {
printf("\n\n - Código ou nome do cliente jah estao em uso.\n\n\n");
}
system("pause");
break;
}
case 2 : listar(); break;
case 3 : {
printf("Nome do cliente: ");
scanf("%s", &str);
buscar(str);
system("pause");
break;
}
case 4 : {
printf("Nome do cliente que deseja excluir: ");
scanf("%s", &str);
if(deletar(str) == 1)
{
printf("\n\n - Cliente excluido com sucesso. \n\n\n");
}
else
{
printf("\n\n - Não foi possivel excluir cliente. \n\n\n");
}

}
system("pause");
break;
case 5 : {
printf("Nome do cliente: ");
scanf("%s", &str);
alterar(str);
system("pause");
break;
}
case 6 : limparmemoria();
}
}
}

Lista duplamente encadeada

A imagem tah um pouco(muito) ruin,, a lista duplamente encadeada, como o próprio nome da diz é uma lista q não aponta só para o próximo elemento,, + também para o anterior,, isso permite uma "navegação" bem avontade entre os elementos de uma lista.
Segue abaixo o exemplo de uma lista encadeada simples...

Verificador de cpf.(diz quais são os 2 últimos dígitos)

#include <stdio.h>
#include <stdlib.h>

int main()
{
int a[10], soma, r, i, j;
soma = r = i = j = 0;
for(i=0;i<9;i++){
scanf("%d", &a[i]);
}
for(i=10;i>=2;i--){
soma += a[j] * i;
j++;
}
if((soma % 11) == 0 || (soma % 11) == 1){
a[9] = 0;
}
else { a[9] = 11 - (soma % 11); }
soma = j = 0;
for(i=11;i>=2;i--){

soma += a[j] * i;
j++;
}
if((soma % 11) == 0 || (soma % 11) == 1){
a[10] = 0;
}
else { a[10] = 11 - (soma % 11); } i = 0;
do {
printf("%d", a[i]);
i++;
} while( i!=11 );
system("pause");
}

Gerador de Cpf =X

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define TOTAL 1000


int main()
{

int a[10], soma, r, i, j, gerar;
soma = r = i = j = gerar = 0;
srand(time(NULL));
for(gerar=0;gerar<=TOTAL;gerar++){
for(i=0;i<9;i++){
a[i] = rand() % 10 ;
}
for(i=10;i>=2;i--){
soma += a[j] * i;
j++;
}
if((soma % 11) == 0 || (soma % 11) == 1){
a[9] = 0;
}
else { a[9] = 11 - (soma % 11); }
soma = j = 0;
for(i=11;i>=2;i--){

soma += a[j] * i;
j++;
}
if((soma % 11) == 0 || (soma % 11) == 1){
a[10] = 0;
}
else { a[10] = 11 - (soma % 11); } i = 0;
do {
printf("%d", a[i]);
if(i == 8) { printf("-"); }
i++;
} while( i!=11 );
getchar();
}
}

Decimal -> Binário (contador)

#include <stdio.h>
#include <stdlib.h>

#define VAL 50

int tobinari(int r);
int main() {
int i =0;
int w =0;
printf("Até q valor deseja contar?\n");
scanf("%d", &w);
for(i=0;i<w;i++){ tobinari(i); }
system("pause");
}

int tobinari(int r)
{
int n[VAL];
int i;
int cont;
for(i=0;i<=VAL;i++){ n[i] = 0; }
for(i=0;i<VAL;i++){
/*
if( (r2 / 2) != 0 || (r2 % 2) > 0){ // precisa ser aprimorado!
cont++;
}
*/
n[i] = r % 2;
r = r / 2;

}
for(i=VAL;i>=0;i--){ printf("%d", n[i]); }
printf("\n");
}

Decimal -> Binário

Jeitinho fácil de ser transformado em algorítmo, para converter um número da forma decimal para a binária.

Verificar números primos dentro de um intervalo.

#include <stdio.h>

#include <stdlib.h>

#define INTER 1000

int primo(int b){
int i, count = 0;
for(i=1;i<b+1;i++){ if((b % i) == 0) { count++; }
}

if(count == 2) { return 1; } else { return 0; }
}

int main(void)
{
int i;
for(i=0;i<INTER;i++) { if(primo(i) == 1) { printf("%d\n", i);
}
}
system("pause");
}

Entra com 10 número, se for par, imprime a soma dos número entrados q são pares, caso contrario, imprime a soma dos ímpares.

#include <stdio.h>

#include <stdlib.h>

double veri(double b)

{
int r;
r = b;
return (b / 2) - (r / 2);
}


int main() {

double num[10];
int i=0;
double somaprim = 0;
double somapar = 0;
double soma = 0;
for(i=0;i<10;i++) {
scanf("%lf", &num[i]);
if(veri(num[i]) > 0.1 && veri(num[i]) < 0.9) { somaprim += num[i]; }
else { somapar += num[i]; }
soma += num[i];
}
if(veri(soma) > 0.1 && veri(soma) < 0.9) { printf("%lf\n", somaprim); }
else printf("%lf\n", somapar);
system("pause");
}

Calculadora em C/C++

#include <iostream>

using namespace std;



class calc {

private:

double num[2];



public:

double somar();

double subtrair();

double multi(){ return num[0] * num[1]; }

double dividir(){ return num[0] / num[1]; }

calc (double d, double c) {

num[0] = d;

num[1] = c;

}

};



double calc::somar(){ return num[0]+num[1]; }

double calc::subtrair(){ return num[0]-num[1]; }



int main(void) {

double n[2];

cout << "Número: " << endl;

cin >> n[0];

cout << "Número: " << endl;

cin >> n[1];

calc calcular(n[0], n[1]);

cout << calcular.somar() << endl;;

cout << calcular.subtrair() << endl;;

cout << calcular.multi() << endl;;

cout << calcular.dividir() << endl;;

string k;

cin >> k;

}

cplusplus.com

C++ Language Tutorial Published by Juan Soulie
Last update on Aug 6, 2006 at 3:45pm

These tutorials explain the C++ language from its basics up to the newest features of ANSI-C++, including basic concepts such as arrays or classes and advanced concepts such as polymorphism or templates. The tutorial is oriented in a practical way, with working example programs in all sections to start practicing each lesson right away.

http://www.cplusplus.com/doc/tutorial/

Soma número ímpares e primos dentro de um intervalo(100) (obs: 2 é o único número par primo! ;) )

#include <stdio.h>
#include <stdlib.h>


int main()
{
int i=0;
int soma = 0;
for(i=0;i<101;i++){
i++;
soma += i;
}
soma += 2; // 2 - único número par q é primo. ;]
printf("%d", soma);
system("pause");
}

Somador(5 em 5);

#include <stdio.h>
#include <stdlib.h>

int main() {

   int i, soma=0;
   i=0;
   while(i!=350){
      soma += i;
      i += 5;    // equivalente a: i = i + 5
   }
   printf("%d", soma) ;
   system("pause");
}

----------------------------------

A idéia básica para resolver esse tipo de questão está no simples intendimento das funções de laço e condições. A lógica desse programa é simples, na linha 1: temos o #include (q garante as funções printf() e scanf(), já na linha 2 temos outra biblioteca que irá contribuir com o nosso código obj. na inclusão na função system();, linha 3,4,5,6, não há mistérios, declarando as variáveis, a grande sacada está na função while(), q ativa o for até a condição q está entre os ()'s se torne falsa,,, then, keep going,.. and going.. ;}

Recebe 10 numeros e imprime o resultado da soma dos ímpares.

#include <stdio.h>
#include <stdlib.h>
double veri(double b)

{
int r;
r = b;
return (b / 2) - (r / 2);
}
int main()
{
double nums[10];
int i=0;
double soma = 0;
for(i=0;i<10;i++){
scanf("%lf", &nums[i]);
if(veri(nums[i]) > 0.1 && veri(nums[i]) < 0.9) { soma += nums[i]; }
}
printf("%lf", soma);
system("pause");
}

Tutorial: "C++ COMO UMA LINGUAGEM DE PROGRAMAÇÃO ORIENTADA A OBJETOS."

Simpatizei muito com esse tutorial, recomendo para aqueles que já possuem alguma intimidade com a linguagem C e deseja avançar pra linguagem C++.

http://www.ic.unicamp.br/~cmrubira/aacesta/cpp/cpp15.html

(em breve novos links!)

Ler 20 valores inteiros, um de cada vez. Encontrar e escrever o maior

/* Ler 20 valores inteiros, um de cada vez. Encontrar e escrever o maior
valor lido. */

#include <stdio.h>

#include <stdlib.h>



main()

{

int a[20], i=0, k, r=0, index=0;

while(i<20) {

printf("Digite o %do numero:", i+1);


scanf("%d", &a[i]) ;

i++;

}

while(r<20){

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

if(a[index] <
a[k]) { index=k; break; }

}

r++;

}

printf("O maior numero eh: %d", a[index]);

system("pause");

}

Outro exercício =]

/*
Escrever um algoritmo que lê a hora de início de um jogo e a hora de
término do jogo, ambas subdivididas em 2 valores distintos, a saber: horas e
minutos. Calcular e escrever a duração do jogo, também em horas e minutos,
considerando que o tempo máximo de duração de um jogo é de 24 horas e que o jogo
pode iniciar em um dia e terminar no dia seguinte.

*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>


struct horarios {

int inicio_horas;

int inicio_minutos;

int fim_horas;

int fim_minutos;

} tabela;



main ()

{

int k, k2, cont=0, cont2=0;

puts("digite a hora q inicia:");

scanf("%d" ,&tabela.inicio_horas);

puts("digite o minuto q inicia:");

scanf("%d" ,&tabela.inicio_minutos);

puts("digite a hora q termina:");

scanf("%d" ,&tabela.fim_horas);

puts("digite a minuto q temina:");

scanf("%d" ,&tabela.fim_minutos);

k = tabela.inicio_horas;

k2 = tabela.inicio_minutos;

while(k != tabela.fim_horas){

if(k == 24){

k = 0;

cont++;

}

else { k++; cont++; }

}

while(k2 != tabela.fim_minutos){

if(k2 == 60){

k2 = 0;

cont2++;

}

if(cont2 == 60) { cont++; cont2 = 0;}

else { k2++; cont2++; }

printf("%d\n", k2);

}

printf("\nHoras: %d", cont);

printf("\nMinutos: %d", cont2);

system("pause");

}

Circuito simples na porta paralela.

(Montado em um protoboard ;P usando 7 leds)

------------------------------------------------------------------------------------

#include <stdio.h>
#include <windows.h> //Necessário para: LoadLibrary(), GetProcAddress() e
HINSTANCE.
#define LPT1 0x378

//Declaração dos ponteiros para função.

typedef short _stdcall (*PtrInput)(short EndPorta);
typedef void _stdcall (*PtrOutput)(short EndPorta, short valor);

int main(void)
{
HINSTANCE hLib; //Instância para a DLL inpout32.dll.
PtrInput inportB; //Instância para a função Imp32().
PtrOutput outportB; //Instância para a função Out32().

//Carrega a DLL na memória.
hLib = LoadLibrary("inpout32.dll");
if(hLib == NULL) //Verifica se houve erro.
{
printf("Erro. O arquivo inpout32.dll
não foi encontrado.\n");
getch();
return -1;
}
//Obtém o endereço da função Inp32 contida na DLL.
inportB = (PtrInput) GetProcAddress(hLib, "Inp32");
if(inportB == NULL) //Verifica se houve erro.
{
printf("Erro. A função Inp32 não foi
encontrada.\n");
getch();
return -1;
}


//Obtém o endereço da função Out32 contida na DLL.
outportB = (PtrOutput) GetProcAddress(hLib, "Out32");
if(outportB == NULL) //Verifica se houve erro.
{
printf("Erro. A função Out32 não foi
encontrada.\n");
getch();
return -1;
}

//---------------------------------------------------------------------------

//Uso das funções outportB() e inportB():

int i, k;
unsigned char Valor=255; //Em binário: 11111111
while( Valor > 0 )
{
for(i=0;i<100;i++) { printf("sleep
;P\n"); }

outportB(LPT1, Valor); // Envia para
a Porta LPT1

Valor = Valor >> 1; //A cada
passagem, o bit 1 é movido para a direita

if (Valor == 0) { Valor = 255; }
}

}

---------------------------------------------------------------------------------
Fonte: rogercom. adaptação: david

requisitos: 8 leds, 8R de 470 ohms, um cabo de impressora.

Muito interessante. Para q funcione eh importante resaltar q precisa ter a dll input32 pq são usadas 2 funções(inp32, out32) para ter acesso a lpt, já no caso do linux não precisa, pode usar função ioperm .

IOPERM

int ioperm(unsigned long from, unsigned long num, int turn_on)

obs: precisa de privilegios de root.

D0 -----led----resistor----- (grd)
D1 -----led----resistor----- (grd)
D2 -----led----resistor----- (grd)
D3 -----led----resistor----- (grd)
D4 -----led----resistor----- (grd)
D5 -----led----resistor----- (grd)
D6 -----led----resistor----- (grd)
D7 -----led----resistor----- (grd)

D0 .. D7 pinos 2 a 9 respectivamente.

Endereço para enviar byte para lpt:
Registro de Dados
lpt1: 378h
lpt2: 278h


,.,,
display de 7 segmentos, next step! ;P

Trabalhando com strings.

/* 05º) Fazer um programa para receber uma string do usuário (máx. 50
caracteres) e fazer uma estatística dos caracteres digitados.
Por exemplo, para a string "O EXERCICIO E FACIL"
A estatística mostrada será '

O' = 2, ' '=3, 'E' = 3,'X' = 1, 'R' = 1, 'C' = 3, 'I' = 3, 'F' = 1, 'A' = 1, 'L' = 1

-------------------------------------------------------------------------------------
Escrito por: Lagartosdr
*/


#include <stdio.h>
#include <stdlib.h>


int main(int argc, char *argv[])
{
int posicao, k=0, e=0, i=0,l=0,deb=0,m=0,arv=0;
char str1[50], arm[1000]=""; //Zera arm para garatir q non ocorreram erros nas contagens.
puts("String:");
gets(str1);
while(str1[l] != '\0'){
e = 0;
for(k=0;k<=strlen(str1);k++){
if(str1[l] == str1[k]){ e++; }
if(k == strlen(str1)) { //Verifica se k jah é do tamanho da string
for(deb=0;deb<=strlen(str1);deb++){ //verifica se a str[l] jah foi armazenada em arm.
if(str1[l] == arm[deb]){ m=0; break; } //m=0, não imprime, m !=0, imprime.
else { m++; }
}
if(m!= 0){ //verifica o valor de m para q possa imprimir ou não a string.
printf(" %c = %d \n", str1[l], e);
arm[arv++] = str1[l]; //armazena no buff pra garantir q essa string non seja impressa novamente.
}
}
}
l++;
i++;
}

system("PAUSE");
return 0;
}

Anexando string 1 em string 2 apartir da posição X.

04º) Escrever uma função que:

- receba dois strings como parâmetro, bem como um valor inteiro representando uma posição.

- insira o segundo string no primeiro, na posição indicada pelo valor.

Fazer um programa que receba dois strings do usuário , o valor da posição, chame a função anteriormente implementada e exiba o resultado ao usuário.

#include <stdio.h>
#include <stdlib.h>

int comchance(char x[20], char w[20], int a);
int comchance(char x[20], char w[20], int a){
int i, t=0;

for(i=a;i<=a+strlen(w);i++) {
x[i] = w[t]; t++;
if(t == strlen(w)) { break; }
}
i=0;
while(x[i] != '\0') {
putchar(x[i]); i++; }
}

int main(int argc, char *argv[]){
char x[20], w[20];
int a;
puts("Digite a primeira string:");
gets(x);
puts("Digite a segunda string:");
gets(w);
puts("Digite o inteiro:");
scanf("%d", &a);
comchance(x, w, a);
system("PAUSE");
return 0;
}

Verificando se string1 esta contida em string2.

#include <stdio.h>
#include <stdlib.h>


void sair();
void sair() {
printf("\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB
ERRO:\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\n");
printf("String 1 deve maior que a string 2.\n");
printf("\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB
\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB\xDB
\xDB\xDB\xDB\xDB\xDB\n\n\n\n");
main();
}
int main(int argc, char *argv[])
{
char v1[20], v2[20];
int i=0, w=0, vr=0, vr2=0, x;
printf("String1:"); gets(v1);
printf("String2:"); gets(v2);
if(strlen(v2)>strlen(v1)) {
sair();
}
for(i=0;i<=strlen(v1)+1;i++){
if(v1[i] == v2[w]) { w++; vr++; }
else { vr = 0; w=0;}
if(vr == strlen(v2)) { vr++; vr2=(i-(strlen(v2)-1)); x=1; break; }
}
if (x != 0) { printf("String2 estah contida em String1, começando na posicao: %d
de string1 e terminando na posição %d.\n", vr2, vr2+strlen(v2)-1); }
else { printf("String2 nao estah contida em String1\n"); }
system("PAUSE");
return 0;
}

Verifica se duas string são iguais,

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){
char v1[30], v2[30];
int i=0, vr=0;
gets(v1); gets(v2);
if(strlen(v1) != strlen(v2)) { printf("Diferentes\n"); }
else {
for(i=0;i<strlen(v1);i++){
if(v1[i] == v2[i]) { vr++; }
}
printf("vr(%d) e strlen(v2)(%d)", vr, strlen(v2));
if(vr == strlen(v1)){ printf("Iguais\n"); } else { printf("Diferentes\n"); }
}
system("PAUSE");
return 0;
}

Concatenando duas strings.

#include <stdio.h>
#include <stdlib.h>



int main(int argc, char *argv[])
{
char v1[30],v2[30],v3[60];
int i =0, w=0;
gets(v1); gets(v2);
for(i=0;i<strlen(v1);i++){
v3[i] = v1[i];
}
for(i=strlen(v1);i<=strlen(v2)+strlen(v1); i++){
v3[i] = v2[w];
w++;
}
i=0;
while(v3[i] != '\0'){ putchar(v3[i]); i++; }
system("PAUSE");
return 0;
}

Transformando um Binário em Decimal

#include <stdio.h>
#include <stdlib.h>


int multi(int j)
{
int i = j, d, r=1;
for(d=0;d<i;d++){
r = r * 2;
}
return r;
}
int main(int argc, char *argv[])
{
char bin[8];
int i, j, n = 0;
scanf("%s", &bin);
j = (strlen(bin) - 1);
for(i=0;i<=strlen(bin)-1;i++){
if(bin[i] == '1'){
n = (n + multi(j));
}
j--;
}
printf("\n%d\n", n);
system("PAUSE");
return 0;
}