Archive for the "Programação" Category

Identação de Código Fonte

É comum em linguagem de programação termos uma maneira de organizar o código, a essa maneira denominamos Identação.

Apesar de que na maioria das linguagens de programação a identação ser algo meramente estético, ela mostra de forma mais clara a hierarquia dos elementos e por isso facilita a leitura de um código fonte de um programa.

Quando começamos a programar geralmente não compreendemos a facilidade que a identação nos dará, por exemplo:

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

main()
{
int pegavalor;
pegavalor=0;
printf("Entre com um valor ");
scanf("%i",&pegavalor);
if(pegavalor < 100)
{
printf("O valor digitado e menor que 100\n");
}
else
{
printf("O valor digitado e maior ou igual a 100\n");
}
if(pegavalor%2==0)
printf("O valor digitado e um numero par\n");
else
printf("O valor digitado e um numero impar\n");
system("pause");
}

No exemplo acima, não estamos tendo um cuidado com a organização do arquivo, o que pode gerar algumas confusões em uma revisão futura, lembrando que o exemplo tem apenas 24 linhas, porém se imaginarmos um sistema de 1000 linhas, isso irá atrapalhar a interpretação do código, abaixo uma sugestão de identação, parecida com a usada por Brian Kernighan e Dennis Ritchie (ver blog do Hélio*), veja:

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

main() {
  int pegavalor;
  pegavalor=0;
  printf("Entre com um valor ");
  scanf("%i",&pegavalor);
  if(pegavalor < 100) {
    printf("O valor digitado e menor que 100\n");
  } else {
    printf("O valor digitado e maior ou igual a 100\n");
  }
  if(pegavalor%2==0)
    printf("O valor digitado e um numero par\n");
  else
    printf("O valor digitado e um numero impar\n");
  system("pause");
}

Com o mesmo conteúdo, já é possível perceber que por mais simples que seja a “identação” ela possível uma melhor visualização, perceba que os if’s ganharam recuos, possibilitando que apenas batendo o olho você saiba que determinada fecha chaves ( } ) pertence a um determinado if.

Imaginando em um arquivo grande, isso irá facilitar MUITO a vida do programador, possibilitando até a descobrir erros de forma rápida.

A dica é, observe os exemplos, escolha uma identação e pratique-a mantenha seu código organizado, e você será “um pouco” mais feliz

*O blogueiro e programador Hélio Costa Silva fez um interessante post em se Blog, mostrando diversas maneiras de se organizar (identar) o código. CONFIRA

Tabela Verdade [Atualizado]

Por definição. Tabela-verdade é o conjunto de todas as possibilidades combinatórias entre valores de diversas variáveis lógicas (binários), as quais se encontram em apenas duas situações (V)erdadeiro ou (F)also, e um conjunto de operadores lógicos.

A lógica binária, ou bitwise operation é a base de todo o cálculo computacional. Na verdade, são estas operações mais básicas que constituem todo o poderio dos computadores. Qualquer operação, por mais complexa que pareça, é traduzida internamente pelo processador para estas operações.
Por isso dizemos então que o computador trabalha apenas com zeros e uns.

As operações que podemos aplicar sobre esses valores lógicos estão abaixo restritos:

Operador NOT (!)

O operador unário NOT, ou negação binária resulta no complemento do operando, i.e., será um bit ’1′ se o operando for ’0′, e será ’0′ caso contrário, conforme podemos confirmar pela tabela de verdade:

A ¬A
1 0
0 1

Implementação em C

A = 0;
B = !A;

Operador AND (&&)

O operador binário AND, ou conjunção binária devolve um bit 1 sempre que ambos operandos sejam ’1′, conforme podemos confirmar pela tabela de verdade:

A B A ∧ B
1 1 1
1 0 0
0 1 0
0 0 0

Implementação em C

 if (variavel1 &amp;&amp; variavel2) { /*código*/ } 

Operador OR (||)

