Include C/C++

Vídeos: Ponteiros e Recursividade

2009-10-19T10:50:00.001-02:00

Video sobre Ponteiros.

Video sobre Recursividade.

Até!

Carregando variáves de arquivo LUA

2009-08-13T07:41:00.019-03:00

Olá, depois de um tempo sem postar nada, trago um exemplo de como se carregar variáveis de um arquivo lua para o seu aplicativo em c++, utilizando Dev-C++.

A linguagem lua vem sendo utilizada em muitos jogos, um grande exemplo é o jogo online Tibia, não é grande a atuação da linguagem lua neste jogo, ela é utilizada para se carregar variáveis como SERVIDOR, USUARIO, VERSÃO, entre outros detalhes.

Então vamos lá. Primeiramente temos que entender que a biblioteca que utilizaremos para carregar arquivos lua foi inicialmente desenvolvida para C, portanto, se você pretende utilizar C++ é necessário um comando para que seja possivel utilizar.

externn "C" {
    #include "lua.h"
    #include "lualib.h"
    #include "lauxlib.h"
}

Agora vamos ao nosso arquivo lua que guardará as variáveis. Crie um arquivo com a extenção lua e grave as seguintes vareiáveis:

SERVIDOR = "localhost"
USUARIO = "ROOT"
SENHA = "123"

Salve-o com o nome que desejar, desde que esteja na mesma pasta que o seu projeto. Para que o nosso programa possa ler as variáveis quando quiser, sem necessitar de um código enorme toda a vez que for capturar a variável, vamos criar uma função CarregaVariavel do tipo Const Char*. Esta função recebera o seguinte parâmetro:
variavel é a variavel que será carregada.

const char* CarregaVariavel(char* variavel)
{
   // Variavel
   lua_State *LuaVar = lua_open();
   // Carrega o arquivo
   int sts = luaL_loadfile(LuaVar, "hello.lua");

   // Se carregou o arquivo
   if( sts== 0 ) {
      // Carrega os dados do arquivo em si...
      sts = lua_pcall(LuaVar, 0, LUA_MULTRET,0);
}

   // Captura o valor da variavel entre aspas.
   lua_getglobal(LuaVar,variavel);
   // Atribui a uma variavel o valor capturado
   return lua_tostring(LuaVar,-1);

   lua_close(LuaVar);
}

Para chamarmos a nossa função, declararemos uma variavel do tipo const char e chamamos a nossa função. como abaixo

const char *teste;
teste = CarregaVariavel("SERVIDOR");

O nosso programa final pode ser visto na listagem abaixo.


const char* CarregaVariavel(char* variavel);

int main( int argc, char ** argv) {

    const char *servidor;
    const char *usuario;
    const char *senha;

    servidor = CarregaVariavel( "SERVIDOR" );
    cout << servidor << endl;
    usuario = CarregaVariavel("USUARIO");
    cout << usuario << endl;

    senha = CarregaVariavel("SENHA");
    cout << senha << endl;
    system("pause");
    return 0;
}

const char* CarregaVariavel(char* variavel)
{
   // Variavel
   lua_State *LuaVar = lua_open();
   // Carrega o arquivo
   int sts = luaL_loadfile(LuaVar, "hello.lua");

   // Se carregou o arquivo
   if( sts== 0 ) {
      // Carrega os dados do arquivo em si...
      sts = lua_pcall(LuaVar, 0, LUA_MULTRET,0);
}

   // Captura o valor da variavel entre aspas.
   lua_getglobal(LuaVar,variavel);
   // Atribui a uma variavel o valor capturado
   return lua_tostring(LuaVar,-1);

   lua_close(LuaVar);
}

"Mas pô sipmann.. deu erro na hora de compila aqui no dev...??"... Para poder compilar é necessário baixar o pacote (através do sistema de pacotes do dev mesmo) "lua"... "Prontooo... e agora???"... Agora é necessário dizer ao compilador que iremos utilizar a biblioteca que acabamos de baixar (lembram do acesso ao mysql??? mesma coisa) Project >> Project Options >> Parameters... ai na lista "Linker" adicionem as duas linhas a seguir...
-lLua -lLualib

Pronto... só compilar e brincar...
Abração e espero que tenham gostado... qualquer duvida só posta ai... até

Revista programar: Metaprogramação em C++

2009-06-12T08:55:00.002-03:00

A revista Programar dos nossos irmãos lusitanos em sua edição 20 publicou um interessante artigo sobre Metaprogramação em c++.

Fica assim nossa recomendação de leitura para o fim de semana: http://www.revista-programar.info/front/view/26

Aufwiederzehn!

Otimizações do compilador GCC

2009-05-31T16:01:00.002-03:00

Olá pessoal, esse pequeno post é para falar sobre compilação com otimização do compilador. Para isso vamos medir o tempo de execução de nosso programa.

Usei o exemplo do post anterior, de qualquer forma segue o código abaixo:

#include 
#include 

double tempo()
{
 struct timeval tv;
 gettimeofday(&tv,0);
 return tv.tv_sec + tv.tv_usec/1e6;
}

int main()
{
 double t1,t2;
 double i;
 t1 = tempo();
 printf("%lf\t",t1);

 for(i=0;i<300000000;i++);

 t2 = tempo();
 printf("%lf\t",t2);

 printf("%lf\n",t2-t1);
 return 0;
}

Na hora de compilar um programa com o GCC você pode colocar alguns parâmetros, vamos usar:

-O1 Otimiza para tamanho do binário
-O2 Otimiza para desempenho de execução
-O3 Otimiza para Data cache

* Atenção é "O" (letra) e não "0" (número).

Vamos aos testes:


[helton2@hrpc ~]$ gcc teste.c -O1
[helton2@hrpc ~]$ ./a.out
1243797632.612002    1243797633.767017    1.155015

