Android SDK

Para que o Android SDK execute normalmente precisamos ter instalado a JDK (não apenas a JRE) a partir da versão 5, então verifiquem isso antes de partimos para o SDK propriamente dito. A JDK pode ser baixada aqui:

http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u2-download-1377129.html

Escolha a versão correta para seu sistema operacional e mande brasa. Depois disso podemos baixar a SDK do android e executá-la em nossa máquina. A última versão pode ser baixada aqui:

http://developer.android.com/sdk/index.html

Para Windows existe uma versão instalável (.exe), mas vamos nos concentrar nas outras que seguirão exatamente os mesmos passos em todas as plataformas. Após baixar basta descompactar em alguma pasta.

Ao descompactar o SDK temos a estrutura de arquivos da figura, sendo que cada um tem a seguinte função:

• add-ons: pacotes externos do Android (vazia no momento pois ainda não instalamos nada)
• plataforms: plataformas específicas para cada versão do Android (vazia no momento pois ainda não instalamos nenhuma plataforma)
• tools: ferramentas para desenvolvimento e emulador do Android (para facilitar podemos adicioná-la ao PATH do sistema)
• AVD Manager.exe: gerenciador de AVD (Android Virtual Device), máquinas virtuais (emuladores) que usaremos para testar as aplicações

• SDK Manager.exe: usado para configuração do SDK, instalação de plataformas e bibliotecas e ferramentas (já que vem vazio devemos instalar alguma plataforma para começar)

Instalação de uma Plataforma Android

De forma simples, através do SDK Manager, podemos instalar a plataforma Android que quisermos selecionando a versão correspondente e clicando em Install Packages. no caso da figura acima, estamos instalando a versão 4.0.3 juntamente com documentação, exemplos e a google API correspondente. Na figura abaixo, vejam que selecionei também a versão 2.2 para instalar, por questões de compatibilidade e por essa versão ainda ser muito difundida.

Após isso, basta aceitar os termos e o SDK Manager irá baixar e instalar as plataformas escolhidas. Por se tratar de um número grande de arquivos esse processo deve ser um pouco demorado.

Instalação do Eclipse com ADT

A ferramenta padrão para desenvolvimento android escolhida pela google é o bom e velho eclipse unido a um plugin especialmente desenvolvido para isso, o ADT (Android Development Tools). Para instalá-lo, admitindo que já temos um eclipse funcionando normalmente em nossa máquina, basta acessarmos o menu Help > Install new software…

Na janela que se abre devemos clicar no botão Add.. e inserir a URL de onde será baixado o ADT: https://dl-ssl.google.com/android/eclipse/

Logo após serão carregados os programas disponíveis nesta URL, então selecionamos todos e mandamos instalar, clicando em next.

Novamente clicamos em next

Aceitamos os termos da licença e, por fim, clicamos em finish. Assim, o ADT será instalado em nosso eclipse.

Depois de tudo baixado o eclipse pedirá paa ser reiniciado e, quando voltar, o plugin deverá estar instalado corretamente. Para que possamos começar a usá-lo, antes precisamos configurar o ADT para que ele “enxergue” o SDK. Para isso vamos ao menu Windows > Preferences e selecionamos Android no lado esquerdo da janela que abriu. Para configurarmos basta selecionarmos, através do botão Browse, a pasta em que descompactamos o SDK.

Dessa forma o ADT estará configurado e estamos bem perto de poder começar a programar para android, bastando, para isso, criarmos nosso primeiro dispositivo virtual (AVD) para que possamos rodar nossas aplicações no emulador.

Criação de uma AVD

Preferi deixar a criação da AVD para o final para podermos fazer isso diretamente de dentro do eclipse, via plugin ADT (mas também poderiamos fazer pelo aplicativo AVD Manager, citado mais acima). Usando o botão do eclipse destacado na figura chamamos o AVD Manager.

O AVD Manager será aberto:

Para criarmos um AVD devemos clicar no botão New

Nessa janela devemos dar um nome para nosso AVD e selecionarmos a plataforma alvo em Target. Pronto, as outras opções serão preenchidas por padrão, mas podemos modificá-la a nosso gosto, por exemplo reservando um espaço para simular um cartão SD no emulador ou mudar a resolução da tela do mesmo. Vejam como ficou configurado meu AVD:

Voltando a tela do AVD Manager podemos testar nosso AVD selecionando-o e clicando em Start, assim o emulador será aberto:

Assim finalizamos a configuração de nosso ambiente e já podemos partir para a criação de nosso primeiro projeto: um HelloWorld.

#include <iostream>

#define TAMANHO 5

