 |
|
|
 Planilha de Dimensionamento de Tubulações
Hidráulicas Água Fria e Água Quente CompletaNossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes. |
||
Você está aqui: Cards de Engenharia Civil - Estruturas de Aço e Madeira |
||
|
||
 Link para compartilhar na Internet ou com seus amigos: |
||
C# ::: Dicas & Truques ::: Arquivos e Diretórios |
Como testar se um diretório existe em C# usando a propriedade Exists da classe DirectoryInfoQuantidade de visualizações: 3 vezes |
|
Em algumas situações nós precisamos verificar se um diretório existe em C#, talvez para ler ou gravar dados neste arquivo. Isso pode ser feito por meio da propriedade Exists da classe DirectoryInfo. Esta propriedade retorna um valor true se o diretório existir e false em caso contrário. Veja o código completo para o exemplo:
using System;
using System.IO;
namespace Estudos {
class Principal {
static void Main(string[] args) {
// vamos criar uma nova instância da classe DirectoryInfo
DirectoryInfo dir = new DirectoryInfo(@"C:\estudos_csharp\imagens");
// vamos testar se o diretório existe
if (dir.Exists) {
Console.Write("Diretório existe");
}
else {
Console.Write("Diretório não existe");
}
Console.WriteLine("\nPressione uma tecla para sair...");
Console.ReadKey();
}
}
}
Ao executar este código C# nós teremos o seguinte resultado: O diretório existe. |
Java ::: Dicas & Truques ::: Strings e Caracteres |
Como converter uma string para letras maiúsculas usando o método toUpperCase() da classe String da linguagem JavaQuantidade de visualizações: 3 vezes |
|
Nesta dica eu mostro como podemos usar o método toUpperCase() da classe String para transformar em maiúsculas todas as letras de uma palavra, frase ou texto. Veja o exemplo abaixo:
package arquivodecodigos;
public class Estudos{
public static void main(String[] args){
String frase = "Programar em Java é bom";
System.out.println(frase);
// vamos converter para letras maiúsculas
frase = frase.toUpperCase();
System.out.println(frase);
System.exit(0);
}
}
Ao executarmos este código nós teremos o seguinte resultado: Programar em Java é bom PROGRAMAR EM JAVA É BOM |
C++ ::: Win32 API (Windows API) ::: Aplicativos e Outros |
C++ Windows API GUI - Como criar sua primeira aplicação de interface gráfica usando C++ e WinAPIQuantidade de visualizações: 48403 vezes |
|
Esta dica mostra o código completo para uma aplicação de interface gráfica usando C++ e a Win32 (WinAPI - Windows Programming Interface). Trata-se de uma janela simples, mas com todas as características presentes em todas as janelas das aplicações Windows: uma barra de títulos, o ícone e os botões de maximizar, minimizar e fechar. Antes de executar o exemplo observe que este código contém o ponto inicial para a criação de qualquer aplicação gráfica em C++/WinAPI, a saber: A função de entrada WinMain, o laço de mensagens Message Loop, a função de callback Window Procedure e as técnicas de registrar e criar a janela. Neste momento não discutimos os detalhes do código. Em outras dicas você encontrará análises mais aprofundadas de cada parte. Este código foi escrito e testado no Dev-C++, mas, deve funcionar sem problemas em outros compiladores C++ para Windows. Assim, abra o Dev-C++, vá em File -> New -> Projec. Na aba Basic, selecione Console Application, dê um nome ao projeto e deixe a opção C++ Project marcada. Salve o projeto e inclua o código abaixo no arquivo .cpp principal:
#include <windows.h>
// define o nome da classe de janela
const char nomeJanela[] = "aCodigos";
// esta é a Window Procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM
wParam, LPARAM lParam){
switch(msg){
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hwnd, msg, wParam,
lParam);
}
return 0;
}
// função de entrada da aplicação
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE
hPrevInstance, LPSTR lpCmdLine, int nCmdShow){
WNDCLASSEX wc;
HWND hwnd;
MSG Msg;
// vamos registrar a Window Class
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = 0;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = nomeJanela;
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
if(!RegisterClassEx(&wc)){
MessageBox(NULL, "Erro ao registrar a janela!",
"Erro!", MB_ICONEXCLAMATION | MB_OK);
return 0;
}
// cria a janela
hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, nomeJanela,
"Minha primeira aplicação Win32",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
350, 200, NULL, NULL, hInstance, NULL);
if(hwnd == NULL){
MessageBox(NULL, "Erro ao criar a janela!",
"Erro!", MB_ICONEXCLAMATION | MB_OK);
return 0;
}
// mostra a janela
ShowWindow(hwnd, nCmdShow);
UpdateWindow(hwnd);
// Este é o laço de mensagens (Message Loop)
while(GetMessage(&Msg, NULL, 0, 0) > 0){
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
return Msg.wParam;
}
Pronto! Só compilar (geralmente F9 no Dev-C++), observar o resultado e estudar o código atentamente. |
JavaScript ::: Dicas & Truques ::: Operadores de Manipulação de Bits (Bitwise Operators) |
JavaScript Avançado - Como usar o operador de bits & (E/AND sobre bits) da linguagem JavaScriptQuantidade de visualizações: 1521 vezes |
|
O operador de bits & (E/AND sobre bits) da linguagem JavaScript é usado quando queremos comparar os bits individuais de dois valores integrais (inteiros) e produzir um terceiro resultado. Os bits no resultado serão configurados como 1 se os bits correspondentes nos dois outros valores foram 1. Em caso contrário os bits são configurados como 0. Para quem gosta de Lógica Matemática, ou a Tabela Verdade da Lógica de Boole, vai se lembrar do conectivo "^", que diz que a proposição resultante da conjunção só será verdadeira quando as proposições simples individuais forem verdadeiras. O operador de bits & do JavaScript é similar ao conectivo "^" da Lógica Proposicional. Vamos analisar os seguintes valores binários: a) 0101 (5 decimal) b) 0100 (4 decimal) Quando aplicamos o operador & nestes dois valores teremos o seguinte resultado: 0101 0100 ---- 0100 Veja que o resultado é 0100, uma vez que apenas o segundo bit de cada valor está configurado como 1. Vamos ver isso em JavaScript agora. Observe o seguinte trecho de código:
<html>
<head>
<title>Manipulação de Bits em JavaScript</title>
</head>
<body>
<script type="text/javascript">
var a = 5;
var b = 4;
var c = a & b;
// exibe o resultado (em binário e em decimal)
document.writeln("a = " + obterBits(a) + " (" + a + ")");
document.writeln("<br>b = " + obterBits(b) + " (" + b + ")");
document.writeln("<br>a & b = " + obterBits(c) + " (" + c + ")");
// função auxiliar que converte um decimal em sua representação em bits
function obterBits(valor){
var mascara = 1 << 31; // 10000000 00000000 00000000 00000000
var buffer = ""; // um buffer para guardar os bits dos bytes
for(var i = 1; i <= 32; i++){
// compara os bits individuais dos dois valores inteiros
if((valor & mascara) == 0){
buffer = buffer + "0";
}
else{
buffer = buffer + "1";
}
valor = valor << 1; // desloca uma posição para a esquerda
// Cada troca à esquerda corresponde à multiplicação do
// valor por 2
if(i % 8 == 0){ // completou um byte?
buffer = buffer + " ";
}
}
return buffer;
}
</script>
</body>
</html>
Ao executar este código teremos o seguinte resultado:
a = 00000000 00000000 00000000 00000101 (5)
b = 00000000 00000000 00000000 00000100 (4)
a & b = 00000000 00000000 00000000 00000100 (4)
|
Java ::: Estruturas de Dados ::: Árvore Binária e Árvore Binária de Busca |
Estruturas de dados em Java - Como fazer a travessia de uma árvore binária de busca em Java usando o percurso em-ordem (in-order, In-ordem ou ordem simétrica)Quantidade de visualizações: 5583 vezes |
Antes de discutirmos o percurso in-order, veja a árvore binária de busca na figura abaixo: Esta árvore possui 9 nós e obedece à regra de que os nós com valores menores que o nó pai ficam à sua esquerda, e aqueles com nós maiores que o nó pai, ficam à sua direita. O percurso em ordem é usado quando queremos exibir os valores dos nós da árvore binária de busca em ordem ascendente. Neste tipo de percurso nós visitamos primeiramente a sub-árvore da esquerda, então o nó atual e finalmente a sub-árvore à direita do nó atual. É importante notar que esta travessia é feita por meio de um método recursivo. Veja o código completo para o exemplo: Código para No.java:
package arvore_binaria;
public class No {
private int valor; // valor armazenado no nó
private No esquerdo; // filho esquerdo
private No direito; // filho direito
// construtor do nó
public No(int valor){
this.valor = valor;
this.esquerdo = null;
this.direito = null;
}
public int getValor() {
return valor;
}
public void setValor(int valor) {
this.valor = valor;
}
public No getEsquerdo() {
return esquerdo;
}
public void setEsquerdo(No esquerdo) {
this.esquerdo = esquerdo;
}
public No getDireito() {
return direito;
}
public void setDireito(No direito) {
this.direito = direito;
}
}
Código para ArvoreBinariaBusca.java:
package arvore_binaria;
public class ArvoreBinariaBusca {
private No raiz; // referência para a raiz da árvore
// método usado para inserir um novo nó na árvore
// retorna true se o nó for inserido com sucesso e false
// se o elemento
// não puder ser inserido (no caso de já existir um
// elemento igual)
public boolean inserir(int valor){
// a árvore ainda está vazia?
if(raiz == null){
// vamos criar o primeiro nó e definí-lo como a raiz da árvore
raiz = new No(valor); // cria um novo nó
}
else{
// localiza o nó pai do novo nó
No pai = null;
No noAtual = raiz; // começa a busca pela raiz
// enquanto o nó atual for diferente de null
while(noAtual != null){
// o valor sendo inserido é menor que o nó atual?
if(valor < noAtual.getValor()) {
pai = noAtual;
// vamos inserir do lado esquerdo
noAtual = noAtual.getEsquerdo();
}
// o valor sendo inserido é maior que o nó atual
else if(valor > noAtual.getValor()){
pai = noAtual;
// vamos inserir do lado direito
noAtual = noAtual.getDireito();
}
else{
return false; // um nó com este valor foi encontrado
}
}
// cria o novo nó e o adiciona como filho do nó pai
if(valor < pai.getValor()){
pai.setEsquerdo(new No(valor));
}
else{
pai.setDireito(new No(valor));
}
}
return true; // retorna true para indicar que o novo nó foi inserido
}
// método que permite disparar a travessia em-ordem
public void emOrdem(){
emOrdem(raiz);
}
// sobrecarga do método emOrdem com uma parâmetro (esta é a versão
// recursiva do método)
private void emOrdem(No raiz){
if(raiz == null){ // condição de parada
return;
}
// visita a sub-árvore da esquerda
emOrdem(raiz.getEsquerdo());
// visita o nó atual
System.out.print(raiz.getValor() + " ");
// visita a sub-árvore da direita
emOrdem(raiz.getDireito());
}
}
E agora o código para a classe principal:
package arvore_binaria;
import java.util.Scanner;
public class ArvoreBinariaTeste {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
// vamos criar um novo objeto da classe ArvoreBinariaBusca
ArvoreBinariaBusca arvore = new ArvoreBinariaBusca();
// vamos inserir 9 valores na árvore
for(int i = 0; i < 9; i++){
System.out.print("Informe um valor inteiro: ");
int valor = Integer.parseInt(entrada.nextLine());
// vamos inserir o nó e verificar o sucesso da operação
if(!arvore.inserir(valor)){
System.out.println("Não foi possível inserir." +
" Um elemento já contém este valor.");
}
}
// vamos exibir os nós da árvore usando o percurso in-order
System.out.println("\nPercurso in-order:");
arvore.emOrdem();
System.out.println("\n");
}
}
Ao executar este código teremos o seguinte resultado: Informe um valor inteiro: 8 Informe um valor inteiro: 3 Informe um valor inteiro: 10 Informe um valor inteiro: 1 Informe um valor inteiro: 6 Informe um valor inteiro: 14 Informe um valor inteiro: 4 Informe um valor inteiro: 7 Informe um valor inteiro: 13 Percurso in-order: 1 3 4 6 7 8 10 13 14 |
Desafios, Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