Neste exemplo o tamanho do binário ficou em 6329 bytes e demorou 1.155 segundos.


[helton2@hrpc ~]$ gcc teste.c -O2
[helton2@hrpc ~]$ ./a.out
1243797643.222072    1243797644.371347    1.149275

Neste exemplo o tamanho do binário ficou em 6345 bytes e demorou 1.149 segundos.


[helton2@hrpc ~]$ gcc teste.c -O3
[helton2@hrpc ~]$ ./a.out
1243797650.764788    1243797651.959029    1.194241

Neste exemplo o tamanho do binário ficou em 6409 bytes e demorou 1.194 segundos.

Compilando da forma padrão ...


[helton2@hrpc ~]$ gcc teste.c
[helton2@hrpc ~]$ ./a.out
1243797667.095339    1243797670.080635    2.985296

Neste exemplo o tamanho do binário ficou em 6369 bytes e demorou 2.985 segundos.

Como aqui estamos tratando de um problema fácil, apenas um simples "for" a diferença é pequena, mas com problemas mais complexos, sem dúvida essas opções de compilação podem dar um "up" no seu programa.

As opções aqui abordadas são válidas para a maioria dos compiladores C e C++ tanto em ambiente unix, linux, mac e windows.

Dica de Claudio Schepke. Obrigado!

Como instalar o GCC em Mandriva pela linha de comando?

2009-05-14T09:57:00.005-03:00

Vamos ver aqui simples rápido como instalar programas (aqui vamos instalar o GCC, mas serve para qualquer outro) em distribuição Mandriva (qualquer versão) ou outra distribuição que utiliza o gerenciador de pacotes URPMI.

O URPMI é como o APT das distribuições baseadas em Debian... um gerenciador de pacotes.

Bom, o primeiro passo é "testar" se a instalação de um dado pacote (rpm, que está nos repositórios) é possível. Para isso (com root) usamos "urpmi -- test gcc", onde "gcc" é o pacote que queremos instalar.
O URPMI então nos diz se é possíovel ou não. Para instalar então tem que dar o comando "urpmi gcc" onde gcc é o pacote que queremos instalar.

No início da tela anterior, executamos o comando "gcc" e como pode ver, não havia esse comando, instalamos, executamos novamente e tudo ok.

É essa a dica, agora você que usa uma máquina rodando alguma distribuição que usa RMPI, e acessa ela remotamente por SSH por exemplo e que não tem acesso a interface gráfica... já pode programar em C.

Welcome to jungle :)
Bye

Fatorial Recursivo em C

2009-04-25T22:26:00.002-03:00

Neste pequeno tutorial vou demonstrar o cálculo do fatorial utilizando recursividade na linguagem C. O fatorial de um número é igual a ele mesmo vezes ele menos um até chegar em um, exemplo:

Fatorial de 4 é igual a 4*3*2*1 que é igual a 24.
Fatorial de 5 é igual a 5*4*3*2*1 que é igual a 120.

Na função a seguir temos cálculo do fatorial de um número sem usar recursividade. Ela recebe como parâmetro um número inteiro e retorna o fatorial daquele número.


int fatorial (int n)
{   
    int i;
    i = n - 1; 
    for (i; i!=1; i--)
        n = n * i;
    return n;
}

Então podemos considerar que:

- o fatorial de 5 é igual a 5 multiplicado pelo fatorial de 4;
- o fatorial de 4 é igual a 4 multiplicado pelo fatorial de 3;
- o fatorial de 3 é igual a 3 multiplicado pelo fatorial de 2 e assim por diante.

Montando uma função matemática temos:

fatorial de x = x * fatorial de ( x -1 );

Entendido isso, a nossa função recursiva está praticamente pronta, basta adicionar uma condição de fim, que na função anterior é i diferente de 1. Veja a seguir a implementação da função em C.


int fatorial (int n)
{
    if(n==1) 
        return n;
    return fatorial(n-1) * n;          
}

Simples assim, até.

Qual o tempo de execução de meu aplicativo?

2009-04-19T23:29:00.008-03:00

Há situações em que precisamos medir quanto tempo demorou a execução de um determinado procedimento, ou a execução de um programa. Neste caso no Linux podemos usar a função gettimeofday().

Para mais detalhes... na linha de comando digite: man gettimeofday

Algumas informações úteis:

- a função retorna um int
- o primeiro parâmetro é a struct timeval (arquivo time.h), e o segundo é um valor de timezone, mas esse parametro está deprecated, e como diz na documentação costuma-se usar um valor nullo (0, zero)
- para que isso funcione você precisa ter no seu computador a glibc.

Vamos ao código e posterior análise:

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

double tempo()
{
 struct timeval tv;
 gettimeofday(&tv,0);
 return tv.tv_sec + tv.tv_usec/1e6;
}

int main()
{
 double t1,t2;
 double i;
 t1 = tempo();
 printf("%lf\t",t1);

 for(i=0;i<300000000;i++);

 t2 = tempo();
 printf("%lf\t",t2);

 printf("%lf\n",t2-t1);
 return 0;
}

1 - Criamos uma função que retorna um double, a função tempo()

double tempo()
{
 struct timeval tv;
 gettimeofday(&tv,0);

 return tv.tv_sec + tv.tv_usec/1e6;
}

Essa função declara uma variável chamada tv, que é do tipo da struct timeval (lembre... essa struct está definida no arquivo time.h). Depois chamamos a função propriamente, passando um ponteiro para nossa variável tv e o segundo parâmetro como a documentação sugere com valor nulo.

Depois dividimos os microsegundos por 1000000 para convertê-los em segundos (deixe 1e6, não sei porque, mas se dividir por 1000000 não vai dar certo ... isso ainda é um mistério), somamos a esse resultado os os segundos de agora. A struct timeval tem dois atributos, tv_sec (os segundos de agora) e tv_usec (os microsegundos do segundo de agora). Como nossa variável se chama tv, então para acessar os microsegundos usamos tv.tv_usec.

