![]() |
|
|
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 Hidrostática |
||
|
||
|
|
||
JavaScript ::: Dicas & Truques ::: Cookies |
Cookies em JavaScript - Como registrar a quantidade de vezes que o usuário visitou a sua página HTMLQuantidade de visualizações: 2 vezes |
|
Nesta dica mostrarei como podemos cookies em JavaScript para gravar e exibir para o usuário a quantidade de vezes que ele visitou o nosso site ou página. Veja que, no código, nós temos duas funções: gravarCookie(), que recebe o nome, o valor e a direção do cookie em dias, e obterCookie(), que recebe o nome do cookie e retorna o seu valor. O resultado ficará parecido ao que temos na figura abaixo: ![]() E agora o código JavaScript completo para o exemplo, incluindo a página HTML:
<html>
<head>
<title>Estudando JavaScript</title>
<script type="text/javascript">
// função que permite gravar um cookie
function gravarCookie(nome, valor, diasDuracao){
var dataExpiracao = new Date();
dataExpiracao.setTime(dataExpiracao.getTime()
+ (diasDuracao * 24 * 3600 * 1000));
document.cookie = nome + "=" + escape(valor) +
((diasDuracao == null) ? "" : "; expires=" + dataExpiracao);
}
// função quer permite obter um cookie
function obterCookie(nome){
if(document.cookie.length > 0){
var c_start = document.cookie.indexOf(nome + "=");
if(c_start != -1){
c_start = c_start + nome.length + 1;
c_end = document.cookie.indexOf(";", c_start);
if(c_end == -1){
c_end = document.cookie.length;
}
return unescape(document.cookie.substring(
c_start, c_end));
}
}
return null;
}
</script>
</head>
<body>
</HEAD>
<BODY>
<script type="text/javascript">
// verifica se o visitante já esteve aqui
var vezes = obterCookie('visitas');
if(vezes != null){
document.write("<h1>Esta é a sua " + vezes + "ª visita.</h1>");
gravarCookie("visitas", ++vezes, 30);
}
else{ // é a primeira vez. grave a visita
// grava um cookie que durará 30 dias
gravarCookie("visitas", 1, 30);
document.write("<h1>Esta é a sua primeira visita ao site</h1>");
}
</script>
</body>
</html>
|
AutoCAD Civil 3D .NET C# ::: Dicas & Truques ::: Alinhamento - Alignment |
Como retornar a quantidade de perfis de um alinhamento do Civil 3D usando a função GetProfileIds() da API C# do AutoCAD Civil 3DQuantidade de visualizações: 772 vezes |
|
Em algumas situações nós precisamos obter a quantidade de perfis (profiles) de um determinado alinhamento do AutoCAD Civil 3D. Para isso nós podemos usar a função GetProfileIds(), que retorna uma coleção ObjectIdCollection contendo os ids de todos os perfis pertencentes a um determinado alinhamento. Para este exemplo eu usei um alinhamento chamado "EIXO DA RODOVIA" e criei para ele um profile chamado "TN - SUPERFÍCIE NATURAL" para representar a superfície natural e outro chamado "GREIDE - PERFIL VERTICAL DA RODOVIA" para representar o alinhamento vertical. Note que, após obtermos a coleção ObjectIdCollection por meio da função GetProfileIds(), tudo que temos a fazer é acessar a sua propriedade Count. Veja o código AutoCAD Civil 3D .NET C# completo para o exemplo:
using System;
using Autodesk.AutoCAD.Runtime;
using Autodesk.Civil.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.Civil.DatabaseServices;
namespace Estudos {
public class Class1 : IExtensionApplication {
[CommandMethod("Alinhamento")]
public void Alinhamento() {
// vamos obter uma referência ao documento atual do Civil 3D
CivilDocument doc = CivilApplication.ActiveDocument;
// obtemos o editor
Editor editor = Application.DocumentManager.MdiActiveDocument.Editor;
// vamos pesquisar o alinhamento chamado "EIXO DA RODOVIA"
string nome = "EIXO DA RODOVIA";
// vamos iniciar um nova transação
using (Transaction ts = Application.DocumentManager.MdiActiveDocument.
Database.TransactionManager.StartTransaction()) {
try {
// efetuamos uma chamada ao método GetAlignmentByName() passando
// o documento atual do AutoCAD Civil 3D e o nome do alinhamento
// que queremos encontrar
Alignment alinhamento = GetAlignmentByName(doc, nome);
// ops, o alinhamento não foi encontrado
if (alinhamento == null) {
editor.WriteMessage("\nO alinhamento não foi encontrado.");
}
else {
// encontramos o alinhamento. Vamos mostrar a quantidade de perfis
// que ele possui
ObjectIdCollection ids_perfis = alinhamento.GetProfileIds();
// e mostramos o resultado
editor.WriteMessage("\nO alinhamento possui " + ids_perfis.Count +
" perfis.\n");
}
}
catch (System.Exception e) {
// vamos tratar o erro
editor.WriteMessage("Erro: {0}", e.Message);
}
}
}
// função C# que retorna um alinhamento por nome, ou null em
// caso de não encontrar o alinhamento desejado
public Alignment GetAlignmentByName(CivilDocument doc, string nome) {
// vamos declarar um objeto da classe Alignment
Alignment alinhamento = null;
// agora vamos obter os ids de todos os alinhamentos
ObjectIdCollection alinhamentos = doc.GetAlignmentIds();
// vamos percorrer todos os ids de alinhamentos retornados
foreach (ObjectId idAlinhamento in alinhamentos) {
alinhamento = idAlinhamento.GetObject(OpenMode.ForRead) as Alignment;
// encontramos o alinhamento
if (alinhamento.Name.Equals(nome)) {
return alinhamento;
}
}
// retorna null se o alinhamento não for encontrado
return null;
}
public void Initialize() {
// pode deixar em branco
}
public void Terminate() {
// pode deixar em branco
}
}
}
Ao executar este código AutoCAD Civil 3D .NET C# nós teremos o seguinte resultado: O alinhamento possui 2 perfis. |
C++ ::: STL (Standard Template Library) ::: Vector C++ |
Como obter um iterador para o primeiro ou último elemento de um vector C++ usando as funções begin() e end()Quantidade de visualizações: 8292 vezes |
|
Há situações em nossos códigos que precisamos obter uma referência ao primeiro ou último elemento de um vector e usar tal referência para acessar os demais elementos. Isso pode ser feito com um iterador. Assim, para obter um iterador para o primeiro elemento nós podemos usar a função begin(), que retorna duas formas de iteradores: iterator begin(); const_iterator begin() const; A primeira versão retorna um iterador que pode ser usado, não somente para acessar os elementos do vector, como também para alterar seus valores. Veja no trecho de código abaixo como obtemos um iterador para o primeiro elemento e o incrementamos de forma a atingir o último elemento:
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]){
// um vector vazio que conterá inteiros
vector<int> valores;
// vamos inserir três elementos
valores.push_back(54);
valores.push_back(13);
valores.push_back(87);
// vamos obter um iterador para o primeiro elemento
vector<int>::iterator it = valores.begin();
// vamos mostrar o valor atual do iterador
cout << "Valor atual do iterador: " << *it << endl;
// vamos adiantar o iterador duas vezes
it += 2;
// vamos mostrar o novo valor do iterador
cout << "Novo valor do iterador: " << *it << endl;
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
É importante lembrar que podemos alterar os valores dos elementos de um vector por meio do iterador. Veja:
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]){
// um vector vazio que conterá inteiros
vector<int> valores;
// vamos inserir três elementos
valores.push_back(54);
valores.push_back(13);
valores.push_back(87);
// vamos obter um iterador para o primeiro elemento
vector<int>::iterator it = valores.begin();
// vamos atribuir um novo valor ao primeiro elemento
*it = 128;
// vamos mostrar o novo valor do primeiro elemento
cout << "Novo valor do primeiro elemento: " << valores.front() << endl;
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Mas, e se quiséssemos evitar tal alteração? Bastaria usar um iterador constante: // vamos obter um iterador constante para o primeiro elemento vector<int>::const_iterator it = valores.begin(); Faça esta alteração no código anterior e verá que o programa não mais compila. A mensagem de erro de compilação indica: assignment of read-only location Vamos agora obter um iterador para o último elemento. Para isso podemos usar a função end(). Veja: iterator end(); const_iterator end() const; É importante notar que end() retorna um iterador para o elemento APÓS o último elemento do vector. Veja no trecho de código abaixo como obtemos um iterador para o último elemento:
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]){
// um vector vazio que conterá inteiros
vector<int> valores;
// vamos inserir três elementos
valores.push_back(54);
valores.push_back(13);
valores.push_back(87);
// vamos obter um iterador para o último elemento
vector<int>::iterator it = valores.end();
// como end() retorna um iterador para um elemento
// APÓS o último elemento do vector, temos que voltar
// um elemento para acessarmos de fato o último elemento
it--;
// vamos mostrar o valor atual do iterador
cout << "Valor do iterador: " << *it << endl;
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Um dos usos mais comuns dos iteradores begin() e end() é quando queremos percorrer todos os elementos de um vector. Veja:
#include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]){
// um vector vazio que conterá inteiros
vector<int> valores;
// vamos inserir três elementos
valores.push_back(54);
valores.push_back(13);
valores.push_back(87);
// vamos percorrer o vector e exibir os elementos
vector<int>::iterator it;
for(it = valores.begin(); it < valores.end(); it++){
cout << *it << endl;
}
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
|
Java ::: Dicas & Truques ::: Threads |
Threads em Java - Como usar a interface Runnable da Java API em suas aplicaçõesQuantidade de visualizações: 18430 vezes |
|
A interface pública Runnable deve ser implementada em nossas classes quando queremos que instâncias destas possam ser executadas por uma thread. Esta interface está no pacote java.lang e entre as classes que a implementam podemos citar AsyncBoxView.ChildState, FutureTask, RenderableImageProducer, Thread e TimerTask. Esta interface apresenta apenas um método, a saber: public void run(); Este interface foi idealizada para fornecer um protocolo comum para objetos que têm como objetivo executar determinadas porções de código enquanto ativos. Por exemplo, Runnable é implementada pela classe Thread. Estar ativa significa que uma thread foi iniciada e ainda não finalizou sua tarefa. Além disso, a interface Runnable fornece meios para que uma classe esteja ativa sem fazer sub-classe de Thread. Uma classe que implementa Runnable pode ser executada sem fazer sub-classe de Thread criando-se uma instância de Thread e fornecendo tal classe como alvo. Na maioria dos casos, a interface Runnable deve ser usada se estivermos planejando apenas sobrescrever o método run() e nenhum outro método da classe Thread. Isso é importante, uma vez que não devemos extender classes a menos que tenhamos a intenção de modificar ou extender o comportamento fundamental da classe. Veja uma aplicação na qual temos uma classe que implementa Runnable. Note como criamos instâncias de Thread e fornecemos nossa classe como alvo:
// criamos uma classe que servirá como thread
class MinhaThread implements Runnable{
private String nome;
public MinhaThread(String nome){
this.nome = nome;
}
public void run(){
for(int i = 1; i <= 20; i++){
System.out.println(nome + ": " + i);
}
}
}
public class Estudos{
public static void main(String[] args){
// vamos criar duas threads
MinhaThread mt1 = new MinhaThread("Thread 1");
Thread t1 = new Thread(mt1);
t1.start();
MinhaThread mt2 = new MinhaThread("Thread 2");
Thread t2 = new Thread(mt2);
t2.start();
System.exit(0);
}
}
|
Java ::: Fundamentos da Linguagem ::: Tipos de Dados |
Como usar null em JavaQuantidade de visualizações: 32435 vezes |
|
O tipo de dados null é um tipo (ou valor) especial que indica que uma referência não está apontando para nenhum objeto, ou seja, aponta para uma posição de memória nula. Este tipo pode ser atribuído (ou testado) apenas a referências. Seu uso não é permitido com primitivos. Veja um trecho de código no qual definimos que uma variável do tipo String aponta para um objeto nulo:
public class Estudos{
public static void main(String args[]){
String nome = null;
System.out.println(nome.length());
System.exit(0);
}
}
Este código compila normalmente. Porém, ao tentarmos executá-lo, temos uma exceção de tempo de execução NullPointerException: Exception in thread "main" java.lang.NullPointerException at Estudos.main(Estudos.java:5) Isso aconteceu porque estamos tentando executar um método de um objeto que não existe. Uma técnica muito valiosa é testar se uma referência não está apontando para um objeto nulo. Veja como isso é feito:
public class Estudos{
public static void main(String args[]){
String nome = null;
if(nome != null)
System.out.println(nome.length());
else
System.out.println("Objeto é nulo.");
System.exit(0);
}
}
Tenha em mente que, quando uma referência recebe o valor null, o objeto para o qual ela apontava fica imediatamente disponível para o coletor de lixo (Garbagge Colector), ou seja, a memória ocupada pelo objeto pode ser liberada a qualquer momento. Veja agora o que acontece quando tentamos atribuir o valor null a um primitivo:
public class Estudos{
public static void main(String args[]){
int valor = null;
System.exit(0);
}
}
Eis a mensagem de erro de compilação:
Estudos.java:3: incompatible types
found : <nulltype>
required: int
int valor = null;
^
1 error
|
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 |






