Construindo Interfaces gráficas com PySide - QWidget

Fala pessoal, estou de volta dessa vez para falar mais de PySide =). Se você ainda não leu os posts anteriores a esse aqui no blog, por favor leia acessando a tag (PySide).

Até agora rabiscamos algumas apps em cima de nosso toolkit gráfico, mas chegou a hora de começar a desvendar o nosso PySide. Vamos falar hoje da classe QWidget que é a base dos componentes: Buttons, Text Fields, Check Box .. etc.

 

QWidget

A classe QWidget é a classe base para todos os objetos de interface do usuário. Portanto uma tela é formada de vários QWidgets, claro que um QWidget é responsável por agrupar os demais. Dai aquela famosa nomenclatura childs and parents ;).

A única coisa que não pode ser agrupada em uma QWidget são as janelas, geralmente janelas tem um contorno e uma barra de título, digo geralmente pois podemos omitir essas características na construção de nossa janela. Em PySide podemos ter uma QWidget sem um pai, quando isso acontece dizemos que temos uma QWidget top-level, essas widgets tem barra de título e ícone. Apesar de poder ter uma widget independente (top-level) isso não é muito usado.

 

Widgets compostas

Widgets compostas são widgets que abrigam outras widgets (filhas). Não existe um número máximo de filhos que uma QWidget pode ter. Pense em um QFrame (ainda não aprendemos sobre ele, mas é uma área onde podemos adicionar objetos) e nele pode ser adicionado vários widgets (botões, campos de texto, campos de seleção, etc).

 

Minha primeira Widget

Vamos lá galera hora de entender o código. O que fazemos nesse código é codificar o evento de duplo clique, quando isso ocorre o titulo da janela altera ... faça o teste.

Como de praxe as primeiras linhas são os importes necessários das classes e módulos que vamos utilizar em nosso programa. Depois definimos nossa classe (Window) que herda de QWidget. Já no construtor alteramos o título de nossa janela para Aplicacao Bala.

Depois definimos um método que na verdade é um tratador de eventos (aprenderemos mais sobre isso nos próximos posts), esse método trata o duplo clique na área da minha QWidget, ou seja, se o usuário clicar duas vezes no interior de minha QWidget, então o método vai ser executado. Quando o método for executado ele vai imprimir no terminal o valor de event e alterar o título da QWidget para funciona!!!.

Agradecimentos

Esse post é só para introduzir a classe QWidget, no posso post vamos trabalhar mais os eventos que podemos ter em nossas widgets. Até a próxima pessoal =).

Construindo interfaces gráficas com PySide - QMenuBar / QMenu / QAction

Fala pessoal, tudo ...

Hoje vou continuar falando de PySide. Vou mostrar como inserir barra de menu, menus e ações.

Motivação

Na grande maioria das vezes quando escrevemos uma interface gráfica precisamos disponibilizar ao nosso usuário uma barra de menu com algumas operações. Fazer a divisão das operações em menus com nomes significativos, facilita o uso do seu software. Hoje em dia a maioria dos softwares fazem o uso de menus para dividir as ações que o programa oferece, um bom exemplo é o seu navegador ... imagine como seria complicado utilizá-lo se ele não tivesse um menu para dividir as operações.

 Mostre o código

Agora é a hora legal, onde o Guilherme para de falar e exibe o código, vamos lá? Veja como é o código e confira a explicação logo em seguida:

Nas linhas 4,5,6 importo os módulos que vou usar em meu programa. Nesse caso mostrei como importar todas as classes presentes no módulo QtGui e QtCore, fazendo dessa maneira você não precisa escrever por nome do módulo mais o nome da classe, por exemplo QtGui.MainWindow.

Da linha 8 à 36 tenho a definição de uma classe que herda de MainWindow (caso você não saiba o que é a MainWindow leia). As novidades começam a surir a partir da linha 14, onde uso o método setGeometry que pede 4 argumentos (posx, posy, largura, altura) para definir a janela.

Na linha 18 eu crio uma barra de menu utilizando o construtor  da classe QMenuBar. Toda MainWindow já possui uma barra de menu por definição, portanto também poderíamos apenas recuperar a QMenuBar sem precisar instanciar uma nova, veja:

Depois da barra de menu criada na linha 19 eu crio um menu utilizando o construtor QMenu. O construtor de QMenu pode ter dois ou um parâmetro, o primeiro parâmetro é o texto que será mostrado na barra de menus, o segundo é o elemento pai do menu. Esse parâmetro exerce o seguinte comportamento, quando a janela pai do menu é destruída o menu também é removido.

Por enquanto já temos o menu e temos a barra de menu, mas ainda falta criar ações para esse menu, ou seja, quais funções vão ser colocadas/agrupadas naquele menu, por exemplo: menu file tem as actions save, open, save as.

Para criar uma ação utilizamos o construtor QAction(), esse construtor pode ter vários parâmetros de configuração como: ícones, teclas de aderência (Ctrl + A), texto exibido na barra de status. Por isso cabe uma consulta um pouco mais detalhada a documentação para poder usar todos os recursos dele. Eu apenas defini o texto de apresentação e a ação (método) que ele executa, acredito que seja o as principais funções dele. O primeiro parâmetro é o texto que vai parecer quando o menu for aberto, o segundo parâmetro é o elemento pai da QAction e o terceiro e ultimo é o nome do método que a ação invoca quando é clicada.

Feito isso basta adicionar a action ao menu, e adicionar o menu na barra de status. Ufa está quase acabando, agora só falta definir o método que a QAction vai chamar, nesse código teremos que criar um método chamado hello().

Nas 34,35 e 36 está mostrando a definição do método hello. Esse método limpa a tela do terminal (Unix like) e escreve o texto Hello World.

No final você deve ter uma janela semelhante a essa em sua área de trabalho ao interpretar o código:

(menu do mac é na barra, em alguns linux isso também ocorre fique atento a esse detalhe).

Ao clicar no menu e na Action sobre o seu terminal deve ter o seguinte resultado:

Bom pessoal é isso ai, qualquer dúvida deixem comentários! Até a próxima e bons estudos.

Construindo interfaces gráficas com PySide - MainWindow

Fala pessoal, hoje vamos aprender como construir uma janela principal utilizando o toolkit gráfico PySide.

PySide é uma versão do PyQt com uma licença diferente, para mais informações vide a documentação oficial.

Motivação

Muitas vezes estamos programando alguns scripts Python, mas pela ausência de GUI nao conseguimos mostrar aos nossos pais os programas que fazemos (brincadeira pessoal).

A motivação aqui, é o fato que programas que possuem uma interface, tornam-se mais amigável  e conseguem alcansar um número  maior de usuários e também conseguem facilitar a execução de tarefas dentro do software.

Mostre o código

Agora é a hora legal, onde o Guilherme para de falar e exibe o código, vamos lá? Veja como é o código e confira a explicacao logo em seguida:

Na primeira linha fazemos a importação dos módulos QtGui e QtCore. Logo após criamos uma classe, que herda de QMainWindow.

Dentro da classe temos apenas 3 linhas, a primeira linha declara o construtor da classe ( __init__() ). Na segunda linha temos a chamada ao construtor da classe pai, nesse caso temos uma chamada ao construtor da classe QMainWindow. Na 3 e ultima linha da classe, chamamos o método serWindowTitle, ele tem um parâmetro do tipo str (string). Esse método altera o título da nossa janela.

Feito isso já temos uma janela escrita em PySide, porém, falta ainda um método para criar uma instância da janela, e iniciar a nossa app. Nas ultima linhas definimos o método main (um velho amigo). Na primeira linha do main temos a importação do módulo sys, logo após criamos uma aplicação. Depois criamos uma instância da classe janela, chamamos o método show() para exibi-la, e por fim mandamos a aplicação executar. 

Se você preferir, não precisamos criar o método main e nem importar o módulo sys ... Veja como ficaria:

O resultado final deve ser uma janela parecida com a que temos na imagem a seguir:

Bom é isso ai pessoal, até a próxima!! Bons estudos :)

Algoritmo produtor / consumidor - Python

Olá pessoal, na aula de SOP (Sistemas Operacionais) da minha faculdade meu professor pediu para que escrevêssemos um algoritmo para simular dois processos (A e B), onde o processo A era um produtor de valores e o processo B era um consumidor de valores.

Também era desejado que os dois processos pudessem operar de forma igual mesmo se os dois possuíssem velocidades diferentes. Exemplo:

[1 caso] Se o processo A (produtor) for mais veloz que o processo B (consumidor) ele deve produzir um número máximo N e logo em seguida dormir. O processo A será ativado novamente quando a lista estiver sem nenhum valor para ser consumido.

[2 caso] Se o processor B (consumidor) for mais veloz que o processo A (produtor) ele deve consumir todo o vetor de valores len(N) e logo em seguida dormir. O processo B (consumidor) será ativado novamente quando a lista estiver preenchida com valores para serem consumidos.

Para fazer esse tarefa usei a linguagem Python, e segue abaixo a minha implementação:

#! /usr/bin/python
# coding:utf-8

from random import randint
from time import sleep
import sys
import os

lista = [] #cria uma lista de valores com nenhum valor inserido
dormir_c = False #flag para desativar/ativar processo B (consumidor)
dormir_p = False #flag para desativar/ativar processo A (produtor)
length_max = int(sys.argv[1]) #tamanho max do vetor

#Processo A (produtor), produz valores para a lista
def produtor():
 global lista, length_max, dormir_c, dormir_p

 if not dormir_p: #verifica se processo está ativo
  while len(lista) < length_max: #verifica se a lista não atingiu seu tamanho máximo
   lista.append(randint(0, 1000)) #adiciona um valor inteiro entre 0 e 1000 à lista
   print 'Olá Sr. Programador eu sou o produtor, olha como está a lista de valores ' + str(lista)
  else:
   print 'Fiz o meu serviço olha como eu deixei a lista cheinha >>> ' + str(lista)
   print 'Agora eu vou tirar uma soneca. [Produtor está tirando uma soneca acorde ele quando a lista estiver vazia] \n'
   dormir_p = True #desativa o processo A
   dormir_c = False #ativa o processo B
   consumidor() #chama o consumidor

#Processo B (consumidor), consome valores da lista      
def consumidor():
 global lista, length_max, dormir_c, dormir_p

 if not dormir_c: #verifica se processo está ativo
  if lista: #verifica se a lista contem valores
   del lista[0] #remove o valor que se encontra no inicio da lista
   print 'Olá Sr. Programador eu sou o consumidor, olha como está a lista de valores' + str(lista)
  else:
   print 'Fiz o meu serviço olha como eu deixei a lista limpinha >>> ' + str(lista)
   print 'Agora eu vou tirar uma soneca. [Consumidor está tirando uma soneca, acorde ele quando a lista possuir valores] \n'
   dormir_c = True #desativa o processo B
   dormir_p = False #ativa o processo A
   produtor() #chama o produtor

while True: #loop infinito
 #inicia a brincadeira
 produtor() 
 consumidor()
 sleep(5) #trava a tela a cada iteração para podermos ver os processos em execução
 print '-----------------------------------------------------------------------------------------------------------------------------------'

Para executar o script, você deve informar o número máximo de itens que a lista pode conter. Esse parâmetro deve ser informado por linha de comando. Desse modo para executarmos nosso script temos que fazer:

user@server$ python algoritmo.py  N

Onde N é um número inteiro aleatório. Quando quiser encerrar a execução basta pressionar Ctrl+C. Espero que gostem do material e até a próxima!

Atualizando o Firefox no Slackware - Slackware [14]

Olá pessoal, cansado do Firefox 15 que a instalação do Slackware 14 traz por padrão? Hoje vou mostrar como atualizar o seu Firefox para a versão mais atual (no momento em que escrevi esse post estava na versão 23). Vamos laá então.

Atualizando o Firefox

Bom primeiramente você deve baixar a versão do Firefox que deseja instalar em sua máquina diretamente pelo site do fornecedor https://www.mozilla.org/pt-BR/firefox/fx/.

Página de download do navegador mozilla firefox.

Após o termino do download vá até o diretório e descompacte o pacote baixado. Abaixo fiz uma pequena demonstração de como utilizar a linha de comando nesse caso. Veja:

root@user:# su -
root@user:# wget http://https://www.mozilla.org/pt-BR/firefox/fx/ firefox-23.0.1.tar.bz2
root@user:# tar -jxvf firefox-23.0.1.tar.bz2
root@user:# mv firefox firefox-23
root@user:# mv firefox /usr/lib/
root@user:# rm /usr/bin/firefox
root@user:# cd /usr/bin
root@user:# ln -s /usr/lib/firefox-23/firefox firefox
root@user:# rm -r /usr/lib/firefox-15.0.1/

