Ofereço ajuda em Java, C/C++, Python, C#, LISP, AutoLisp, AutoCAD
+55 (062) 98553-6711
Ofereço ajuda em PHP, Python, C#, JavaScript, Laravel, Google Ads e SEO
+55 (062) 98243-1195

Você está aqui: Delphi ::: dbExpress ::: TSQLConnection

Como criar um objeto da classe TSQLConnection em tempo de execução e efetuar uma conexão com um banco de dados

Quantidade de visualizações: 13236 vezes
A forma mais comum de se criar uma conexão com um banco de dados usando a arquitetura dbExpress é configurando o componente TSQLConnection em tempo de design, ou seja, fornecendo os valores para as suas propriedades e parâmetros de conexão por meio do editor de propriedades. No entanto, haverá situações nas quais teremos que criar um objeto TSQLConnection em tempo de execução, ou seja, criar o componente, fornecer valores para suas propriedades e efetuar a conexão com o banco de dados durante a execução do programa.

Nesta dica eu mostrarei como isso pode ser feito. Analise cuidadosamente o código abaixo (inserido no evento Click de um botão):

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm1.Button1Click(Sender: TObject);
var
  conn: TSQLConnection;
begin
  // vamos criar um novo objeto da classe TSQLConnection
  conn := TSQLConnection.Create(nil);

  // vamos definir os parâmetros da conexão...note que
  // aqui estou usando uma conexão com o MS SQL Server usando
  // Windows Authentication
  with conn do
  begin
    ConnectionName := 'MSSQLConnection';
    DriverName := 'MSSQL';
    LibraryName := 'dbxmss.dll';
    VendorLib := 'oledb';
    GetDriverFunc := 'getSQLDriverMSSQL';
    LoginPrompt := False;

    // parâmetros adicionais da conexão
    Params.Add('SchemaOverride=sa.dbo');
    Params.Add('HostName=NOTEBOOK');
    Params.Add('DataBase=estudos');
    Params.Add('OS Authentication=True');

    // vamos abrir a conexão
    try
      begin
        Open;
        ShowMessage('Conexão efetuada com sucesso.');
      end;
    except
      on e : TDBXError do // uses DBXCommon
         ShowMessage('Não foi possível efetuar a conexão. Erro: ' +
            e.Message);
    end;
  end;
end;

Veja que o primeiro passo foi declarar uma variável chamada conn do tipo TSQLConnection. Em seguida nós criamos um novo objeto desta classe usando a linha:

conn := TSQLConnection.Create(nil);

Os passos seguintes foram a definição do nome de conexão, o nome do driver, nome do servidor, nome da base de dados, etc. Usei também o tratamento de exceção para exibir uma mensagem mais descritiva no caso de a conexão não puder ser feita com sucesso.

Note que neste exemplo eu demonstro uma conexão em tempo de execução com o MS SQL Server. Este procedimento pode ser aplicado a qualquer um dos bancos de dados suportados pelo dbExpress, bastando alterar os valores das propriedades e parâmetros de conexão.

Link para compartilhar na Internet ou com seus amigos:

Delphi ::: Data Access Controls (Controles de Acesso a Dados) ::: TField e Classes Derivadas

Como usar a classe TField em seus programas Delphi

Quantidade de visualizações: 12413 vezes
A classe TField (na unit DB) é um ancestral comum de todos os componentes que representam os campos de uma tabela no banco de dados (ou um dataset cujos dados foram carregados de um arquivo do tipo texto, binário ou XML). Esta classe encapsula o comportamento comum a todos os demais componentes to tipo field (campo).

Veja sua posição na hierarquia de classes do Delphi:

System.TObject
  Classes.TPersistent
    Classes.TComponent
      DB.TField
Esta classe ainda implementa as interfaces Classes.IInterfaceComponentReference e System.IInterface.

A classe TField apresenta propriedades, eventos e métodos que são usados para as seguintes tarefas:

1) Alterar o valor de um campo em um dataset;

2) Converter o valor de um campo de um tipo para outro tipo;

3) Efetuar validações nos dados informados pelos usuários para determinados campos;

4) Definir como as informações dos campos são mostradas em tempo de exibição ou para edição;

