Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD e VBA
PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO

Você está aqui: Cards de Engenharia Civil - Construção Civil
Card 1 de 28
Fases de uma obra

A Planta de Localização (escala usual 1:200) identifica a posição da obra no terreno. Serve para implantar o projeto.

Filtrar Cards
Use esta opção para filtrar os cards pelos tópicos que mais lhe interessam.
Termos:
Aviso Importante: Nos esforçamos muito para que o conteúdo dos cards e dos testes e conhecimento seja o mais correto possível. No entanto, entendemos que erros podem ocorrer. Caso isso aconteça, pedimos desculpas e estamos à disposição para as devidas correções. Além disso, o conteúdo aqui apresentado é fruto de conhecimento nosso e de pesquisas na internet e livros. Caso você encontre algum conteúdo que não deveria estar aqui, por favor, nos comunique pelos e-mails exibidos nas opções de contato.
Link para compartilhar na Internet ou com seus amigos:

PHP ::: Dicas & Truques ::: Arrays e Matrix (Vetores e Matrizes)

Como criar vetores em PHP com a construção array() e usando inteiros como chaves

Quantidade de visualizações: 8676 vezes
A linguagem PHP nos permite criar vetores (arrays) e informar os valores inteiros que queremos como chaves, ou seja, não precisamos, obrigatoriamente, iniciar os índices dos elementos em 0.

Veja o código a seguir:

<html>
<head>
<title>Estudando PHP</title>
</head>
<body>
 
<?php
  $linguagens = array(10 => 'Java',
    11 => 'Python', 12 => 'C++');
             
  echo "A linguagem escolhida foi: " . 
    $linguagens[11];
?>
 
</body>
</html>

Ao executar este código nós teremos o seguinte resultado:

A linguagem escolhida foi: Python


C++ ::: Dicas & Truques ::: Ponteiros, Referências e Memória

Como alocar memória dinâmica usando o operador new do C++

Quantidade de visualizações: 12613 vezes
Em algumas situações precisamos alocar memória dinamicamente. Em C++ isso é feito com o auxílio do operador new. Este operador permite alocar uma determinada quantidade de bytes, alinhados de forma a representar o objeto para o qual queremos reservar memória.

Veja um exemplo de código no qual alocamos memória dinâmica para uma variável do tipo int:

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // aloca memória para um objeto do tipo int
  int *ponteiro = new int;

  // vamos definir o valor para o objeto recém-alocado
  *ponteiro = 20;

  // vamos exibir seu valor
  cout << *ponteiro << endl;

  // vamos liberar a memória
  delete ponteiro;

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Note que aqui a memória foi alocada e guardada em um ponteiro. Veja também o uso do operador delete para liberar a memória alocada. Isso evita os vazamentos de memória tão frequentes em aplicações que lidam com a memória dinâmica.

É claro que este não é o exemplo mais prático. Qual a vantagem de se alocar memória para um int? Declarar uma variável teria sido mais eficiente.

A alocação de memória dinâmica é mais útil quando estamos lidando com objetos mais complexos que os tipos básicos. Alguns exemplos envolvem a criação de objetos de classes, matrizes, estruturas de dados, etc.

Veja um exemplo no qual temos uma declaração de uma classe chamada Cliente e em seguida alocamos memória para uma instância desta classe:

#include <iostream>
#include <string>

using namespace std;

// declaração da classe Cliente
class Cliente{
  public:
    Cliente();
    string obterNome();
    void definirNome(string);
  private:
    string nome;
};

// implementação dos métodos da classe
Cliente::Cliente(){} // construtor vazio

// obtém o nome do cliente
string Cliente::obterNome(){
  return this->nome;
}

// define o nome do cliente
void Cliente::definirNome(string nome){
  this->nome = nome;
}