Agora o main de nosso programa:

int main()
{
 double t1,t2;
 double i;
 t1 = tempo();
 printf("%lf\t",t1);

 for(i=0;i<300000000;i++);

 t2 = tempo();
 printf("%lf\t",t2);

 printf("%lf\n",t2-t1);
 return 0;
}

Declaramos t1 e t2 do tipo double (a máscara para double é %lf lembra?) e também um i que vai ser nosso contador.

Queremos medir quanto tempo demorou um for de 0 até 300000000 (300 milhões), por isso guardamos o tempo de agora em t1 e depois do for em t2, mostramos isso na tela (já vai ver porque). Diminuimos t1 de t2 e temos em segundos quanto que demorou nosso bloco de códigos.

Compilando ...
gcc teste.c
mv a.out teste

Compilei (gerou o a.out) e renomeei isso para teste.

Executando:
./teste

Vai produzir um resultado como:
1240195429.991010 1240195432.975001 2.983991

Temos o tempo inicial, tempo final e a diferença. Atenção!! Se você tiver um computador lento é aconselhavel diminuir o tamanho do for ... a não ser que tenha paciência.

Estou rodando o programa num computador:
uname -a
Linux hrpc 2.6.27.14 # i686 Intel(R) Pentium(R) 4 CPU 3.00GHz GNU/Linux

Legal!! Descobrimos que demorou 2.98 segundos ... mas pense bem, foi a primeira vez que eu executei o programa na máquina ... será que nas vezes seguintes vai ser diferente o tempo? Talvez o programa já vai estar carregado na memória? E ... fora o programa eu tenho mais vários outros processos executando em meu computador... será que eles não interferem?

Só tem uma maneira de saber... rodando mais vezes o programa e vendo o tempo que resultou...

Segue abaixo um shell script que faz o programa executar 50 vezes e guarda (acumulando) o valor dos printf em um arquivo. Atenção para o caminho dos arquivos aí na sua máquina.

#!/bin/sh
i=1
while [ $i -le 50 ]
do
        /home/helton2/teste >> /home/helton2/resultados.txt
        i=`expr $i + 1`
done

exit 0

Este código aí acima é do arquivo runteste.sh, criamos esse arquivo e damos permissão de execução a ele (chmod +x runteste.sh), aí ele é um executável igual nosso programa em C.

Para rodá-lo então:
./runteste.sh

Isso vai criar em "/home/helton2/" o arquivo "resultados.txt" com valores semelhantes (depende de em que dia você está executando e quão rápida é sua máquina) aos listado abaixo:


1240195429.991010    1240195432.975001    2.983991
1240195432.980598    1240195436.225005    3.244407
1240195436.230919    1240195439.232810    3.001891
1240195439.238001    1240195442.226818    2.988817
1240195442.231239    1240195445.222347    2.991108
1240195445.228246    1240195448.210298    2.982052
1240195448.216515    1240195451.466147    3.249632
1240195451.472111    1240195454.732387    3.260276
1240195454.738784    1240195457.728088    2.989304
1240195457.734230    1240195460.976687    3.242457
1240195460.981184    1240195464.242882    3.261698
1240195464.247674    1240195467.239435    2.991761
1240195467.245351    1240195470.236075    2.990724
1240195470.241656    1240195473.518475    3.276819
1240195473.522821    1240195476.506720    2.983899
1240195476.511950    1240195479.494113    2.982163
1240195479.499256    1240195482.492852    2.993596
1240195482.497447    1240195485.473576    2.976129
1240195485.478231    1240195488.463446    2.985215
1240195488.471239    1240195491.746600    3.275361
1240195491.752356    1240195494.763777    3.011421
1240195494.768697    1240195498.037331    3.268634
1240195498.041838    1240195501.072781    3.030943
1240195501.077732    1240195504.334191    3.256459
1240195504.340106    1240195507.636492    3.296386
1240195507.641648    1240195510.639141    2.997493
1240195510.644422    1240195513.607822    2.963400
1240195513.613151    1240195516.608085    2.994934
1240195516.613102    1240195519.872248    3.259146
1240195519.877602    1240195523.154833    3.277231
1240195523.162235    1240195526.428517    3.266282
1240195526.433406    1240195529.866800    3.433394
1240195529.879949    1240195533.494374    3.614425
1240195533.499518    1240195536.512687    3.013169
1240195536.517868    1240195539.777852    3.259984
1240195539.784743    1240195543.055148    3.270405
1240195543.060538    1240195546.337556    3.277018
1240195546.343325    1240195549.587118    3.243793
1240195549.591585    1240195552.838038    3.246453
1240195552.844843    1240195556.124090    3.279247
1240195556.129737    1240195559.367544    3.237807
1240195559.375004    1240195562.423662    3.048658
1240195562.428425    1240195565.675685    3.247260
1240195565.680207    1240195568.961254    3.281047
1240195568.966475    1240195572.196674    3.230199
1240195572.202217    1240195575.433472    3.231255
1240195575.454523    1240195578.449320    2.994797
1240195578.454862    1240195581.466028    3.011166
1240195581.471327    1240195584.739090    3.267763
1240195584.744280    1240195587.976532    3.232252

Agora sim temos dados um pouco melhores!!! Copie-os na sua planilha de cálculos preferida e jogue com os dados!!!!

Aqui achei algumas coisas:

melhor tempo: 2,9634000
pior tempo: 3,6144250
tempo médio: 3,1538744
Maior diferença de tempo : 0,6510250

Sem contar que daria para fazer um belo gráfico de dispersão com esses dados!

Valeu pessoal!!

Planejo fazer meu próximo post sobre structs.

Agradescimentos a Claudio Schepke pela dica da função gettimeofday