5) Calcular o valor de um campo a partir de código escrito no evento OnCalcFields do dataset;

6) Pesquisar o valor do campo a partir de outro dataset.

Em geral não criamos instâncias da classe TField diretamente. Componentes que descendem de TField são criados automaticamente a cada vez que o dataset é ativado. Estes descendentes podem ser dinâmicos (o padrão) ou persistentes. Componentes campos dinâmicos refletem as colunas dos metadados da tabela a qual pertencem no momento que o dataset é aberto. Componentes campos persistentes são criados em tempo de design usando o editor Fields, que especifica os campos no dataset, suas propriedades e a ordem em que deverão estar.

A criação de componentes de campos persistentes garante que todas as vezes que uma aplicação for executada, ela usará e exibirá as mesmas colunas, na mesma ordem, até mesmo se a estrutura física da base de dados mudar. Se uma coluna em uma tabela na qual um componente de campo persistente é baseado for excluída ou alterada, o IDE gera uma exceção em vez de permitir a abertura do dataset usando um coluna não existente ou incompatível. Se isso acontecer, devemos remover o camponente field para o campo não existente usando o editor Fields.

Um campo (field) em um dataset é sempre tratado como uma das classes descendentes de TField abaixo:

        
TADTField          TDateField         TReferenceField   
TAggregateField    TDateTimeField     TSmallIntField   
TArrayField        TFloatField        TSQLTimeStampField   
TAutoIncField      TFMTBCDField       TStringField   
TBCDField          TGraphicField      TTimeField   
TBinaryField       TGuidField         TVarBytesField   
TBlobField         TIDispatchField    TVariantField   
TBooleanField      TIntegerField      TWideStringField   
TBytesField        TInterfaceField    TWordField   
TCurrencyField     TLargeintField     TDataSetField   
TMemoField     
Veja um trecho de código no qual usamos o método FieldByName() da classe TDataSet para obter uma referência a um determinado campo (field) de um ClientDataSet e usamos sua propriedade AsString para obter o valor do campo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm3.Button3Click(Sender: TObject);
var
  campo: TField;
begin
  // vamos obter o campo com o nome "titulo" do registro atual
  campo := ClientDataSet1.FieldByName('titulo');

  // vamos mostrar o valor do campo
  ShowMessage('O valor do campo é: ' + campo.AsString);
end;

Ao executarmos este código teremos um resultado parecido com:

"O valor do campo é: Programando em Java".

Esta dica foi escrita e testada no Delphi 2009.


Delphi ::: Dicas & Truques ::: MIDI Musical Instrument Digital Interface, Mapeamento e sequenciamento MIDI, Entrada e saída MIDI

Como retornar uma lista dos dispositivos de saída MIDI no sistema usando Delphi

Quantidade de visualizações: 11209 vezes
Em algumas ocasiões nós precisamos obter uma lista dos dispositivos de saída MIDI no sistema, talvez com o propósito de selecionar um determinado dispositivo em uma ListBox ou ComboBox. O trecho de código abaixo mostra como isso pode ser feito.

O primeiro passo é declarar uma variável do tipo TMidiOutCaps. Este registro está declarado na unit MMSystem.pas e é uma tradução da estrutura MIDIOUTCAPS da API do Windows. Entre outros tipos de dados, esta estrutura possui um membro szPname que retorna o nome do dispositivo. Na unit MMSystem.pas este membro está declarado como array[0..MAXPNAMELEN-1] of AnsiChar, ou seja, uma matriz de AnsiChar que será preenchida pela API do Windows e terá seu final marcado com o caractere null (NULL terminated string). Note a conversão deste valor para o tipo String no momento de inserí-lo no ComboBox. Em versões anteriores do Delphi (estou escrevendo este código no Delphi 2009) podíamos usar a função StrPas() para esta finalidade.

O passo seguinte é obter a quantidade de dispositivos de saída MIDI. Isso é feito com uma chamada à função midiOutGetNumDevs da API do Windows. Uma vez obtida a quantidade de dispositivos nós usamos um laço for e, no corpo deste laço, usamos o valor da variável de controle i para efetuar uma chamada à função midiOutGetDevCaps(), também da API do Windows:

midiOutGetDevCaps(i, @MidiOutCaps, sizeof(TMidiOutCaps));