Pronto pessoal, lembrando que tudo isso pode ser feito utilizando a interface gráfica. Basta que você abra o navegador de arquivos pela linha de comando logado como root. Se tudo deu certo a tela de entrada do firefox deve ser esta:

Agora você já sabe como fazer para ter sempre o firefox mais atual em seu sistema operacional :). Até a próxima pessoal o/

Liberar som para usuário sem privilégios de root [Slackware 14]

Fala pessoal, hoje vou mostrar como liberar o som para usuário comum no Slackware 14. Eu resolvi mudar de SO e apostei minhas fichas no SO do Patrick (criador da distro), como sei que essa distro tem fama por ser leve e muito prática adotei ela como sistema padrão. Nessa transição de SO (Xubuntu p/ Slackware) tive muitas percas e ganhos. Abaixo fiz uma pequena lista delas:

Percas 

• Central de programas
• Facilidade para instalação de pacotes via terminal
• Não ter que compilar pacotes em todas as instalações

Ganhos

• Velocidade e desempenho
• Pacotes default completos
• Estabilidade de SO

Mas como nem tudo são rosas eu tive/tenho vira e mexe um problema aqui e outro acolá. 

Bom chega de conversa vamos fazer o seu som responder ai para que você possa escutar suas músicas e assistir aos seus vídeos. Abra o seu terminal e entre como root:

>> su -
>> [informe sua senha...]

Agora vamos adicionar o seu usuário ao grupo audio, assim ele terá acesso a todos os dispositivos de áudio:

>> usermod -G audio $seu_usuario

Pronto, faça um logoff ou reboot e tudo estará funfando jovem!
Até a próxima pessoal <o/

Estrutura de dados usando C - Pilha

Olá pessoal, como disse no post biblioteca de estrutura de dados estou criando uma biblioteca para facilitar a vida de programadores que desejam utilizar linguagem C para trabalhar com estrutura de dados, assim como de professores e alunos em sala de aula.

Nesse post irei mostrar como usar a stack.h. Essa biblioteca serve para manipular estrutura de dados do tipo pilha, vamos lá?!

Adicionando a biblioteca em seu arquivo C

Meu objetivo não é dizer o que é uma pilha e nem como ela funciona na memória de seu computador (já estou trabalhando em um post para isso). Hoje vamos aprender como facilitar a sua vida na criação e manipulação de uma pilha.

Primeiramente é necessário que você tenha o código fonte da biblioteca que pode ser obtido no no meu repósitorio de código, feito isso salve em um local de seu HD para que possamos utilizá-lo.

Agora crie um arquivo C para que possamos trabalhar =). Importante: crie o arquivo C no mesmo local onde você salvou o código da biblioteca.

Para adicionar a biblioteca a seu arquivo C use o include passando o caminho em que a mesma se encontra. No nosso caso o arquivo C e o código fonte da biblioteca estão no mesmo local. Veja:

#include "stdio.h" #include "stdlib.h" #include "stack.h"

Declarando uma variável do tipo Pilha e criando uma Pilha

Para declarar uma variável do tipo pilha devemos declarar um ponteiro do tipo Stack, e posteriormente para criar uma pilha na memória devemos chamar a função new( ) que retorna a pilha criada. Veja:

/* Declarando variável do tipo Stack */ Stack* pilha; /* Criando uma Pilha */ pilha = new();

Fácil não é? Pronto com isso temos uma pilha alocada em nossa memória, porém, ela ainda está vazia. Vamos ver como fazemos para inserir valores nessa pilha.

Inserindo e removendo valores da pilha

Até a versão atual da biblioteca (1.0 beta) as estruturas de dados trabalham unicamente com o tipo de dado float. Para inserir valores na pilha temos a função push(Stack*, float), e para remover valores temos a função pop(Stack*). Veja:

/* Adicionando valores a pilha */ push(pilha, 10); push(pilha, 20); push(pilha, 30); /* Removendo valores da pilha */ float item_removido = pop(pilha); printf("%f, foi o item removido \n\n", item_removido);
E ai pessoal está fácil? Nem parece linguagem C? kkkk. Ainda temos mais duas funções que devemos saber trabalhar, digamos que você tenha que listar os valores contidos na pilha ... e agora? Calma pequeno gafanhoto eu também fiz essa função ... ufaa ^_^. E a ultima função é talvez uma das mais importantes, ela será a responsável por liberar o espaço de memória ocupado por sua pilha. Vamos ver como utilizá-las!

Listando valores contidos na pilha, e destruindo a pilha

Algo muito importante quando estamos trabalhando com pilhas é listar os valores que estão contidos na pilha, para fazer isso podemos usar a função show(Satck*), antes de encerrar a nossa aplicação devemos limpar a memória para evitarmos que a mesma fica ocupada com os dados que foram utilizados durante a execução de nosso código. Para destruir a pilha temos a função clean(Stack*). Veja:

/* Exibindo os valores presentes na pilha */ printf("Itens da pilha:\n"); show(pilha); /* Limpando a memória */ clean(pilha);

Pronto pessoal, agora podemos fazer qualquer aplicação C utilizando Pilhas =). Em breve está chegando a versão 2.0, fique ligado no blog. Segue o código completo:

#include "stdio.h" #include "stdlib.h" #include "stack.h" /* Sabemos que para usar a ED de Pilha devemos usar o tipo Stack. * Uma vez que haja uma variável do tipo Stack podemos usar os recursos da stack.h =) */ int main() { /* Declarando variável do tipo Stack */ Stack* pilha; /* Criando uma Pilha */ pilha = new(); /* Adicionando valores a pilha */ push(pilha, 10); push(pilha, 20); push(pilha, 30); /* Removendo valores da pilha */ float item_removido = pop(pilha); printf("%f, foi o item removido \n\n", item_removido); /* Exibindo os valores presentes na pilha */ printf("Itens da pilha:\n"); show(pilha); /* Limpando a memória */ clean(pilha); return 0; }

Bom pessoal e aqui termina mais um post! Se você gostou recomende e assine o nosso feed de noticias para ficar a par das novidades =). Até a próxima!

Biblioteca de estrutura de dados - Linguagem C

Olá pessoal, no meu tempo livre venho trabalhando em algo que pode ajudar muitos estudantes de programação a entenderem alguns conceitos de estruturas de dados sem quebrarem tanto a cabeça (como eu quebrei kkk).

Eu resolvi criar uma biblioteca (escrita em linguagem ANSI C), para facilitar o uso DA linguagem no ensino aprendizagem da disciplina de estruturas de dados. Como estou programando a biblioteca em meu tempo livre (que não é muito) ela está em sua versão BETA e ainda incompleta.

Na versão atual (versão 1.0) temos incluídos os arquivos headers para trabalharmos com as estruturas de: Pilha, Lista Encadeada, Lista Circular, Lista Duplamente Encadeada, Árvores Binárias e Gráfos (BETA).

Nessa primeira versão cada estrutura pode trabalhar com tipos de dados de pontos flutuantes, porém, já estou trabalhando para que as mesmas trabalhem com qualquer tipo de dados (int, float e char).

O código fonte estará disponível no Github para quem quiser usá-lo =). Abaixo colocarei os links com o How-To para usar a biblioteca com cada uma das estruturas de dados.

Isso é tudo pessoal, e até a próxima. =)

OBS: OS LINKS ESTÃO CEGOS POR ENQUANTO.

Pilhas 
Listas encadeadas 
Listas circulares 
Listas duplamente encadeadas 
Árvores binárias 
Grafos (BETA) 
Link do projeto (Github) 

Python - Ler parâmetros informados por linha de comando

Olá pessoal, hoje vou ensinar como ler parâmetros passados por linha de comando utilizando a linguagem de programação Python.

Muitas vezes quando estamos fazendo algum script para executar uma determinada rotina temos que informar alguns parâmetros de configuração.

Para informar parametros no atraves da linha de comando basta escrevelos após o comando de interpretação assim:

#python aula.py guilherme carvalho python

Quando fazemos isso dizemos para rodar o arquivo aula.py e passamos 3 parametros para esse arquivo que são: guilherme, carvalho e python. Esses argumentos são recebidos como uma lista e podemos usalos dentro de nosso codigo.