Calculadora em C utilizando pilhas

2009-03-30T15:45:00.004-03:00

Olá, exemplo muito básico, mas muito básico mesmo, de uma calculadora com as 4 operações básicas feito no Dev-C++ utilizando a linguagem C e também o conceito de pilhas. Este programa pede para o usuário digitar dois valores e armazena eles em uma pilha (vetor), depois pede para o usuário informar a operação desejada, desempilha os valores e armazena eles em variáveis auxiliares, isso poderia ser tirado fora mas pro melhor entendimento preferi deixar assim, feita a operação é armazenado o resultado na pilha novamente e chamado a função que exibe o resultado final.


/*
  Name: Calculadora
  Author: Bol�var Arthur Butzke
  Date: 23/03/09 21:52
  Description: Calculadora. Programa que utilize pilhas para efetuar as opera��es b�sicas: 
               adi��o, subtra��o, divis�o e multiplica��o.
*/
/* Bibliotecas de Fun��es */
#include <stdio.h>
#include <stdlib.h>
/* Constantes */
#define MAX 10
#define BASE 0
/* Vari�veis */
int TOPO=0, OPERACAO=0;
float VETOR[MAX], VALOR=0, N1=0, N2=0, RESULTADO=0;
/* Fun��o para inserir elementos na pilha */
void EMPILHAR(float VALOR)
{
     if (TOPO == MAX)
        printf("Buffer OverFlow - Pilha Cheia.\n");
     else                
        VETOR[TOPO] = VALOR;
     TOPO++;
}
/* Fun��o para retirar elementos da pilha */
float DESEMPILHAR()
{
     if (TOPO == BASE)
        printf("Buffer UnderFlow! Pilha Vazia.\n");
     else 
     {
        TOPO--;   
        RESULTADO = VETOR[TOPO]; 
     }
     return RESULTADO;
}
/* Fun��o para efetuar as opera��es */

void CALCULA()
{
    int RESULT = 0;
    
         if (OPERACAO == 1) {
              printf("\nOperacao de Adicao\n"); 
              N1 = DESEMPILHAR();
              N2 = DESEMPILHAR();
              RESULTADO = N1 + N2;
              printf("\n%f + %f = %f\n",N1,N2,RESULTADO);
              EMPILHAR(RESULTADO); 
              RESULT = 1;
              }
         if (OPERACAO == 2) {
              printf("\nOperacao de Subtracao\n"); 
              N1 = DESEMPILHAR();
              N2 = DESEMPILHAR();
              RESULTADO = N1 - N2;
              printf("\n%f - %f = %f\n",N1,N2,RESULTADO);
              EMPILHAR(RESULTADO); 
              RESULT = 1;
              }              
         if (OPERACAO == 3) {
              printf("\nOperacao de Multiplicacao\n"); 
              N1 = DESEMPILHAR();
              N2 = DESEMPILHAR();
              RESULTADO = N1 * N2;
              printf("\n%f * %f = %f\n",N1,N2,RESULTADO);
              EMPILHAR(RESULTADO); 
              RESULT = 1;
              }
         if (OPERACAO == 4) {
              printf("\nOperacao de Divisao\n"); 
              N1 = DESEMPILHAR();
              N2 = DESEMPILHAR();
              RESULTADO = N1 / N2;
              printf("\n%f / %f = %f\n",N1,N2,RESULTADO);
              EMPILHAR(RESULTADO); 
              RESULT = 1;
              }
//         printf("Operacao informada invalida. Operacoes validas sao:\n adicao (+)\n subtracao (-)\n multiplicacao (*)\n divisao (/)\n");
       if (RESULT==0)
         {
            printf("\nOperacao nao encontrada. \n1 -> Adicao\n2 -> Subtracao\n3 -> Multiplicacao\n4 -> Divisao\nInforme a operacao novamente: ");
            scanf("%d",&OPERACAO);
            CALCULA();
         }
    
}
/* Fun��o para exibir o resultado */
void MOSTRARESULTADO()
{
      printf("Resultado da operacao e' %f\n",VETOR[BASE]);
}

/* Fun��o Principal */
int main()
{
    int AUXILIAR=1;
    printf("\n  Calculadora 1.0\n");
    while (AUXILIAR != 0)
    {
          printf("\nDigite o valor1: ");
          scanf("%f",&N1);
          EMPILHAR(N1);
          printf("\nDigite o valor2: ");
          scanf("%f",&N2);
          EMPILHAR(N2);
          printf("\n1 -> Adicao\n2 -> Subtracao\n3 -> Multiplicacao\n4 -> Divisao");
          printf("\nDigite a operacao: ");
          scanf("%d",&OPERACAO);
          CALCULA();
          MOSTRARESULTADO();
          printf("\nDigite 0 para sair ou 1 para realizar outra operacao: ");
          scanf("%d",&AUXILIAR);
          // nencess�rio para limpar a pilha ap�s realizar uma opera��o, sem isso vai mostrar sempre o resultado da primeira opera��o.
          TOPO = BASE;
    }
    return 0; 
}

Para entender melhor o conceito de pilhas, pense em uma pilha de pratos, quando você precisa de um prato você vai e retira o que está em cima, quando não precisa mais, você coloca ele em cima novamente, assim, sempre o último prato empilhado é o primeiro que sai, leia este post sobre listas encadeadas para saber mais.

Transpor Matriz em Vetor

2009-03-20T23:11:00.005-03:00

Olá galera do ICC!!

Hoje vou postar um programinha feito por mim durante uma aula de revisão, ele é muito simples, possui basicamente uma matriz de ordem 10 e um vetor de 100 elementos.

Segue abaixo o código-fonte.