O operador binário OR, ou disjunção binária devolve um bit 1 sempre que pelo menos um dos operandos seja ’1′, conforme podemos confirmar pela tabela de verdade:

A B A ∨ B
1 1 1
1 0 1
0 1 1
0 0 0

Implementação em C

if ( variavel1 || variavel2 ) {
  /* Código */
}

Existe também outros operadores, como o NAND e o XOR, para mais informações, segue alguns links:

Wikibooks: Introdução à programação/Lógica

Organização e estruturas de Computador – Lógica Digital

 

[Atualização]

Para quem quiser brincar com portas lógicas, acesse http://logic.ly/demo/

[Atualizado]

Introdução a lógica, UFSC - http://www.inf.ufsc.br/ine5365/introlog.html

Ranking da linguagens de programação

Qual é a melhor linguagem de programação[bb] ?

Qual a linguagem de programação aonde estão os melhores salários[bb]?

Por qual linguagem de programação eu devo começar?

Essas 3 perguntas não tem respostas rápidas e fáceis, visto que o mercado de T.I. é muito grande, com diversas demandas e que muda constantemente. Portando essas perguntas são acompanhadas de inúmeras outras, afim de chegar mais próximo do que o profissional[bb]deseja.

Porém é possível visualizar um Ranking aonde estão dispostas as linguagens e sua “reputação” por assim dizer.

Abaixo o gráfico feito pela TIOBE Software, com uma informação importante. Encabeçando a lista temos o Java e logo abaixo C, uma linguagem por muitas vezes tida como velha e pelos menos entendidos: Morta.

Se você está na dúvida, veja o Ranking e observe aonde você vai colocar suas fichas ;)

Veja a matéria completa aqui (em inglês)

Arquivos em C

Obs: Esse post será "revisitado" em breve.

Porque usar arquivos?
- Armazenar de maneira persistente as informações
- Armazenar uma grande quantidade de informações

Tipos de Arquivos:
- Texto
- Binário

Características dos arquivos Texto
- Arquivos seqüenciais
- Arquivos podem ser editados em qualquer editor
- Sua leitura é seqüencia pois deve ser feita do inicio ao fim

Características dos arquivos Binários
- Feita internamente pelo programa que gerou, através de uma seqüencia de bits
- O acesso pode ser feito de forma não seqüencial (randômica)

Como trabalhar com os arquivos em C
- Será necessário utilizar um "tipo" novo de variável, chamado FILE (stdio.h)
- Abrir o arquivo
- Trabalhar com o arquivo (ler/gravar)
- Fechar o arquivo

Um pequeno exemplo de escrita em arquivo texto

#include <stdio.h>

int main (int argc, char * argv[]) {
	// cria uma variavel que aponta para o arquivo
	FILE *arq;
	// abre o arquivo *função fopen*, retorna o endereço do arquivo para a variavel arq
	// Modo de abertura -> W
	arq = fopen("arquivo.txt","w");
	// utiliza a função fprintf, que é como a printf, porem dando saida para um arquivo
	fprintf(arq,"Esse é meu primeiro arquivo!\n");
	// fechando o arquivo
	fclose(arq);

	return 0;
}

Um pequeno exemplo de leitura em arquivo texto

#include <stdio.h>

int main (int argc, char * argv[]) {
	char c;
	// cria uma variavel que aponta para o arquivo
	FILE *arq;
	// abre o arquivo *função fopen*, retorna o endereço do arquivo para a variavel arq
	// modo de abertura -> R
	arq = fopen("arquivo.txt","r");
	// Pega caracter a caracter (com a funcao fgetc) joga na variavel c e depois imprime
	c = fgetc(arq);
	while (c != EOF) {
		printf("%c", c);
		c = fgetc(arq);
	}

	// fechando o arquivo
	fclose(arq);

	return 0;
}

 

Funções

FILE * fopen ( const char * filename, const char * mode );

[link]