using namespace std;

// Tipos para o grafo
typedef int no;

typedef struct t_grafo {
	bool vertice[TAMANHO];
	no arestas[TAMANHO][TAMANHO];
} grafo;

// Tipos para a fila
typedef struct t_no_fila {
	no no_grafo;
	struct t_no_fila* proximo;
} no_fila;

typedef struct t_fila {
	no_fila* inicio;
	no_fila* final;
} fila;

// Funções de manipulação da fila
fila inicializar() {
	fila f;
	f.inicio = NULL;
	f.final = NULL;
	return f;
}

void enfileire(no v, fila& f) {
	no_fila* n = new no_fila;
	n->no_grafo = v;
	n->proximo = NULL;
	if (f.final != NULL) {
		f.final->proximo = n;
	}
	f.final = n;
	if (f.inicio == NULL) {
		f.inicio = n;
	}
	n = NULL;
}

void desenfileire(fila& f) {
	if (f.inicio == NULL) {
		cout << "Erro! Fila vazia." << endl;
	} else {
		no_fila* t = f.inicio;
		f.inicio = f.inicio->proximo;
		t->proximo = NULL;
		delete t;
		if (f.inicio == NULL) {
			f.final = NULL;
		}
	}

}

bool fila_vazia(fila f) {
	return f.inicio == NULL;
}

no frente(fila f) {
	return f.inicio->no_grafo;
}

// Funções de manipulação do grafo
void visite(no v) {
	cout << " -> " << v;
}

void marque(no v, grafo& g) {
	g.vertice[v] = true;
}

bool marcado(no v, grafo g) {
	return g.vertice[v];
}

// Percorrimento em amplitude
void amplitude(no v, grafo g) {
	no t, w;
	fila f = inicializar();
	visite(v);
	marque(v, g);
	enfileire(v, f);
	while (not fila_vazia(f)) {
		t = frente(f);
		desenfileire(f);
		for (w = 0; w < TAMANHO; w++) {
			if (g.arestas[w][t] == 1 && not marcado(w, g)) {
				visite(w);
				marque(w, g);
				enfileire(w, f);
			}
		}
	}
}

// Percorrimento em profundidade
void profundidade(no v, grafo& g) {
	no w;
	visite(v);
	marque(v, g);
	for (w = 0; w < TAMANHO; w++) {
		if (g.arestas[w][v] == 1 && not marcado(w, g)) {
			profundidade(w, g);
		}
	}
}

int main() {
	grafo gr = { {false, false, false, false, false },
		{
			{0, 1, 1, 0, 0},
			{1, 0, 0, 1, 1},
			{1, 0, 0, 0, 0},
			{0, 1, 0, 0, 1},
			{0, 1, 0, 1, 0}
		}
	};

	cout << "Percorrimento em amplitude";
	amplitude(0, gr);
	cout << endl;
	cout << "Percorrimento em profundidade";
	profundidade(0, gr);
	cout << endl;
	return 0;
}

Vejam que os algoritmos são exatamente iguais ao pseudocódigo do livro. Usamos apenas os assuntos anteriores, como fila, para criar as estruturas auxiliares.

Na função main, só o que precisamos fazer é construir o grafo segundo nossa estrutura (nesse caso de matriz de incidência) e, em seguida, chamar as funções de percorrimento. A saída do algoritmo é a sequência de nós que o procedimentos percorrem no processo.

A seguir temos a mesma implementação usando listas de adjacência. Como podem notar, a diferença maior é na estrutura usada para representar o grafo e no método main a construção do grafo que, por sinal, é o mesmo usado no código acima e que representa o grafo da página 160.

#include <iostream>

#define TAMANHO 5

using namespace std;

// Tipos para o grafo
typedef int no;

typedef struct t_no_lista {
	int no;
	struct t_no_lista* proximo;
} no_lista;

typedef struct t_grafo {
	bool vertice[TAMANHO];
	no_lista* arestas[TAMANHO];
} grafo;

// Tipos para a fila
typedef struct t_no_fila {
	no no_grafo;
	struct t_no_fila* proximo;
} no_fila;

typedef struct t_fila {
	no_fila* inicio;
	no_fila* final;
} fila;

// Inserção de nós adjacentes na estrutura do grafo
// Passa-se a aresta (nós origem e destino)
void insere_aresta_grafo(no origem, no destino, grafo& g) {
	no_lista* n1 = new no_lista;
	n1->no = destino;
	n1->proximo = g.arestas[origem];
	g.arestas[origem] = n1;
	n1 = NULL;

	no_lista* n2 = new no_lista;
	n2->no = origem;
	n2->proximo = g.arestas[destino];
	g.arestas[destino] = n2;
	n2 = NULL;
}