/*
Data: 09/03/2009
Autor: Bolívar Arthur Butzke

E-mail: bolivarbutzke@gmail.com
Blog: bolivarbutzke.blogspot.com

1) Considerando uma matriz “M”, com a seguinte definição: 

              [ M(I,J), (I = 1..10), (J = 1..10) ] e um vetor

              V(I), (I = 1..100), escreva os seguintes procedimentos:

i) Um procedimento que mostre a diagonal principal da matriz
ii) Um procedimento de consulta e um de atribuição para os elementos da matriz “M”
iii) Um procedimento que transponha a matriz “M” para o vetor “V”
*/

#include stdio.h
#include time.h

/* Prototipação das Funções */
void DiagonalPrincipal(void);
void Consultar(void);
void Atribuir(void);
void Trasnpor(void);
void ExibirVetor(void);
void ExibirMatriz(void);

/* Declaração das variáveis Globais */
int M[10][10], i, j, V[100], n; 

int main()
{
 /* Preenche a matriz com números aleatórios */ 
 for (i=0;i<10;i++)
  for (j=0;j<10;j++)
  {
   srand(time(NULL)+i*j);   
   M[i][j] = rand() % 100;
  }
 /* Chama função que exibe a matriz */
 ExibirMatriz();
 /* Chama função que exibe a diagonal principal */
 DiagonalPrincipal();
 /* Chama função que consulta na matriz */
 Consultar();
 /* Chama função que cadastra valor na matriz */ 
 Atribuir();
 /* Chama função que transpoe a matriz em vetor */
 Trasnpor();
 /* Chama função que exibe o vetor */
 ExibirVetor();
 /* Encerra a função main retornando um inteiro -> 0 */
 return 0;
}

void DiagonalPrincipal(void)
{
 /* Procedimento que Exibe a diagonal principal da matriz */
 printf("\n\n--------------------------------------------------\n");
 printf(" Diagonal Principal da Matriz");
 printf("\n--------------------------------------------------\n");
 for (i=0;i<10;i++)
  for (j=0;j<10;j++)
   if (i==j)    
    printf("%d ",M[i][j]); 
}

void Consultar(void)
{
 /* Procedimento de Consulta na Matriz M */ 
 printf("\n\n--------------------------------------------------\n");
 printf(" Consulta dos Elementos da Matriz");
 printf("\n--------------------------------------------------\n");
 printf("\n Informe a linha do elemento: ");
 scanf("%d",&i);
 printf("\n Informe a coluna do elemento: ");
 scanf("%d",&j);
 printf("\n Valor armazenado Matriz[%d][%d]: %d\n",i,j,M[i][j]);
}

void Atribuir(void)
{
 /* Procedimento de Atribuição de Valor para um elemento da Matriz M */
 printf("\n\n--------------------------------------------------\n");
 printf(" Atribuição de Valor para um elemento da Matriz");
 printf("\n--------------------------------------------------\n");
 printf("\n Informe a linha do elemento: ");
 scanf("%d",&i);
 printf("\n Informe a coluna do elemento: ");
 scanf("%d",&j);
 printf("\n Informe o valor para armazenar: ");
 scanf("%d",&M[i][j]);
 printf("\n Valor armazenado Matriz[%d][%d]: %d\n\n",i,j,M[i][j]); 
}

void Trasnpor(void)
{
 /* Procedimento para transpor a Matriz M para o Vetor V */
 printf("\n\n--------------------------------------------------\n");
 printf(" Transposição da Matriz M para o Vetor V");
 printf("\n--------------------------------------------------\n");
 n = 0;
 for (i=0;i<10;i++)
  for (j=0;j<10;j++)
  {    
   V[n] = M[i][j];
   n++;
  }
}

void ExibirVetor(void)
{
 /* Exibe dados no vetor */
 printf("\n\n--------------------------------------------------\n");
 printf(" Dados do Vetor");
 printf("\n--------------------------------------------------\n");
 for (n=0;n<100;n++)
  printf("Vetor[%d] = %d\n",n,V[n]);
}

void ExibirMatriz(void)
{
 /* Exibe dados da matriz */
 printf("\n\n--------------------------------------------------\n");
 printf(" Dados armazenados na Matriz");
 printf("\n--------------------------------------------------\n");
 for (i=0;i<10;i++)
 {
  for (j=0;j<10;j++)
  {
   printf("%d ",M[i][j]);
  }
 printf("\n");
 }
}

Bem, no início do programa eu precisei incluir o arquivo de cabeçalho (header) stdio.h (Standart Input/Output) para poder executar os comandos de entrada e saída como printf e scanf, sendo que o printf serve para imprimir uma mensagem na tela e o scanf serve para ler algum valor formatado, por isso precisa passar um parametro dizendo qual o tipo de dados que vai receber e em qual variável vai armazenar, neste caso as variáveis eram todas do tipo integer (valores inteiros) então a máscara é %d. Também precisei incluir o time.h para usar a função time e poder atribuir valores aleatórios conforme hora do sistema nos elementos da matriz.

Quando copiar este código para testar lembre-se de que precisa ter o sinal de "menor que" antes do nome dos arquivos de cabeçalho e o sinal de "maior que" no final para que o seu compilador preferido busque estes arquivos.header na pasta padrão do compilador, se por acaso você tiver estes arquivos cole-os no mesmo diretório/pasta do arquivo com código-fonte.c e então coloque os nomes dos arquivos de cabeçalho dentro de "aspas duplas".

A função que passa os valores armazenados na matriz para o vetor é muito simples, primeiramente inicializamos a variável n com o valor zero, que corresponde ao primeiro elemento do vetor (lembre-se que sempre começamos a contar do zero). Depois fizemos dois for , que chamamos de laços aninhados para acessar os elementos da matriz, no primeiro laço dizemos qual linha estamos e no segundo a coluna, assim podemos percorrer todos os elementos da matriz.