Esta função recebe o identificador do dispositivo (um valor inteiro começando em 0 e indo até a quantidade de dispositivos - 1), um ponteiro para um registro MidiOutCaps e o tamanho em bytes do registro. Se a função for executada com sucesso, o registro MidiOutCaps será preenchido com várias informações úteis, tais como o nome do dispositivo, o ID do fabricante, o ID do produto, versão do driver, tipo do dispositivo MIDI, número de vozes suportadas, número máximo de notas que podem ser tocadas simultaneamente, etc.

Para finalizar, nós acessamos o campo szPname do registro MidiOutCaps e o adicionamos no ComboBox. Veja o código completo a seguir:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm1.Button2Click(Sender: TObject);
var
  i: Integer;
  MidiOutCaps: TMidiOutCaps; // este registro (record) está definido em MMSystem.pas
  erro: Word;
begin
  // uses MMSystem

  ComboBox2.Clear;
  // midiOutGetNumDevs retorna a quantidade de dispositivos de saída MIDI no sistema
  for i := 0 to midiOutGetNumDevs - 1 do
  begin
    // vamos obter o dispositivo identificado pela variável i (uDeviceID)
    erro := midiOutGetDevCaps(i, @MidiOutCaps, sizeof(TMidiOutCaps));
    if erro <> MMSYSERR_NOERROR then
       raise Exception.Create('Não foi possível obter a lista de dispositivos ' +
         'de saída MIDI');

    // vamos adicionar o nome do dispositivo no ComboBox
    ComboBox2.Items.Add(StrPas(MidiOutCaps.szPname));
  end;
end;

Ao executar este código o ComboBox será preenchido com valores semelhantes à:

Microsoft GS Wavetable SW Synth
MPU-401

Nas demais dicas relacionadas a este assunto você deverá sempre indicar o dispositivo de saída MIDI. Geralmente você poderá fornecer os valores 0 ou 1 para as funções MIDI que pedem o ID do dispositivo de saída.

Para fins de compatibilidade esta dica ou anotação foi escrita usando Delphi 2009.


Delphi ::: Dicas & Truques ::: Data e Hora

Como retornar a data e hora atual em Delphi usando as funções Now() e DateTimeToStr()

Quantidade de visualizações: 23504 vezes
Em algumas situações precisamos obter a data e hora atual do sistema. Em Delphi isso pode ser feito com o auxílio da função Now(), presente na unit SysUtils. Este função não requer nenhum argumento e retorna a data e hora atual como um TDateTime. Veja o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm1.Button1Click(Sender: TObject);
var
  data: TDateTime;
begin
  // vamos obter a data e hora atual
  data := Now();

  // vamos exibir o resultado
  ShowMessage(DateTimeToStr(data));
end;

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

28/09/2018 15:14:15

Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009.


Delphi ::: Dicas & Truques ::: Strings e Caracteres

Como converter todo o conteúdo de uma string para letras maiúsculas em Delphi usando a função AnsiUpperCase()

Quantidade de visualizações: 17161 vezes
Algumas vezes precisamos converter todo o conteúdo de uma string para letras maiúsculas. Em Delphi isso pode ser feito com o auxílio da função AnsiUpperCase(). Esta função recebe uma string e retorna outra string com todos os caracteres maiúsculos. Veja o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm1.Button1Click(Sender: TObject);
var
  nome: string;
begin
  nome := 'Osmar';

  // vamos converter a string para letras maiúsculas
  nome := AnsiUpperCase(nome);

  // exibe o resultado
  ShowMessage(nome);
end;

Note que esta função suporta caracteres de mais de um byte e com acentuações.

Para questões de compatibilidade, esta dica foi escrita usando Delphi 2009.


Delphi ::: Data Controls (Controles de Dados) ::: TDBGrid

Como obter a quantidade de linhas em um controle TDBGrid do Delphi (duas formas)

Quantidade de visualizações: 10514 vezes
A quantidade de linhas em um controle TDBGrid pode ser obtida de duas formas diferentes. A primeira consiste em fazer uma conversão de TDBGrid para TStringGrid e usar a propriedade RowCount. Veja:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm3.Button3Click(Sender: TObject);
var
  quantLinhas: Integer;