Abre um arquivo.

Parâmetros:

filename

    Nome do arquivo

mode

    modo de abertura do arquivo:

    Modos de abertura

    r    Abre o arquivo para leitura. O arquivo precisa existir

    w    Abre um arquivo em branco para escrita. Se existir um arquivo com o mesmo nome ele será sobrescrito por um arquivo em branco.

    a    Abre um arquivo para "atualização". Operações de escrita serão adicionadas no final do arquivo. Se o arquivo não existir, será criado.

    r+    Abre o arquivo para leitura e escrita.

    w+    Cria um arquivo vazio para leitura e escrita.Se existir um arquivo com o mesmo nome ele será sobrescrito por um arquivo em branco.

    a+    Abre um arquivo para leitura e "atualização". Todas as operações de escrita serão feitas no final do arquivo. Se o arquivo não existir, será criado.

    OBS: Esses modos de abertura de arquivo são para arquivos textos, porém para proceder a operação em arquivos binários, basta acrescentar a letra b, ficando (rb, wb, ab, rb+, wb+, ab+) (pode-se usar também r+b, w+b, a+b, tendo o mesmo efeito)

Retorno:

    Se for bem sucedido, então retorna o ponteiro para o arquivo

    Se não, retorna um ponteiro nullo (NULL)

fprintf

int fprintf ( FILE * stream, const char * format, ... );

[link]

Escreve em um arquivo

Parâmetros

stream

    Ponteiro para o arquivo

format

    Idem as formatações do comando printf (%c %d …)

Argumentos adicionais

    Dependendo dos parâmetros de formatação da string, é necessário informar as variáveis que irão preencher as informações

Retorno

    Se OK, retorna o numero total de caracteres escritos

    Se falha, um numero negativo é retornado

fclose

int fclose ( FILE * stream ); 

[link]

Fecha o arquivo

Parâmetros

stream

    Ponteiro para o arquivo que será fechado

Retorno

    Se OK, o arquivo é fechado e o valor 0 é retornado.

    Se falha, EOF é retornado   

Segundo VideoCast – Continuação de Ponteiros

Nesse segundo videocast mostro um pouco mais sobre a Continuação de Ponteiros, Ponteiros de Ponteiros, Passagem de Valor por referencia e algo sobre o argc, argv[].

Preparem-se. 30 minutos ;)

Ponteiros (2a parte) from Carlos Eduardo Silva on Vimeo.

Google lança nova linguagem de programação –> Go

O Google anunciou esses dias uma nova linguagem de programação, chamada GO, muito interessante, nascida para ser rápida, tanto na compilação de códigos como na hora de programar.

Veja o promo vídeo:

E aqui vai a telinha do meu "primeiro arquivo .go"

goKadu2

Link: http://golang.org/

Operadores

Em C existem diversos tipos de operadores, são eles:

  • Aritméticos
  • Unários
  • Atribuição
  • Relacionais
  • Lógicos

Aqui vai alguns exemplos básicos de 2 operadores em especifico, são eles ++ e (operadores unários).

Como é de se imaginar, o operador ++ faz o incremento unário em uma variável, já o faz o decremento. É importante notar que existe duas maneiras de utiliza-los, e a maneira influência no resultado da operação.

Se você utiliza-lo antes da variável, então ela será incrementada ou decrementada antes de ser utilizadas na expressão, se você utiliza-la após a variável, então ela será utilizada na expressão, e só depois será incrementada/decrementada.

Exemplificando:

#include <stdio.h>
int main (void)
{
   int iValor_01 = 10, iValor_02 = 5, iValor_03 = 8;
   int iResultado;

   iResultado = iValor_01++ + 9;         /* Retorna 10 para iValor_01
                                            iResultador = 10 + 9
                                            iValor_01 = iValor_01 + 1 */
   printf("Resultado 1 %d\n", iResultado);

   iResultado = --iValor_02 + 10;        /* iValor_02 = iValor_02 - 1
                                            iValor_02 fica com o valor 4
                                            iResultado = 4 + 10 */
   printf("Resultado 2 %d\n", iResultado);

   iResultado = ++iValor_03 * ++iValor_03; /* iValor_03 = iValor_03 + 1
                                              Retorna 9 para iValor_03
                                              iValor_03 = iValor_03 + 1
                                              Retorna 10 para iValor_03
                                              iResultado = 9 * 10 */
   printf("Resultado 3 %d\n", iResultado);

   iResultado = iValor_01++ * iValor_01++;   /* Retorna 11 para iValor_01
                                                iValor_01 = iValor_01 + 1
                                                Retorna 12 para iValor_01
                                                iResultado = 11 * 12
                                                iValor_01 = iValor_01 + 1 */
   printf("Resultado 4 %d\n", iResultado);

   return 0;
}

Abra seu compilador e teste o código acima, verifique, olhe linha linha e adicione essa “funcionalidade” a mais em suas habilidades ;)

+ Info no BR-C

A declaração“padrão”da função Main

Normalmente utilizamos começamos um programa em C da seguinte maneira:

#include <stdio.h>

main() {
    printf("Ola, Mundo!!!");
}

 

Isso funciona, porém é interessante notar que os compiladores C mais novos podem retornar “warnings” ou até mesmo erros referente a utilização da função main dessa maneira.

Isso acontece porque na norma C99 [em inglês], aonde está redigido os novos padrões da linguagem C, foi explicitado como a função main deve ser declarada, veja:

#include <stdio.h>

int main (int argc, char * argv[]) {
	printf("Ola, Mundo!!!");
	return 0;
}

Percebam algumas mudanças, primeiro a função main passou a retornar um inteiro, ganhou 2 argumentos, int argc e char * argv, que possibilitam o programa a receber parâmetros externos.

Veja o exemplo abaixo

#include <stdio.h>

int main (int argc, char * argv[]) {
	int i;
	printf("\n\n\n\n");
	printf("Nome do programa.....: %s\n",argv[0]);
	printf("Numero de argumentos.: %d\n",argc);
	if(argc > 1) {
        printf("\n\n**** .A.R.G.U.M.E.N.T.O.S. ****\n\n");
    }
	for(i = 1; i <= argc; i++) {
        if(argv[i] != NULL) {
            printf("Argumento %d..........: %s\n",i,argv[i]);
        }
    }
    printf("\nFim...\n");
	return 0;
}

Esse exemplo acima irá mostrar todos os parâmetros que você passar para o programa, abaixo um exemplo da saída, imaginando que meu executável chame teste.exe, e que eu tenha executado ele passando alguns parâmetros:

argc_argv3

É isso!!!!

Exemplos: Funções e Vetores

Sistema de Controle de Livros

Um aluno do Curso de TADS resolveu ajudar seus familiares e desenvolver um sistema para fazer o controle de livros de sua biblioteca particular, antes de começar ele fez um levantamento do que seria necessário ter no sistema, o encontrado foi:

Cadastrar livros
- Numero do Registro
- Título
- Autor
- Numero da estante
- Numero da prateleira

Tendo essa estrutura, o aluno colocou como características para que o sistema tornasse utilizável, são elas:

- Um menu de opções aonde seria escolhido as operações disponíveis:

  • Cadastrar uma Obra
  • Consultar uma Obra
  • Consultar todas as obras

Abaixo um programa simples para mostrar a resolução do problema proposto, utilizando menus, arrays e funções:

#include <stdio.h>
#define MAX 10

// Variaveis Globais
struct estante {
	int estante;
	int prateleira;
};

struct livro {
	int reg;
	char titulo[80];
	char autor[100];
	struct estante posicao;
};

struct livro livros[MAX];
int    livre;  // Variavel auxiliar, responsavel por saber quantos livros ja foram cadastrados