Dentro deste laços aninhados, atribuimos o valor da matriz para o vetor e somamos 1 na variável n, assim quando o laço se repetir a segunda vez passaremos o valor armazenada na linha 0 e coluna 1 para a posição 1 do vetor, na terceira vez ainda será o valor da linha zero mas coluna dois e n valerá 2, e assim por diante até passarmos os 100 valores armazenados na matriz para o vetor.

A função "DiagonalPrincipal" serve para exibir os elementos que se encontram na Diagonal Principal, ou seja, os elementos onde o número da linha é igual ao número da coluna. Outras funções mais simples são para atribuir um valor para um determinado elemento da matriz e consultar o valor de um elemento da matriz, em nenhuma das funções eu precisei passar valores por parametros ou ponteiros porque neste programa específico estamos utilizando variáveis globais que ficam visíveis em todo o programa.

Por enquanto é isso, em breve artigo sobre listas encadeadas.

Listas Encadeadas

2009-03-20T00:24:00.013-03:00

Olá galera do ICC!!!

Estamos de volta e com conteúdo muito divertido, esta semana tirei para estudar um pouco sobre listas em C e é muito legal. Bom para começar, sempre que queremos guardar um grupo de dados podemos utilizar vetores ou matrizes, isso faz com que você utilize um espaço contíguo na memória, que mesmo com alocação dinâmica de memória vai necessariamente ser sequencial, então podemos acessar qualquer elemento do vetor passando apenas o ponteiro para o primeiro elemento.

Até neste ponto tudo bem, mas um vetor não é uma estrutura muito flexível, é necessário definir um tamanho máximo para ele, mesmo usando alocação dinâmica para definir/alterar o tamanho do vetor isso acaba custando caro em relação a processamento e uso da região da memória livre reservada para execução do programa (Heap). Isso pode gerar muitos problemas como estouros de memória ao tentar inserir mais um elemento em um vetor cheio (Overflow) ou então Buffer Underflow ao tentar ler um vetor vazio.

Para resolver estes problemas foram criadas as listas encadeadas, são nada mais do que uma estrura de dados com elementos ordenados do mesmo tipo. Elas podem ter o formato de filas ou pilhas, nas filas os dados são inseridos em uma estremidade e retirados na outra, conhecido como FIFO (First In, First Out) e nas pilhas os dados que são inseridos por último são retirados primeiro, conhecido como LIFO (Last In, First Out).

Uma lista encadeada pode ser inicializada sem nenhum valor e a medida que vamos inserindo elementos nela vamos alocando memória dinâmicamente, assim o risco de faltar memória diminui pois não precisamos alocar uma grande quantidade de memória que não vai ser usada depois e não corremos o risco de ocorrer overflow. Quando queremos inserir um novo elemento na lista precisamos criar um nó, que é um ponteiro com endereço de memória do elemento e o valor o valor do elemento, o controle dos dados passa a ser logico e diminui o processamento necessário para recuperar os valores armazenados.

Em breve exemplos utilizando pilhas e listas encadeadas.

Até.

Acesso a banco de dados MySQL

2009-03-04T23:54:00.028-03:00

Olá pessoal...

Bom sendo este o meu primeiro post aqui no Include C/C++ e este post se destina a criar uma aplicação que tenha acesso a um banco de dados MySQL. Então vamos lá, agora que vocês já devem ter tudo funcionando 100% após ter lido o post Compilando C/C++ no Linux e no Windows.

Agora então agora é necessário instalar o servidor de banco de dados MySQL. No linux basta digitar apt-get install mysql-server-X.X onde X é a versão. Nós iremos utilizar a 5.0 (mysql-server-5.0). São aproximadamente 36MB. Após baixado e instalado uma senha é requisitada, eu utilizei a famosa senha 123.

Para que se consiga utilizar a biblioteca mysql é necessário baixar a libmysqlclient-dev, também através do apt-get.

Com o serviço instalado vamos criar as tabelas, para isto abra um terminal e digite mysql --user=root -p, então pedirá uma senha, esta senha é do root do MySQL então vamos inserir a senha que você definiu (no meu caso 123) e pronto estamos conectados com o serviço. Vamos então digitar...


create database acessodb;

connect acessodb;

CREATE TABLE `usuarios` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`usuario` varchar(20) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5;

INSERT INTO `usuarios` (`id`, `usuario`) VALUES
(1, 'Mauricio Sipmann'),
(2, 'Bolivar Arthur Butzke'),
(3, 'Helton Ritter'),
(4, 'Michel de Sousa');

Então ta, criamos um banco de dados, criamos a tabela e inserimos uns dados para podermos testar o banco, para sair do serviço basta digitar exit. Agora para conectar

Feito isto vamos para o código-fonte do progrma em C++.


#include   // Para usar o cin.get
#include  // mysql/mysql.h  biblioteca mysql  
#include  // para usar o istringstream

using namespace std;

int main(void)
{
 MYSQL DBCon; // Vairiavel de conexão
 MYSQL_RES *result; //variável que recebe o resultado
 MYSQL_ROW dados; //variável que recebe os dados

 int ID; // Converter para integer

 // Inicia a variável DBCon
 mysql_init(&DBCon);

 //Conecta com o banco de dados
 if ( mysql_real_connect(&DBCon, "127.0.0.1", "root", "", "acessoaobd", 0, NULL, 0) )
 {
       printf("Conectado!\n\n");
  }
  else
  {
       //Escreve o erro que ocorreu
       printf("Erro n %d : %s\n", mysql_errno(&DBCon), mysql_error(&DBCon));
   cin.get();  //Espera o usuário pressionar uma tecla
   cin.get();
   return 1;
  }

// Executa a consulta
if(mysql_query(&DBCon,"select * from usuarios"))
{
printf("Erro n %d : %s\n",mysql_errno(&DBCon),mysql_error(&DBCon));
cin.get();
cin.get();
return 1;
}

// Recebe os dados da cunsulta
result = mysql_store_result(&DBCon);

// Se consultou (sem erros)
if (result)
{
// Enquanto receber dados vai escrevendo
while ((dados=mysql_fetch_row(result)) != NULL)
{
 // Escreve os dados formatados sende estes a ID e o NOME

 istringstream buffer(dados[0]); // Cria a variável que recebera a string a ser convertida para int
 buffer >> ID; // Convert a string para int
 printf("%02d     %s\n",ID,dados[1]); // Escreve formatado
}

// Limpa da memória
mysql_free_result(result);

}
else
{
printf("Erro n %d : %s\n", mysql_errno(&DBCon), mysql_error(&DBCon));
cin.get();
cin.get();
return 1;
}
printf("\n");
// Fecha a conexão ...
mysql_close(&DBCon);

return 0;
}