begin
  // vamos obter a quantidade de linhas no DBGrid
  quantLinhas := TStringGrid(DBGrid1).RowCount;

  // vamos mostrar o resultado
  ShowMessage('O DBGrid possui ' + IntToStr(quantLinhas) + ' linhas.');
end;

Ao executar este código você verá um mensagem parecida com:

"O DBGrid possui 5 linhas."

Note que a propriedade RowCount inclui a linha reservada aos títulos das colunas do DBGrid, ou seja, uma linha a mais que a quantidade de registros no controle.

A segunda forma de se obter a quantidade de linhas no DBGrid consiste em obter a quantidade de registros no TDataSet no qual o DBGrid está conectado por meio de sua propriedade DataSource. Veja como isso pode ser feito:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm3.Button3Click(Sender: TObject);
var
  quantLinhas: Integer;
begin
  // vamos obter a quantidade de linhas no DBGrid
  quantLinhas := DBGrid1.DataSource.DataSet.RecordCount;

  // vamos mostrar o resultado
  ShowMessage('O DBGrid possui ' + IntToStr(quantLinhas) + ' linhas.');
end;

Veja que aqui nós usamos a propriedade RecordCount para obter a quantidade de registros no DataSet. Note que agora a contagem de linhas não inclui a linha reservada para os títulos das colunas.

Esta dica foi escrita e testada no Delphi 2009.


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

Como declarar e inicializar uma matriz de Integer em Delphi

Quantidade de visualizações: 12300 vezes
Nesta dica eu mostrarei como declarar e inicializar uma matriz de inteiros (Integer) em Delphi. Mostrarei também como exibir o valor de cada elemento usando um laço For. Veja o código:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

procedure TForm3.Button1Click(Sender: TObject);
var
  // vamos declarar uma matriz de 10 inteiros
  valores: array[1..10] of Integer;
  i: Integer;
begin
  // vamos inicializar a matriz com os números pares de 2 até 20
  for i := Low(valores) to High(valores) do
    begin
      valores[i] := i * 2;
    end;

  // vamos exibir os valores dos elementos
  for i := Low(valores) to High(valores) do
    begin
      Memo1.Lines.Add(IntToStr(valores[i]));
    end;
end;


Ao executar este código teremos o seguinte resultado:

2
4
6
8
10
12
14
16
18
20


Delphi ::: Dicas & Truques ::: Recursão (Recursividade)

Como usar recursividade em Delphi - Como usar recursão ou funções recursivas em Delphi

Quantidade de visualizações: 15386 vezes
Recursão ou recursividade é a habilidade que uma procedure ou function (função) possui de chamar a si própria uma vez, várias, indefinidamente ou até que a solução do problema a ser resolvido seja encontrada. Assim, podemos definir uma função recursiva (aqui uma procedure recursiva) em Delphi da seguinte forma (atenção: não execute este código):

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

// uma procedure recursiva
procedure Recursiva;
begin
  // chama a si própria
  Recursiva;
end;

// vamos chamar a procedure pela primeira vez
// a partir do Click de um botão
procedure TForm1.Button1Click(Sender: TObject);
begin
  Recursiva;
end;

O fato de eu pedir para que você não execute o código é que, uma vez clicado o botão, a procedure Recursiva será chamada e continuará chamando a si mesma até que a pilha do sistema estoure, ou seja, como funções recursivas são implementadas usando a pilha do sistema operacional e não na área de memória destinada a cada aplicativo o resultado será um travamento do programa, e, caso não estejamos com sorte, um travamento do sistema operacional. Sabedor do risco, clique no botão para ver o resultado você mesmo.

O que devemos saber a respeito das funções recursivas é que estas precisam saber o ponto de parada, de forma a evitar chamadas infinitas. Como exemplo, veja uma procedure recursiva que conta de 0 até 10. Note como cada chamada verifica se já é hora de interromper a cadeia:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

// uma procedure recursiva que conta de 0 até 10
procedure Contar(valor: Integer);
begin
  // vamos exibir o valor atual
  ShowMessage(IntToStr(valor));

  // é hora de parar?
  if valor = 10 then
    ShowMessage('Terminei')
  else
    begin
      // chama a si própria (note que aumentamos o valor atual em 1)
      Inc(valor);
      Contar(valor);
    end;