int main(int argc, char *argv[]){
  // aloca memória para um objeto da classe Cliente
  Cliente *c = new Cliente();

  // vamos definir o nome do cliente
  c->definirNome("Osmar J. Silva");

  // vamos exibir o nome do cliente
  cout << c->obterNome() << endl;

  // vamos liberar a memória usada
  delete c;

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Ao executar este código C++ nós teremos o seguinte resultado:

Nome do cliente: Osmar J. Silva


QGIS ::: PyQGIS API ::: Aplicações com código fonte completo

Como listar os 5 municípios goianos com maior área em uma camada do QGIS usando PyQGIS - Código Python completo

Quantidade de visualizações: 653 vezes
Este código completo mostra uma aplicação QGIS na qual usei PyQGIS para resolver um desafio muito interessante, e complexo. Acredito que servirá de base para muitos códigos interessantes envolvendo QGIS, Python e PyQGIS.

Comecei fazendo o download do shapefile do Estado de Goiás, contendo seus 246 municípios no site do IBGE. Em seguida carreguei o shapefile no QGIS usando um objeto QgsVectorLayer.

Note que criei uma classe Municipio para guardar cada um dos municípios encontrados no shapefile. E, para agrupar os objetos da classe Municipio eu criei uma lista chamada municipios.

Para acessar cada um dos municipios, ou seja, cada uma das 246 feições da camada, eu usei a função getFeatures() da classe QgsVectorLayer. Então, ao percorrer cada uma dessas feições, eu obtive seus atributos, por meio da função attributes(), e os usei para criar os objetos da classe Municipio.

Uma vez obtida a lista de municípios, o passo seguinte foi classificar a lista por ordem crescente de área (a área dos municípios). Um laço for me permitiu listar apenas os 5 municípios com maiores áreas e, além de registrar o somatório de seus áreas, obter os seus códigos para selecioná-los na camada, usando a função selectByExpression().

O desafio final foi mostrar as labels, ou seja, os rótulos de cada um dos municípios no mapa do QGIS, porém, eu queria mostrar os rótulos apenas dos 5 municípios com as maiores áreas. Para resolver o desafio, lancei mão da função setFilterExpression().

Veja o código completo para o exemplo:

# uma classe para guardar cada um dos municípios
# do Estado de Goiás
class Municipio:
  # método construtor
  def __init__(self, codigo, nome, estado, area):
    self.codigo = codigo
    self.nome = nome
    self.estado = estado
    self.area = area
  
# para guardar os municípios
municipios = []
  
# vamos criar um novo objeto QgsVectorLayer com o local
# do nosso shapefile
camada = QgsVectorLayer("C:\\GOIAS\\GO_Municipios_2022.shp",
  "Municípios do Estado de Goiás", "ogr")
 
# vamos testar se a camada é válida  
if not camada.isValid():
  print("Não foi possível carregar a camada %s" % camada.name())
else:
  # vamos percorrer todas as feições da camada
  # e obter os seus atributos
  feicoes = camada.getFeatures()  
  for f in feicoes:
    # vamos obter os atributos desta feição
    atributos = f.attributes()  
    # e criamos um novo objeto da classe Municipio
    municipio = Municipio(atributos[0], atributos[1],
      atributos[2], atributos[3])
    # adicionamos este município na lista
    municipios.append(municipio)
    
  # agora vamos ordenar a lista por área da maior para
  # a menor  
  municipios = sorted(municipios, 
    key=lambda municipio:municipio.area, reverse=True)
  
  # vamos adicionar a camada à relação de camadas  
  QgsProject.instance().addMapLayer(camada)
  
  # vamos calcular a área ocupada pelos 5 maiores municípios
  # do Estado de Goiás
  area_5_maiores = 0
  for i in range(5):
    area_5_maiores = area_5_maiores + municipios[i].area
  
  # agora vamos selecionar os 5 maiores municípios na
  # camada do QGIS  
  codigos = ""
  
  for i in range(5):
    codigos = codigos + municipios[i].codigo + ", "
  
  codigos = codigos[0:len(codigos) - 2]
  camada.selectByExpression('"CD_MUN" IN (' + codigos + ')')
  
  # e mostramos os resultados
  print("Os 5 maiores municípios do Estado de Goiás são:\n")
  for i in range(5):
    print("{0}) {1} - Área: {2} km2".format(i + 1, municipios[i].nome,
      municipios[i].area))
  print("\nÁrea ocupada pelos 5 maiores municípios: {0} km2".format(
    area_5_maiores))
    
  # finalmente vamos exibir os nomes dos municípios. Essa foi
  # a parte mais desafiadora do código, pois eu queria mostrar
  # somente os rótulos dos cinco maiores municípios
  settings = QgsPalLayerSettings()
  settings.isExpression = True
  settings.placement = QgsPalLayerSettings.Line
  settings.placement = QgsPalLayerSettings.Horizontal
  # mostra o nome do município
  settings.fieldName = "NM_MUN"

  format = QgsTextFormat()
  format.setColor(QColor('Black'))
  
  settings.setFormat(format)
  settings.enabled = True

  # cria e adiciona uma nova regra
  root = QgsRuleBasedLabeling.Rule(QgsPalLayerSettings())
  rule = QgsRuleBasedLabeling.Rule(settings)
  rule.setDescription("5 Maiores Municípios do Estado de Goiás")
  
  # define o campo que será usado no filtro. Note que somente
  # serão listados os rótulos dos municípios com área maior ou
  # igual ao quinto elemento da lista municípios
  campo_area = "AREA_KM2"
  rule.setFilterExpression(f"\"{campo_area}\" >= {municipios[4].area}")
  root.appendChild(rule)

  # define as configurações do rótulo
  camada.setLabelsEnabled(True)
  rules = QgsRuleBasedLabeling(root)
  camada.setLabeling(rules)
  # redesenha a camada no canvas do QGIS
  camada.triggerRepaint() 

Ao executar este código QGIS, Python e PyQGIS nós teremos o seguinte resultado:

Os 5 maiores municípios do Estado de Goiás são:

1) Niquelândia - Área: 9846.293 km2
2) Mineiros - Área: 9042.844 km2
3) Caiapônia - Área: 8627.961 km2
4) Rio Verde - Área: 8374.255 km2
5) Nova Crixás - Área: 7308.681 km2