Então vamos as explicações. As primeiras linhas fazem referência às bibliotecas que iremos utilizar, iostream para as funções cout e cin, mysql.h para acessarmos o banco de dados, e sstream para convertermos as variáveis de string para int. O código quinta linha tem a função de minimizar o trabalho teriamos quando utilizássemos o cin.get ou cout << "texto", teríamos que escrever sempre std::cout << "" com este using namespace STD poupamos trabalho. Então definimos as variáveis DBCon, result, dados e ID, a variável DBCon é a nossa conexão com o banco, result é a variável que armazena o resultado de uma consulta e a variável dados é que receberá os dados de cada linha para escrevermos (veremos mais adiante nas explicações). A função mysql_ini(&DBCon) tem a finalidade de incializar a variável de conexão com o banco pois precisaremos dela diversas vezes como verão. Agora uma parte interessante e que vai do gosto de cada um. Existem 2 funções para se conectar com o banco de dados, são elas:

MYSQL * mysql_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd);
MYSQL * mysql_real_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd, const char *db, unsigned int port, const char *unix_socket, unsigned int clientflag);

A diferença é que na mysql_real_connet nós já especificamos o banco ao qual queremos nos conectar, já a mysql_connect só conecta e então seria necessário o uso da função mysql_select_db. Nós usaremos a real_connect, onde são necessários os seguintes parâmetros:


mysql_real_connect(variavel_de_conexao(&DBCon),"servidor(127.0.0.1)","usuario(root)","senha(123)","banco_de_dados(acessodb)",porta_de_conexão(0 para padrão),socket(NULL para padrão), flags_do_cliente(0 para padrão));

Caso ocorra algum erro utilizamos a função printf("Erro n %d: %s",mysql_errno(&DBCon), mysql_error(&DBCon)) onde formatamos para receber um inteiro e uma string, onde mysql_errno traz o numero do erro e mysql_error traz a mensagem de erro, então adicionamos 2 vezes cin.get() e um return 1 para que espere o usuário pressionar qualquer tecla para que finalize o programa.

Então chegamos a parte de execução de uma consulta com o mysql_query(&DBCon,"select * from usuarios"), então esta na cara, variável de conexão e em seguida a nossa SQL de seleção, e também é claro um tratamento de erro.

O pŕoximo passo então é armazenar o resultado completo da consulta em uma variável que é a variável result, result = mysql_store_result(&DBCon), esta função é necessário somente passar a variável de conexão, e como padrão checar se não houve erros durante a seleção. Após tudo isto chegamos na parte em que os dados serão exibidos... para isto é necessário fazer um laço para percorrer todas as linhas que retornaram do banco de dados, por isso o while, onde a variável dados recebe a linha atual, ele se transforma numa array.

É dentro do laço que é feito a conversão do campo ID que é string para int para que assim seja possível formatar o valor retornado com o printf.

istringstream buffer(dados[0]); // Cria a variável e já atribui o valor para ela
buffer >> ID; // Convert a string para int

Portanto o índice 0 da array dados é a ID, então o indece 1 é o campo usuário, e assim segue para cada campo seguinte. A formatação usada no printf %02d é utilizada para que sempre seja impresso numero com 2 casas decimais... EX: 04

Concluindo o código o mysql_free_result limpa da memória a pesquisa e o mysql_close encerra a conexão com o banco de dados. Bom, código feito, é hora de compilar, no linux para compilar (lembrando que este é um código C++) seria:

g++ -c arquivo.cpp -lmysqlclient

g++ -o arquivo arquivo.o -lmysqlclient

Bom... Para que este -lmysqlclient?? Ele é usado para associar a libmysql-cliet-dev que nós baixamos antes ao nosso sistema.

Então esta ai. Espero que tenham gostado. Até a próxima...

Hello World multi-idiomas com alocação dinâmica de memória e ponteiros

2009-03-04T01:07:00.011-03:00

Olá pessoal!

Já vimos como desenvolver, sabemos o que precisamos tanto em Linux quanto em Windows para escrever/rodar nossos programas. É claro que se trata do modo mais básico, depois acabamos ajustando para aquilo que estamos desenvolvendo especificamente.

Bom, no post anterior você viu como fazer um "hello world" em C e também em C++. Agora o código é C, e a partir dele iniciaremos postagens referentes a alguns assuntos chaves nessa linguagem:

- Trabalhar com vetores e matrizes (bidimensionais e multidimensionais);

- Trabalhar com alocação dinâmica de memória;

- Trabalhar com strings.

Sem mais delongas confira o código:

/*
Author: Helton Eduardo Ritter
Date:2009-03-04

This program dinamic alloc memory to print "hello world" message
*/

#include  // necessary to printf
#include  // necessary to malloc
#include  // necessary to time