// Funções de manipulação da fila
fila inicializar() {
	fila f;
	f.inicio = NULL;
	f.final = NULL;
	return f;
}

void enfileire(no v, fila& f) {
	no_fila* n = new no_fila;
	n->no_grafo = v;
	n->proximo = NULL;
	if (f.final != NULL) {
		f.final->proximo = n;
	}
	f.final = n;
	if (f.inicio == NULL) {
		f.inicio = n;
	}
	n = NULL;
}

void desenfileire(fila& f) {
	if (f.inicio == NULL) {
		cout << "Erro! Fila vazia." << endl;
	} else {
		no_fila* t = f.inicio;
		f.inicio = f.inicio->proximo;
		t->proximo = NULL;
		delete t;
		if (f.inicio == NULL) {
			f.final = NULL;
		}
	}

}

bool fila_vazia(fila f) {
	return f.inicio == NULL;
}

no frente(fila f) {
	return f.inicio->no_grafo;
}

// Funções de manipulação do grafo
void visite(no v) {
	cout << " -> " << v;
}

void marque(no v, grafo& g) {
	g.vertice[v] = true;
}

bool marcado(no v, grafo g) {
	return g.vertice[v];
}

// Percorrimento em amplitude
void amplitude(no v, grafo g) {
	no t;
	fila f = inicializar();
	visite(v);
	marque(v, g);
	enfileire(v, f);
	while (not fila_vazia(f)) {
		t = frente(f);
		desenfileire(f);
		no_lista* w = g.arestas[t];
		while (w != NULL) {
			if (not marcado(w->no, g)) {
				visite(w->no);
				marque(w->no, g);
				enfileire(w->no, f);
			}
			w = w->proximo;
		}
	}
}

// Percorrimento em profundidade
void profundidade(no v, grafo& g) {
	visite(v);
	marque(v, g);
	no_lista* w = g.arestas[v];
	while (w != NULL) {
		if (not marcado(w->no, g)) {
			profundidade(w->no, g);
		}
		w = w->proximo;
	}
}

int main() {
	grafo gr;
	for (int i = 0; i < TAMANHO; i++) {
		gr.vertice[i] = false;
		gr.arestas[i] = NULL;
	}
	insere_aresta_grafo(3, 4, gr);
	insere_aresta_grafo(1, 4, gr);
	insere_aresta_grafo(1, 3, gr);
	insere_aresta_grafo(0, 2, gr);
	insere_aresta_grafo(0, 1, gr);

	cout << "Percorrimento em amplitude";
	amplitude(0, gr);
	cout << endl;
	cout << "Percorrimento em profundidade";
	profundidade(0, gr);
	cout << endl;
	return 0;
}

Então, é isso, espero que entendam os algoritmos. Não há dificuldade, bastava apenas traduzir os pseudocódigos para a linguagem de programação preferida de cada um...

[]'s
Ricardo Viana

http://ultradownloads.uol.com.br/download/C-Como-Uma-Linguagem-De-Programacao-Orientada-A-Objetos/

http://www.inf.pucrs.br/~pinho/PRGSWB/OO/oocpp.html

http://www.dca.fee.unicamp.br/cursos/POOCPP/

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

http://www.sbvb.com.br/cpp/livro_cpp.pdf

http://orion.lcg.ufrj.br/C++/curso/

C++ Tutorial (Em inglês – resumido e muito bom)

http://www.tiexpert.net/programacao/c/index.php

Aproveitem

[]‘s
Ricardo Viana

ALTER  TABLE sua_tabela ENGINE = InnoDB

Muda-se a engine da tabela para InnoDB, por exemplo.

Para fazer isso em outros bancos o comando é bastante parecido.

[]‘s
zezim

Basta abrir o arquivo msys.bat, presente na pasta de instalação do msys e procurar pelas linhas 55 e 56:

if “x%MINGW32BGCOLOR%” == “x” set MINGW32BGCOLOR=LightYellow
if “x%MINGW32FGCOLOR%” == “x” set MINGW32FGCOLOR=Navy

Aí ficou fácil né. Basta alterar o LightYellow para mudar a cor de fundo e o Navy para mudar a cor da fonte. No meu aqui coloquei Black e White e ficou bem melhor do que o original. Vejam o resultado:

Espero ter ajudado.

[]‘s
zezim

[]‘s
zezim

vi aqui: http://www.tiagodoria.ig.com.br/2008/09/01/abrace-um-programador/

[]‘s
zezim