int menu(void) {
	// variaveis locais
	int retorno;

    // Menu
	printf("\n\n\n");
	printf("****************************************************\n");
	printf("**              Controle de Livros                  \n");
	printf("****************************************************\n");
	printf("** Escolha a opcao desejada:                        \n");
	printf("**                                                  \n");
	printf("** 1 ) Cadastrar uma obra                           \n");
	printf("** 2 ) Consultar uma obra                           \n");
	printf("** 3 ) Listar todas as obras                        \n");
	printf("** 0 ) SAIR                                         \n");
	printf("**                                                  \n");
	printf("** Entre com a opcao desejada : ");
	scanf("%d",&retorno);

	return retorno;
}

void cadastrar(void) {
	printf("\n\n\n");
	printf("****************************************************\n");
	printf("**              CADASTRO DE OBRAS (%d/%d)           \n",livre,MAX);
	printf("****************************************************\n");
	printf("**\n");
	if (livre != MAX) {
		printf("** Numero do Registro...: "); scanf("%d",&livros[livre].reg);
		fgetc(stdin); // Limpando o buffer de teclado
		printf("** Titulo da Obra.......: "); fgets(livros[livre].titulo, 80, stdin);
		printf("** Autor da Obra........: "); fgets(livros[livre].autor, 100, stdin);
		printf("** Numero da Estante....: "); scanf("%d",&livros[livre].posicao.estante);
		printf("** Numero da Prateleira.: "); scanf("%d",&livros[livre].posicao.prateleira);
		printf("**\n");
		printf("**\n");
		printf("**  Registro %d cadastrado com sucesso!               ",livros[livre].reg);
		livre++;
	} else {
		printf("**             ESPACO INSUFICIENTE                  \n");
	}
}

void listar_todos(int registro) {
	int i;
	int imprime;
	int controle = 0;
	printf("\n\n\n");
	printf("****************************************************\n");
	printf("**                 Listando OBRAS                   \n");
	printf("****************************************************\n");
	printf("**\n");
	if(livre > 0) {
		for(i = 0; i < livre; i++) {
			if(registro != 0) {
				imprime = (livros[i].reg == registro);
			}
			if(imprime) {
				printf("** Numero do Registro...: %d\n",livros[i].reg);
				printf("** Titulo da Obra.......: %s",livros[i].titulo);
				printf("** Autor da Obra........: %s",livros[i].autor);
				printf("** Numero da Estante....: %d\n",livros[i].posicao.estante);
				printf("** Numero da Prateleira.: %d\n",livros[i].posicao.prateleira);
				printf("**\n");
				controle++;
			}
		}	

		if((registro != 0) && (controle == 0))
			printf("** REGISTRO NAO ENCONTRADO \n");
	} else {
		printf("**             ESTANTES VAZIAS                  \n");
	}
	printf("\n\n");
}

void lista_especifica(void) {
	int reg;
	printf("\n\n\n");
	printf("****************************************************\n");
	printf("**                 Listando OBRAS                   \n");
	printf("****************************************************\n");
	printf("**\n");
	printf("** Entre com o numero do registro....: "); scanf("%d",&reg);
	listar_todos(reg);
}

int main (void) {
	// variaveis locais
	int opcao = 1;

	// Inicializacao das variaveis
	livre = 0;

	while(opcao != 0) {
		opcao = menu();
		switch(opcao) {
			case 1 : {
				// chamada da funcao cadastrar obra
				cadastrar();
				break;
			}
			case 2 : {
				// chamada da funcao consultar obra
				lista_especifica();
				break;
			}
			case 3 : {
				// chamada da funcao listar todos
				listar_todos(0);
				break;
			}
			case 0 : {
				printf("\n\n");
				printf("** Obrigado por utilizar o sistema...               \n\n\n");
				opcao = 0;
				break;
			} // Fim case
		} // Fim Switch
	} // Fim While

	return 0;
} // Fim main