int main()
{
 char **texts; // this is a pointer
 int i,j,k;

 // dinamic allocate memory to = 4 languages, 20 space string
 for(i=0;i<4;i++)
  texts[i] = malloc(20 * sizeof(char));

 // set texts
 texts[0] = "Hello world!"; // english
 texts[1] = "Hallo Velt!"; // german
 texts[2] = "Ola mundo!"; // portuguese
 texts[3] = "Holla mundo!"; // Spanisch

 // clear values
 srand(time(NULL));
 k =  rand() % 4;

 // print the random gretings
 printf("%s",texts[k]); 

 // the declaration of main function say that this function "retun int value"
 return 0;

}

Vamos as considerações que podem parecer básicas, mas que refrescam a mente de quem está já a algum tempo sem programar em C.

- No início do arquivo principal, você deve incluir as bibliotecas das quais durante o código você vai usar funções. A biblioteca que normalmente está presente em todos os projetos é a "stdio.h" (standard I/O - input/output), ou seja sempre que precisar dar entrada ou saída em alguma informação, precisará incluir essa biblioteca.

- Os delimitadores de comentários em C são os mesmos em muitas outras linguagens de programação. /* comentário aqui de multiplas linhas */ e também tem o // comentário de uma linha.

- O main (embora seja o bloco principal) também é uma função e deve retornar um tipo de dados tal qual foi declarado, por isso daquele return antes de fechar o bloco do main (apenas evitar warning no compilador);

- Na alocação de memória, o malloc retorna void, você deve passar como parâmetro para ele quanto de memória alocar, mas esse tamanho (bytes) dependem da arquitetura da maquina, logo um int em um processador 32 bits tem um tamanho diferente de um int em um processador 64, por isso que sempre fazermos o cálculo em cima de um tipo de dados e não passamos valores fixos;

- O random no C não funciona muito bem se antes você não "limpar" ou mandar "zerar", se esquecer ele sorteará com muita frequencia o mesmo valor;

- Por último e não menos importante temos o "%s" que é a "mascara" do printf que formata o valor passado a partir do segundo parâmetro nesta função. O "%s" no caso diz que o printf deverá formatar o valor como uma string.

Temos neste artigo vários tópicos abordados por alto, bem superficialmente. Em outro momento entraremos em detalhes de cada um.

Até mais!

Compilando C/C++ no Linux e no Windows

2009-03-03T19:35:00.006-03:00

Olá galera do Include C/C++!!

Este é meu primeiro post aqui no ICC e pretendo mostrar o mais básico, como compilar um programa básico em C ou C++ no linux e no Windows.

Primeiramente, vamos montar uma máquina com os softwares necessárias para programar em C/C++, caso o sistema operacional de sua preferência seja o Windows, a maneira mais fácil é baixar e instalar o Bloodshed Dev-C++, é um programa gratuito e pode ser baixado aqui, após instalar o Dev-C++ sua máquina Windows está pronta. Caso você utilize Linux, é um pouco mais fácil, a maioria das distribuições Linux já vem com o compilador GCC instalado ou então nos repositórios, bastando instalar, para este post estou utilizando Ubuntu 8.10 que pode ser baixado aqui. Para deixar sua máquina com tudo em cima no Ubuntu recomendo executar os seguintes comandos para garantir o bom funcionamento.

**Importante, é necessário estar logado como root ou ter permissões de administrador para executar estes comandos, se você estiver logado com outro usuário pode usar o comando "sudo -s" para adquirir privilégios de administrador.

Atualizando o sistema:


 apt-get update
 apt-get upgrade

Instalando o Buil-Essential


 apt-get install build-essential

Feito isso, temos nossa máquina devidamente equipada com os softwares para criar nosso primeiro programa em C/C++.

Pra começar vamos criar um programa que imprima na tela a frase "Hello World!".

Código em C:


#include
main()
{
 printf("Hello World!\n");
}

Código em C++:


#include 
int main()
{
 std::cout << "Hello World!\n" << std::endl;
 return 0;
}

Para compilar no Windows execute o Bloodshed Dev-C++, crie um novo arquivo, copie e cole o código-fonte no arquivo, salve como hello.c ou hello.cpp e pressione F9 para compilar e executar o programa. No Dev-C++ não tem diferença na compilação e execução do código-fonte, tanto para C quanto para C++, basta pressionar F9.

Para compilar no Ubuntu abra qualquer editor de texto puro, pode ser o gedit, crie um novo arquivo, salve o arquivo com código em C como hello.c e o arquivo com código em C++ como hello.cpp, para compilar vá para o terminal (CTRL+ALT+F1) ou abra um terminal em modo design mesmo, basta pressionar as teclas ALT+F2 e executar "gnome-terminal" ou "xterm" para abrir um console de linha de comando, agora vem a parte divertida, vá até o diretório (pasta) onde você salvou os arquivos e execute os seguintes comandos para compilar o programa em C:

Garantir permissão de Administrador


 sudo -s

Compilar o programa


 gcc -c hello.c
 gcc -o hello hello.o

Executar o programa


 ./hello

O programa imprimirá na tela a frase Hello World!

Para compilar e executar o programa em C++, execute os mesmos passos do programa em C, mas na hora executar os comandos trocar o gcc por g++ e a extenção do arquivo para .cpp, fica assim:

Garantir permissão de Administrador


 sudo -s

Compilar o programa


 g++ -c hello.cpp
 g++ -o hello hello.o

Executar o programa


 ./hello

Por enquanto é isso, até a próxima!

Bem vindo ao Include C/C++

2009-03-03T09:03:00.000-03:00

Olá ! caro amigo(a)

Este é o post inaugural do mais novo e revolucionário blog dedicado a linguagem de programação C/C++ e seus entornos (bibliotecas, compiladores...).

Temos um time de geeks tarados por tecnologia e programação, logo surgirão coisas muito loucas aqui no blog, do "hello world" a sockets, rede, banco de dados, talvez alguma coisa de jogos, OpenGL, GTK e o que mais a criatividade permitir.

Assine nosso feed e nos acompanhe nessa saga fantástica! Não percam os próximos episódios.

Até mais