Área ocupada pelos 5 maiores municípios: 43200.03399999999 km2

Para fins de compatibilidade este código foi escrito e testado no QGIS 3.34.5-Prizren.


C# ::: Coleções (Collections) ::: List<T>

Como retornar a quantidade de elementos que podem ser armazenados na List do C# sem redimensioná-la

Quantidade de visualizações: 7670 vezes
O objeto List do C# possui uma propriedade Capacity que nos retorna a quantidade de elementos que podem ser inseridos na lista antes que ela tenha que redimensionar o seu array interno. Quando o tamanho da lista excede essa capacidade, automaticamente o array interno é redimensionado de forma a acomodar esses novos itens.

Nessa dica eu mostro como podemos retornar o valor dessa propriedade. Veja:

using System;
using System.Collections.Generic;

namespace Estudos {
  class Principal {
    static void Main(string[] args) {
      List<int> valores = new List<int>();

      // insere valores na lista
      valores.Add(4);
      valores.Add(2);
      valores.Add(87);
      valores.Add(23);
      valores.Add(100);

      // obtém a capacidade da lista
      // NOTA: Capacity é o número de elementos que a lista
      // pode armazenar antes de ser preciso redimensioná-la.
      int capac = valores.Capacity;
      Console.WriteLine("A capacidade da lista é de "
         + capac + " elementos.");

      Console.WriteLine("\nPressione uma tecla para sair...");
      Console.ReadKey();
    }
  }
}

Ao executar este código C# nós teremos o seguinte resultado:

A capacidade da lista é de 8 elementos.


jQuery ::: Dicas & Truques ::: AJAX

Apostila jQuery - Quais as diferenças entre os métodos ajax(), get() e post() do jQuery?

Quantidade de visualizações: 11195 vezes
Existem algumas diferenças substanciais entre os métodos ajax(), get() e post(). Conhecê-las e saber quando usar cada um destes métodos poderá tornar seus códigos mais dinâmicos e eficientes.

O método ajax() é o mais completo para requisições HTTP e pode ser usado com mais de um dezena de parâmetros. Este método é considerado um método de nível baixo (low level) já que permite um maior controle sobre a requisição AJAX. Além disso, se precisamos de mais flexibilidade, este é o método a ser usado.

Os métodos get() e post() são métodos de nível mais alto (higher level) e aceitam pouco mais que três parâmetros cada um. Use estes métodos quando não precisar de muito controle sobre a requisição AJAX. Estes métodos, por exemplo, não fornecem formas de tratar possíveis erros na requisição HTTP.

Nesta seção você encontrará exemplos de cada um desses métodos.


Veja mais Dicas e truques de jQuery

Dicas e truques de outras linguagens

E-Books em PDF

E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby


E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser. Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book Apenas R$ 19,90


© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 51 usuários muito felizes estudando em nosso site.