![]() |
|
|
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 - Construção Civil |
||
|
||
|
|
||
C++ ::: STL (Standard Template Library) ::: Vector C++ |
Como retornar uma referência ao último elemento de um vector C++ usando a função back()Quantidade de visualizações: 7515 vezes |
O último elemento de um contêiner STL vector pode ser acessado por meio da função back(). Como esta função é sobrecarregada, temos duas opções:reference back(); const_reference back() const;
#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 o valor do último elemento do vector
// Note que back() pode ser usada dos dois lados
// de uma operação de atribuição
int valor = valores.back();
cout << "Último elemento: " << valor << endl;
// vamos alterar o valor do último elemento
valores.back() = 102;
// vamos testar o resultado
cout << "Último elemento: " << valores.back() << endl;
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Ao executar este código C++ nós teremos o seguinte resultado: Último elemento: 87 Último elemento: 102 Note que aqui nós usamos: int valor = valores.back(); para guardar o valor do último elemento na variável valor. Poderíamos também usar: int& valor = valores.back(); valor = 102; Agora valor é uma referência direta ao último elemento do vector. Desta forma, qualquer alteração no valor da variável valor afetará também o último elemento do vector. Observe agora o seguinte trecho de código: int valor = valores.back(); // o último elemento é 87 valores.back() = 20; cout << "Último elemento: " << valor << endl; Aqui nós acessamos o valor do último elemento, guardarmos-o na variável valor e atribuímos o valor 20 à valores.back(). Porém, ao imprimirmos a variável valor o seu conteúdo ainda é 87. De fato, o que gostaríamos é que uma alteração em valores.back() afetasse também a variável valor. Assim: int& valor = valores.back(); // o último elemento é 87 valores.back() = 20; cout << "Último elemento: " << valor << endl; Mas, como evitar alterações diretas na variável valor? Podemos declarar valor como uma referência constante, ou seja, usar a segunda versão da função back(), a saber const T&, que retorna uma referência constante. Veja: const int& valor = valores.back(); // o último elemento é 87 valores.back() = 20; valor = 300; // esta linha não compila cout << "Último elemento: " << valor << endl; Agora o efeito que queríamos é alcançado. Alterações em valores.back() afetam a variável valor, mas, não podemos alterar valor diretamente, já que esta variável é uma referência constante agora. |
Java ::: Dicas & Truques ::: Formulários e Janelas |
Java Swing para iniciantes - Como criar seu primeiro aplicativo de interface gráfica em Java SwingQuantidade de visualizações: 81225 vezes |
|
Um aplicativo de interface gráfica em Java é criado usando-se a classe JFrame, do Java Swing. Objetos desta classe servem como containeres para outros componentes e são as janelas principais dos aplicativos, com título e botões para redimensionar, minimizar, maximizar e fechar. Veja um exemplo de um simples aplicativo de interface gráfica em Java Swing:
package arquivodecodigos;
import javax.swing.*;
public class Estudos extends JFrame{
public Estudos() {
super("Minha primeira aplicação GUI");
setSize(350, 250);
setVisible(true);
}
public static void main(String args[]){
Estudos app = new Estudos();
app.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Este código gera uma janela principal de um aplicativo com 350 pixels de largura e 250 pixels de altura. O título da janela é: "Minha primeira aplicação GUI". Veja o resultado na figura abaixo: ![]() |
Delphi ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI |
Como abrir e fechar um dispositivo de saída MIDI usando DelphiQuantidade de visualizações: 11818 vezes |
Quando queremos executar sons MIDI no Windows, a primeira tarefa a ser realizada é abrir o dispositivo de saída MIDI. Isso é feito com uma chamada à função midiOutOpen() da API do Windows. Veja sua assinatura (em C):MMRESULT midiOutOpen( LPHMIDIOUT lphmo, UINT_PTR uDeviceID, DWORD_PTR dwCallback, DWORD_PTR dwCallbackInstance, DWORD dwFlags ); Esta função está traduzida na unit MMSystem.pas do Delphi da seguinte forma: function midiOutOpen(lphMidiOut: PHMIDIOUT; uDeviceID: UINT; dwCallback, dwInstance, dwFlags: DWORD): MMRESULT; stdcall; Antes de continuarmos, vamos entender os parâmetros desta função: lphmo - Este é um ponteiro para um HMIDIOUT (que é simplemente um Integer). Este ponteiro é preenchido com um handle identificando o dispositivo de saída MIDI aberto. Este handle é usado para identificar o dispositivo nas demais chamadas de saída MIDI. uDeviceID - Identificador do dispositivo de saída MIDI a ser aberto. O valor 0 aqui é seguro, visto que este identifica o primeiro dispositivo na lista de dispositivos de saída. Veja minha dica "Como obter uma lista dos dispositivos de saída MIDI no sistema" para mais informações. dwCallback - Um ponteiro para uma função de callback, um handle de evento, um identificador de thread ou um handle para uma janela ou thread chamada durante o playback do MIDI para processar mensagens relacionadas ao processo de playback. Se não houver nada a ser processado, podemos definir o valor 0 para este parâmetro. Dê uma olhada na minha dica relacionada à função MidiOutProc(). dwCallbackInstance - Dados de instância do usuário passados para a função de callback. Este parâmetro não é usado em callbacks de janela e thread. É seguro manter seu valor como 0. dwFlags - Flag de callback para abrir o dispositivo. Por enquanto vamos manter seu valor como CALLBACK_NULL. Veja minhas outras dicas sobre o assunto para aprofundar mais neste parâmetro. Agora que aprendemos mais sobre os parâmetros da função midiOutOpen(), vamos ver como usá-la para abrir um dispositivo de saída MIDI e tocar a nota DÓ média (aquela no meio da escala de notas possíveis). Veja o código completo para a unit:
unit Unit2;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, MMSystem;
type
TForm2 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
dispositivo: HMIDIOUT; // dispositivo de saída MIDI
public
{ Public declarations }
end;
var
Form2: TForm2;
implementation
{$R *.dfm}
procedure TForm2.Button1Click(Sender: TObject);
var
erro: Word;
begin
erro := midiOutOpen(@dispositivo, 0, 0, 0, CALLBACK_NULL);
// houve erro na abertura do dispositivo de saída MIDI?
if (erro <> 0) then
begin
ShowMessage('Não foi possível abrir o dispositivo MIDI. Erro: ' + IntToStr(erro));
end
else
begin
ShowMessage('Dispositivo MIDI aberto com sucesso.');
// vamos tocar uma nota para nos certificarmos de que o dispositivo
// realmente foi aberto e está funcionando
// vamos tocar a nota DÓ média e com velocidade máxima
midiOutShortMsg(dispositivo, rgb($90, 60, 127));
// vamos deixar a nota soar um pouco
sleep(1000);
// vamos silenciar a nota
midiOutShortMsg(dispositivo, rgb($80, 60, 0));
// finalmente vamos fechar o dispositivo MIDI
midiOutClose(dispositivo);
end;
end;
end.
O primeiro passo foi declarar uma variável do tipo HMIDIOUT: dispositivo: HMIDIOUT; Este é o dispositivo de saída que será usado nas demais chamadas MIDI, incluindo a função midiOutClose(), usada para fechar o dispositivo: midiOutClose(dispositivo); Na API do Windows está função está declarada da seguinte forma: MMRESULT midiOutClose( HMIDIOUT hmo ); Na unit MMSystem.pas do Delphi está função está traduzida da seguinte forma: function midiOutClose(hMidiOut: HMIDIOUT): MMRESULT; stdcall; Veja que só precisamos fornecer o nome da variável representando o dispositivo de saída MIDI aberto no momento para que a função se encarregue de fechá-lo. |
Java ::: Dicas & Truques ::: Arquivos e Diretórios |
Como escrever em um arquivo usando Java - Como escrever em um arquivo usando as classes BufferedWriter e FileWriter do JavaQuantidade de visualizações: 1 vezes |
|
Nesta dica mostrarei como podemos usar a linguagem Java para escrever em um arquivo texto. Para isso nós vamos usar as classes BufferedWriter e FileWriter. Veja o trecho de código completo para o exemplo:
package arquivodecodigos;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class Estudos{
public static void main(String args[]){
try {
BufferedWriter out = new BufferedWriter(new
FileWriter("C:\\estudos_java\\conteudo.txt"));
out.write("Esta é a primeira linha de texto\r\n");
out.write("Esta é a segunda linha de texto");
out.close();
}
catch(IOException e){
System.out.println("Houve um erro: " + e.getMessage());
}
System.out.println("Acabei de escrever no arquivo");
}
}
Ao executar este código Java nós teremos o seguinte resultado: Acabei de escrever no arquivo. Tenha cuidado. Se o arquivo já existir, o método write() da classe BufferedWriter vai sobrescrever o seu conteúdo. Por isso, é sempre uma boa idéia fazer uma verificação antes. |
Java ::: Java + MySQL ::: Metadados da Base de Dados (Database Metadata) |
Java MySQL - Como obter os tipos de dados suportados pelo MySQL e seus correspondentes JDBC usando o método getTypeInfo() da interface DatabaseMetaDataQuantidade de visualizações: 6526 vezes |
|
Em algumas situações precisamos obter os tipos de dados suportados pelo MySQL e mapeá-los para seus correspondentes JDBC. Esta não é uma tarefa fácil, mas que, com uma pequena ajuda dos recursos de reflexão do Java, pode ser realizada depois de algumas xícaras de café. O primeiro passo é obter os tipos de dados suportados pelo MySQL com uma chamada ao método getTypeInfo() da interface DatabaseMetaData. Os campos do ResultSet que nos interessam são TYPE_NAME e DATA_TYPE. TYPE_NAME traz o nome do tipo de dados no MySQL enquanto DATA_TYPE traz o tipo JDBC correspondente como um inteiro. Assim, o que temos que fazer é usar reflexão para obter todos os campos da classe java.sql.Types e efetuar um mapeamento entre os tipos. Veja o código completo para o exemplo:
package estudosbancodados;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
public class EstudosBancoDados{
static Map mapa; // usado para mapear os tipos JDBC
public static void main(String[] args) {
// strings de conexão
String databaseURL = "jdbc:mysql://localhost/estudos";
String usuario = "root";
String senha = "osmar1234";
String driverName = "com.mysql.jdbc.Driver";
try {
Class.forName(driverName).newInstance();
Connection conn = DriverManager.getConnection(databaseURL, usuario, senha);
// vamos obter um objeto da classe com.mysql.jdbc.DatabaseMetaData
DatabaseMetaData dbmd = conn.getMetaData();
// vamos obter os tipos de dados suportados por esta versão do MySQL
// e seus correspondentes JDBC
ResultSet tiposDados = dbmd.getTypeInfo();
while(tiposDados.next()){
System.out.println("MySQL: " + tiposDados.getString("TYPE_NAME") + " - JDBC: "
+ getJdbcTypeName(Integer.parseInt(tiposDados.getString("DATA_TYPE"))));
}
// vamos fechar o ResultSet
tiposDados.close();
}
catch (SQLException ex) {
System.out.println("SQLException: " + ex.getMessage());
System.out.println("SQLState: " + ex.getSQLState());
System.out.println("VendorError: " + ex.getErrorCode());
}
catch (Exception e) {
System.out.println("Problemas ao tentar conectar com o banco de dados: " + e);
}
}
// Este método retorna o nome de um tipo JDBC
// O retorno é null se o tipo JDBC não puder ser reconhecido
public static String getJdbcTypeName(int jdbcType){
// vamos usar reflection para mapear valores inteiros a seus nomes
if(mapa == null) {
mapa = new HashMap();
// vamos obter todos os campos da classe java.sql.Types
Field[] campos = java.sql.Types.class.getFields();
// vamos percorrer os campos
for(int i = 0; i < campos.length; i++){
try{
// vamos obter o nome do campo
String nome = campos[i].getName();
// vamos obter o valor do campo
Integer valor = (Integer)campos[i].get(null);
// vamos adicionar ao mapa
mapa.put(valor, nome);
}
catch(IllegalAccessException e){
System.out.println("Ops: " + e.getMessage());
}
}
}
// vamos retornar o nome do tipo JDBC
return (String)mapa.get(new Integer(jdbcType));
}
}
O resultado da execução deste código foi: MySQL: BIT - JDBC: BIT MySQL: BOOL - JDBC: BIT MySQL: TINYINT - JDBC: TINYINT MySQL: TINYINT UNSIGNED - JDBC: TINYINT MySQL: BIGINT - JDBC: BIGINT MySQL: BIGINT UNSIGNED - JDBC: BIGINT MySQL: LONG VARBINARY - JDBC: LONGVARBINARY MySQL: MEDIUMBLOB - JDBC: LONGVARBINARY MySQL: LONGBLOB - JDBC: LONGVARBINARY MySQL: BLOB - JDBC: LONGVARBINARY MySQL: TINYBLOB - JDBC: LONGVARBINARY MySQL: VARBINARY - JDBC: VARBINARY MySQL: BINARY - JDBC: BINARY MySQL: LONG VARCHAR - JDBC: LONGVARCHAR MySQL: MEDIUMTEXT - JDBC: LONGVARCHAR MySQL: LONGTEXT - JDBC: LONGVARCHAR MySQL: TEXT - JDBC: LONGVARCHAR MySQL: TINYTEXT - JDBC: LONGVARCHAR MySQL: CHAR - JDBC: CHAR MySQL: NUMERIC - JDBC: NUMERIC MySQL: DECIMAL - JDBC: DECIMAL MySQL: INTEGER - JDBC: INTEGER MySQL: INTEGER UNSIGNED - JDBC: INTEGER MySQL: INT - JDBC: INTEGER MySQL: INT UNSIGNED - JDBC: INTEGER MySQL: MEDIUMINT - JDBC: INTEGER MySQL: MEDIUMINT UNSIGNED - JDBC: INTEGER MySQL: SMALLINT - JDBC: SMALLINT MySQL: SMALLINT UNSIGNED - JDBC: SMALLINT MySQL: FLOAT - JDBC: REAL MySQL: DOUBLE - JDBC: DOUBLE MySQL: DOUBLE PRECISION - JDBC: DOUBLE MySQL: REAL - JDBC: DOUBLE MySQL: VARCHAR - JDBC: VARCHAR MySQL: ENUM - JDBC: VARCHAR MySQL: SET - JDBC: VARCHAR MySQL: DATE - JDBC: DATE MySQL: TIME - JDBC: TIME MySQL: DATETIME - JDBC: TIMESTAMP MySQL: TIMESTAMP - JDBC: TIMESTAMP |
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 |