end;

// vamos chamar a procedure pela primeira vez
// a partir do Click de um botão
procedure TForm1.Button1Click(Sender: TObject);
begin
  // chama a função recursiva fornecendo o valor inicial
  Contar(0);
end;

Execute este código e veja o resultado. Observe que a cada chamada recursiva nós incrementamos a variável de controle. Ela é a responsável por evitar que chamadas infinitas sejam feitas.

Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009.


Delphi ::: Dicas & Truques ::: Aplicativos e Outros

Como calcular a distância entre dois pontos na terra em Delphi

Quantidade de visualizações: 1341 vezes
Nesta dica mostrarei como calcular a distância em quilômetros entre dois pontos na terra dadas suas latitudes e longitudes. Neste exemplo eu coloquei o valor de 6378.137 para o raio da terra, mas você pode definir para o valor que achar mais adequado.

O cálculo usado neste código se baseia na Fórmula de Haversine, que determina a distância do grande círculo entre dois pontos em uma esfera, dadas suas longitudes e latitudes.

Veja o código Delphi completo:

----------------------------------------------------------------------
Se precisar de ajuda para ajustar o código abaixo de acordo com as
suas necessidades, chama a gente no WhatsApp +55 (62) 98553-6711 (Osmar)

Ah, e se puder, faça uma DOAÇÃO de qualquer valor para nos ajudar
a manter o site livre de anúncios. Ficaremos eternamente gratos ;-)
Nosso PIX é: osmar@arquivodecodigos.com.br 
----------------------------------------------------------------------

// função que recebe dois pontos na terra e retorna a distância
// entre eles em quilômetros
function CalcularDistancia(lat1: double; lat2: double; lon1: double;
  lon2: double): double;
var
  raio_terra, dlon, dlat, a, c: double;
begin
  raio_terra := 6378.137; // raio da terra em quilômetros

  // o primeiro passo é converter as latitudes e longitudes
  // para radianos
  // não esqueça de adicionar a unit Math
  lon1 := DegToRad(lon1);
  lon2 := DegToRad(lon2);
  lat1 := DegToRad(lat1);
  lat2 := DegToRad(lat2);

  // agora aplicamos a Fórmula de Haversine
  dlon := lon2 - lon1;
  dlat := lat2 - lat1;
  a := Power(Sin(dlat / 2), 2) + Cos(lat1) * Cos(lat2)
    * Power(Sin(dlon / 2),2);

  c := 2 * ArcSin(Sqrt(a));

  // e retornamos a distância
  Result := (c * raio_terra);
end;

procedure TForm5.Button1Click(Sender: TObject);
var
  lat1, lon1, lat2, lon2, distancia: double;
begin
  // obtém as coordenadas vindas dos campos de texto
  lat1 := StrToFloat(txtPrimeiraLatitude.Text);
  lon1 := StrToFloat(txtPrimeiraLongitude.Text);
  lat2 := StrToFloat(txtSegundaLatitude.Text);
  lon2 := StrToFloat(txtSegundaLongitude.Text);

  // vamos calcular a distância entre os dois pontos em Kms
  distancia := CalcularDistancia(lat1, lat2, lon1, lon2);

  // e mostramos o resultado
  txtDistancia.Text := FormatFloat('#.0', distancia) + ' kms';
end;

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

Informe a primeira latitude: -16,674551
Informe a primeira longitude: -49,303598
Informe a segunda latitude: -15,579321
Informe a segunda longitude: -56,10009
A distância entre os dois pontos é: 736,9 kms

Aqui as informações sobre as latitudes e longitudes vieram de campos de texto TEdit, e o código foi disparado a partir do clique de um botão TButton.

Neste exemplo eu calculei a distância entre as cidades de Goiânia-GO e Cuiabá-MT.

A latitude é a distância ao Equador medida ao longo do meridiano de Greenwich. Esta distância mede-se em graus, podendo variar entre 0o e 90o para Norte(N) ou para Sul(S). A longitude é a distância ao meridiano de Greenwich medida ao longo do Equador.


Desafios, Exercícios e Algoritmos Resolvidos de Delphi

Veja mais Dicas e truques de Delphi

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



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