Para usá-los devemos importar o modulo sys e informar qual a posição do parâmetro que desejamos recuperar.

import sys fname,lname,lang = sys.args[1], sys.args[2], sys.args[3] print 'My name is ' + fname + lname + ". I'm love " + lang

Link para o código no pastebin (http://pastebin.com/awXb0Wgz)

Você pode utilizar todos os métodos de estrutura lista uma vez que sys.argv é uma lista de parâmetros. Outra informação importante é que o primeiro parâmetro é sempre o nome completo do arquivo sendo executado. Bom pessoal espero que tenham curtido! Até o próximo post.

Funções em Python - Variáveis por referência ou valor?

Olá pessoal, hoje vamos aprender um pouco mais de Python e entender como essa linguagem trabalha com variáveis em chamadas de funções.

Quando estamos escrevendo um programa estruturado certamente iremos construir algumas funções para solucionar algum problema. Em muitas linguagens de programação temos a opção de passar valores por refência ou por valor.

Quando passamos valores por referência estamos na verdade passando o endereço de memória onde a variável original aponta, então quem recebe esse endereço tem o que chamamos de acesso direto e toda alteração feita localmente reflete a variável original uma vez que o endereço apontado pela variável local é o mesmo da original.

Quando passamos por valor a variável local recebe uma "cópia" do valor que a variável original armazena, e toda a mudança que a variável local recebe NÃO é refletida na variável original pois a variável local é apenas uma cópia de seu valor.

Em Python não fazemos essa divisão em valor ou referencia. Em Python tudo é objeto, e quando eu digo tudo é tudo mesmo: 1, 10, 45, 543,  *lista, *tuplas, *dicionários, etc.

Então como fazer essa divisão em Python? Ora, muito simples. Dizemos que temos objetos que são mutáveis e objetos que são imutáveis. Objetos mutáveis como o próprio nome diz são objetos que podem mudar no decorrer da interpretação do código e objetos imutáveis são aqueles que não mudam no decorrer do código. Exemplo de objetos imutáveis: 1, 20, 123. O objeto 1 quando iniciamos o programa é 1 e no final dele continua sendo 1.

Agora objetos que são mutáveis temos: *listas, *dicionário, etc. Uma lista pode começar fazia, e no final da interpretação terminar com 10 elementos.

* Estruturas de dados da linguagem Python.

Persistir mudanças em variáveis externas

E agora vem a pergunta: Como fazer uma variável externa recuperar o valor que foi dado à ela dentro de uma função?.

A primeira coisa a ver nesse caso é se a variável a ser passada é mutável ou imutável. Caso ela seja mutável não é preciso fazer nada, toda a mudança que ela receber na função vai ser refletida a variável original .

def adicionarItem(item, lista): lista.append(item) lista = list() adicionarItem(5, lista) adicionarItem(10, lista) print(lista)

Veja que criamos uma lista, onde valores são inseridos e ao final exibimos e comprovamos que os valores foram inseridos na lista. Agora se a variável for imutável devemos retornar o valor calculado dentro da função para a variável externa, fazendo com que ela receba esse valor. Exemplo:

def incrementar(a): a += 1 return a a = 5 a = incrementar(a) print(a)

Temos uma função cujo o seu propósito é incrementar um ao valor original da variável passada. Criamos uma variável com o valor 5 e logo em seguida estamos chamando a função e atribuindo o valor de retorno a nossa variável. Ao final estamos imprimindo o valor calculado pela nossa função. Nesse caso nada de errado aconteceu e o valor 6 foi mostrado como já era previsto. Mas e se não tivéssemos atribuído esse retorno a variável, será que o resultado seria o mesmo? Vamos testar:

def incrementar(a): a += 1 return a a = 5 incrementar(a) print(a)

Opa agora o resultado que foi mostrado na tela foi o número 5 :s!!! Isso não era para estar acontecendo! Na verdade era, em Python temos uma tabela de objetos onde cada objeto tem um ID. Então quando criamos uma variável ela é uma etiqueta para esse ID que por sua vez faz uma referencia a memória. Então quando a variável é criada ela está etiquetando o ID do Objeto 5, é criada uma outra variável só que localmente e essa aponta para ID 6. Como a variável local não é retornada ela morre ou melhor deixa de existir assim que a função acaba de ser interpretada. Bom pessoal por hoje é só espero que tenham gostado. Bons estudos!!!

Estruturas em C - struct (só o básico)

Olá pessoal, hoje vamos falar de struct (Estruturas). As estruturas existem em linguagem C para agrupar dados de diferentes tipos. Podemos definir estruturas como tipo de dados  que armazenam dados de tipos desiguais.

Nota: Podemos imaginar estruturas como sendo matrizes, porém, ela seria uma matriz turbinada que pode armazenar mais de um tipo de dado.

Criando uma estrutura

Para criar uma estrutura usamos a palavra-chave struct. Quando fazemos isso estamos definindo para o compilador um novo tipo de dado. Exemplo:

struct Relogio { int horas; int minutos; int segundos; };
A definição de uma estrutura não cria nenhuma variável, somente informa ao compilador as características de um novo tipo de dado. A palavra struct indica que um novo tipo de dados está sendo definido e Relogio será a sua entiqueta.

Outra coisa importante a dizer é que nesse exemplo definimos a struct como sendo global, ou seja, ela está acessível em qualquer parte do código. Podemos definir nossa struct dentro de uma função, com isso ela só poderá ser utilizada dentro dessa função pois seu escopo será local e não mais global. Exemplo:

#include <stdio.h>  int main(void) { struct Relogio { int horas; int minutos; int segundos; }; struct Relogio r; printf("\n O ponteiro hora está parado em qual número? \n >>> "); scanf("%d", &r.horas); printf("\n O ponteiro minuto está parado em qual número? \n >>> "); scanf("%d", &r.minutos); printf("\n O ponteiro de segundo está parado em qual número? \n >>> "); scanf("%d", &r.segundos); /* Não estou considerando se a hora é inválida! */ printf("\n Hora lida \n >>> %d:%d:%d", r.horas, r.minutos, r.segundos); return 0; }
No exemplo acima Relogio só pode ser acessado dentro da função principal (main). Por fim dessa introdução ao assunto gostaria de deixar uma definição sobre estruturas:
Uma estrutura é um tipo de dado cujo formato é definido pelo programador.

typedef + struct

Em C temos um recurso para dar novos nomes a tipos de dados que já existem (typedef). Com ele podemos então nomear as nossas estruturas. Podemos utilizar ele de 3 distintas formas, porém, para ser mas breve o possível vou adotar apenas uma forma e levar até o fim desse post.

typedef struct { int horas; int minutos; int segundos; } Relogio; Relogio rolex; /*Declara uma variavel do tipo Relogio*/
Para acessar os membros contidos em nossa struct utilizamos o operador "." (ponto final).
rolex.horas = 1;
Para acessar os membros de uma struct devemos utilizar o operador ponto. Esse operador conecta o nome de uma variável estrutura ao membro dela.

Estruturas aninhadas

Podemos ter uma estrutura que contém outra estrutura. Quando isso ocorre damos o nome de estruturas aninhadas. Para criar uma estrutura aninhada devemos criar todas as estruturas que agregam/compõem outras estruturas afim de suprir essa hierarquia montada:

typedef struct { int notas[3]; } Boletim; typedef struct { char nome[30]; Boletim boletim; } Aluno;
No exemplo acima temos duas estruturas: Boletim e Aluno. A estrutura Boletim possui apenas um membro já a estrutura Aluno possui dois membros, inclusive um de seus membros é do tipo Boletim. Então devido essa dependência devemos definir primeiramente Boletim e depois Aluno.
Para utilizar estruturas contidas em outras estruturas a ideia é a mesma. Devemos acessar os níveis hierárquicos utilizando o operador ponto e depois fazer a atribuição do valor, ou recuperar o mesmo. Exemplo:

typedef struct { int notas[3]; } Boletim; typedef struct { char nome[30]; Boletim boletim; } Aluno; Aluno Guilherme; int main(void) { Guilherme.boletim.notas[i]=10; return 0; }
Pessoal escrevi só o basicão, caso você goste e se interessou pelo assunto deixe seu comentário pedindo uma segunda parte mais avançada que eu farei ... lembre-se só farei se a demanda for alta por isso ajude ai compartilhando. Bons estudos!