No Delphi e no Lazarus, as seções initialization e finalization são partes especiais das units usadas para executar código automaticamente quando o programa carrega ou descarrega aquela unidade. Elas funcionam como “ganchos” de execução automática.

O que é initialization

É uma seção opcional dentro de uma unit.
O código ali dentro é executado automaticamente quando:

• A aplicação é iniciada e a unit é usada por alguma outra unit (aparece em uses)
• Ou um package é carregado
• Ou uma DLL é carregada

Para que serve?

• Criar objetos globais
• Abrir conexões
• Inicializar variáveis
• Registrar classes (por exemplo, em frameworks de RTTI, componentes, etc.)

Exemplo

unit MyUnit;

interface

implementation

uses
  Classes;

var
  Lista: TStringList;

initialization
  Lista := TStringList.Create;
  Writeln('Inicializei a lista!');

finalization
  Lista.Free;
  Writeln('Liberei a lista!');

end.

finalization

A seção finalization é executada automaticamente quando a unit está sendo descarregada, tipicamente no encerramento da aplicação.

Para que serve

• Liberar objetos criados na initialization.
• Fechar arquivos, conexões, sockets.
• Desregistrar classes.
• Limpar recursos.

Ordem de execução

A ordem segue a cadeia de dependências:

Initialization:

1. Units mais “profundas” na árvore de dependências são inicializadas antes. Também podemos entender que é a ordem em que as units aparecem na cláusula uses
2. A unit principal é inicializada por último.

Finalization:

A ordem é invertida.

Quando usar?

Use initialization/finalization quando:

• Precisar configurar algo global que deve existir enquanto a aplicação estiver rodando.
• Precisar garantir que recursos sejam liberados automaticamente ao finalizar.

Evite usar quando:

• O custo de inicializar for alto (pode deixar o app lento na inicialização)
• Gerar dependências circulares de units

Conclusão

As seções initialization e finalization oferecem ao desenvolvedor um controle poderoso sobre o ciclo de vida das units em Delphi e Lazarus, permitindo inicializar e liberar recursos de forma automática e organizada. Quando usadas corretamente, elas ajudam a garantir que a aplicação comece e termine de maneira consistente, segura e eficiente.

Gostou da explicação?

Já utilizou initialization e finalization em algum projeto ou teve alguma situação curiosa envolvendo essas seções?

Compartilhe suas experiências nos comentários — vamos aprender juntos!

#Delphi #Lazarus #FreePascal #Programação

#DesenvolvimentoDeSoftware #DevTips #CódigoLimpo

#SoftwareEngineering #Pascal #BackendDevelopment

#GiovaniDaCruz

Em muitos sistemas, é comum precisarmos padronizar textos gravados no banco de dados, especialmente descrições e nomes que chegam em letras maiúsculas ou minúsculas.

Se você utiliza Firebird 5, é possível resolver isso diretamente no banco, criando uma função interna capaz de converter qualquer texto para o formato Title Case — ou seja, com a primeira letra de cada palavra em maiúsculo e as demais em minúsculo.

O desafio

O Firebird possui funções como UPPER() e LOWER(), mas nenhuma função nativa que aplique a capitalização de cada palavra.
Por exemplo, não há algo como INITCAP() (presente em bancos como Oracle e PostgreSQL).

Por isso, precisamos criar nossa própria função interna PSQL, que percorre cada caractere da string, identifica o início de uma nova palavra e aplica UPPER() ou LOWER() conforme o caso.

Criando a função INITCAP_UTF8

A seguir está uma função compatível com Firebird 5, que trata inclusive acentos e caracteres especiais.
Ela transforma qualquer texto em formato de título, preservando a legibilidade e o padrão de escrita:

CREATE OR ALTER FUNCTION INITCAP_UTF8(TEXTO VARCHAR(255) CHARACTER SET UTF8)
RETURNS VARCHAR(255) CHARACTER SET UTF8
AS
DECLARE VARIABLE I INT;
DECLARE VARIABLE TAM INT;
DECLARE VARIABLE C CHAR(1) CHARACTER SET UTF8;
DECLARE VARIABLE RESULTADO VARCHAR(255) CHARACTER SET UTF8;
DECLARE VARIABLE PROX_MAIUSC BOOLEAN;
BEGIN
  TEXTO = TRIM(TEXTO);
  RESULTADO = '';
  PROX_MAIUSC = TRUE;
  TAM = CHAR_LENGTH(TEXTO);

  I = 1;
  WHILE (I <= TAM) DO
  BEGIN
    C = SUBSTRING(TEXTO FROM I FOR 1);

    -- Se for letra (inclusive acentuadas)
    IF (PROX_MAIUSC AND C SIMILAR TO '[A-Za-zÁÉÍÓÚÀÈÌÒÙÂÊÎÔÛÃÕÇáéíóúàèìòùâêîôûãõç]') THEN
      RESULTADO = RESULTADO || UPPER(C);
    ELSE
      RESULTADO = RESULTADO || LOWER(C);

    -- Verifica se o próximo caractere inicia nova palavra
    IF (C IN (' ', '.', ',', ';', ':', '!', '?', '(', ')', '-', '''', '"')) THEN
      PROX_MAIUSC = TRUE;
    ELSE
      PROX_MAIUSC = FALSE;

    I = I + 1;
  END

  RETURN RESULTADO;
END;

Aplicando a função no seu banco

Após criar a função, você pode usá-la em qualquer comando SQL.
Por exemplo, para atualizar todos os registros de um campo:

UPDATE produto s
SET s.descricao = INITCAP_UTF8(s.descricao)
WHERE s.tipo_item = 'P';

Esse comando deixará o campo descricao com o formato adequado, tornando o conteúdo mais padronizado e agradável para o usuário.

Exemplos práticos

Por que usar funções internas no Firebird?

Nas versões mais recentes do Firebird 5, as funções SQL internas (PSQL-based) se tornaram uma ferramenta poderosa.
Elas substituem as antigas UDFs externas, permitem melhor portabilidade do banco e garantem maior segurança, já que todo o processamento é feito dentro do engine, sem depender de bibliotecas externas em C.

Além disso, funções como essa tornam a manutenção de dados muito mais simples, evitando a necessidade de scripts de pós-processamento em aplicações Delphi, .NET ou outras linguagens.

Outras versões

Vale destacar que as Internal Functions estão disponíveis a partir do Firebird 3, o que permite integrar funções como esta diretamente ao banco.

Para quem utiliza versões anteriores, é possível adaptar a lógica criando uma Stored Procedure que percorre o texto caractere por caractere, aplicando a mesma regra de capitalização. Assim, a funcionalidade continua acessível mesmo em ambientes legados.

Conclusão

Com poucas linhas de código, é possível deixar seu banco de dados Firebird mais inteligente e padronizado.
A função INITCAP_UTF8 é um ótimo exemplo de como aproveitar os recursos do Firebird 5 para lidar melhor com strings em UTF-8, mantendo a integridade e a estética dos dados.

Dica: se quiser deixar a função ainda mais refinada, é possível ignorar palavras curtas como “de”, “da”, “em”, aplicando capitalização apenas quando fizer sentido em títulos.

E você?

Já precisou padronizar textos diretamente no banco de dados?
Compartilhe sua experiência ou dúvida nos comentários!

#Firebird #SQL #BancoDeDados

#Desenvolvimento

#GiovaniDaCruz

Quando estamos desenvolvendo aplicações em Delphi / Lazarus, muitas vezes precisamos ajustar o comprimento de uma string, adicionando caracteres à esquerda ou à direita. Isso é especialmente útil para padronizar saídas de relatórios, códigos formatados ou preenchimento de campos de tamanho fixo.

Em bancos de dados SQL, temos funções como LPAD e RPAD para realizar essa tarefa. No entanto, no Delphi / Lazarus, precisamos criar funções personalizadas para obter o mesmo resultado. Vamos ver como fazer isso de forma simples e eficiente!

Função LPAD em Delphi e Lazarus

A função LPAD (Left Pad) é usada para preencher uma string à esquerda com um caractere especificado, até que ela alcance o comprimento desejado. Veja como criar essa função em Delphi:

function LPad(const AText: string; ALength: Integer; AChar: Char = '0'): string;
begin
  if Length(AText) >= ALength then
    Result := AText
  else
    Result := StringOfChar(AChar, ALength - Length(AText)) + AText;
end;

Como utilizar o LPAD

var
  PaddedText: string;
begin
  PaddedText := LPad('123', 6);  // Resultado: '000123'
  ShowMessage(PaddedText);
end;

Explicação

• AText: A string que deseja preencher.
• ALength: O comprimento final da string após o preenchimento.
• AChar: O caractere utilizado para o preenchimento (padrão: ‘0’).
• A função verifica se o comprimento da string já é suficiente. Caso seja, retorna a string original; caso contrário, adiciona os caracteres de preenchimento à esquerda.

Função RPAD em Delphi e Lazarus

A função RPAD (Right Pad) é usada para preencher uma string à direita com um caractere especificado. Veja como criar a função:

function RPad(const AText: string; ALength: Integer; AChar: Char = ' '): string;
begin
  if Length(AText) >= ALength then
    Result := AText
  else
    Result := AText + StringOfChar(AChar, ALength - Length(AText));
end;

Como utilizar o RPAD

var
  PaddedText: string;
begin
  PaddedText := RPad('123', 6);  // Resultado: '123   '
  ShowMessage(PaddedText);
end;

Explicação

• A lógica é semelhante à função LPAD, mas o preenchimento é feito à direita da string.
• O caractere de preenchimento padrão é o espaço em branco (‘ ‘).

Conclusão

Essas funções são muito úteis para padronizar saídas de texto e garantir que os valores estejam alinhados conforme necessário. Agora você já sabe como implementar e usar as funções LPAD e RPAD no Delphi e Lazarus de maneira prática e eficiente!

Gostou da dica? Deixe seu comentário e compartilhe este post com seus amigos desenvolvedores!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue desenvolvendo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Até o próximo post. Valeu!

#Delphi #Lazarus #Programacao #Desenvolvimento #DicasDeDev

#LPAD #RPAD #DelphiTips #DevLife #GiovaniDaCruz #PascalModerno

#GiovaniDaCruz

Manipular dados em JSON é uma tarefa comum para desenvolvedores, mas no Delphi, essa operação pode parecer desafiadora, especialmente quando se trata de atualizar valores existentes. Neste artigo, vamos explorar como fazer isso de forma eficiente, utilizando um código funcional e organizado.

O Problema

No Delphi, você não pode simplesmente sobrescrever valores em um objeto JSON com uma atribuição direta. Tentar algo como:

EnderecoObj.Values['cidade'] := 'Rio de Janeiro'; // Gera erro

Isso resulta no erro E2129 Cannot assign to a read-only property. A solução é remover a chave existente e depois adicionar o novo valor. Para simplificar esse processo, criamos o método PostValue, que lida automaticamente com a remoção e adição do valor.

O Método PostValue

A função PostValue, que criamos aqui, encapsula a lógica de atualização, tornando o código mais limpo e reutilizável:

procedure PostValue(pObj: TJSONObject; pName: String; pJSONValue: TJSONValue);
var
  vJsonPair: TJsonPair;
begin
  vJsonPair := pObj.Get(pName);

  if Assigned(vJsonPair) then
  begin
    // Removendo o par existente
    pObj.RemovePair(pName);
    // Adicionando o novo valor
    pObj.AddPair(pName, pJSONValue);
  end
  else
    // Adiciona o par caso ele não exista
    pObj.AddPair(pName, pJSONValue);
end;

Exemplo Completo

Abaixo está o exemplo funcional que utiliza o método PostValue para atualizar dados de um JSON.

(*

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*)

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.JSON, System.SysUtils;

procedure PostValue(pObj: TJSONObject; pName: String; pJSONValue: TJSONValue);
var
  vJsonPair: TJsonPair;
begin
  vJsonPair:= pObj.Get(pName);

  if Assigned(vJsonPair) then
     begin
       //putting the pair at the end of the object
       pObj.RemovePair(pName);
       pObj.AddPair(pName, pJSONValue);
     end
  else
    pObj.AddPair(pName, pJSONValue);
end;

var
  JSONObj, EnderecoObj: TJSONObject;
  JSONString: string;
begin
  // JSON inicial
  JSONString := '{ "usuario": { "nome": "João", "idade": 30, "endereco": { "cidade": "São Paulo", "estado": "SP" } } }';

  // Carregando o JSON
  JSONObj := TJSONObject.ParseJSONValue(JSONString) as TJSONObject;

  try
    // Obtendo o objeto "endereco"
    EnderecoObj := JSONObj.GetValue<TJSONObject>('usuario.endereco');

    if Assigned(EnderecoObj) then
    begin
      // Atualizando a Cidade
      PostValue(EnderecoObj, 'cidade', TJSONString.Create('Rio de Janeiro'));

      // Atualizando o Estado
      PostValue(EnderecoObj, 'estado', TJSONString.Create('RJ'));
    end;

    // Exibindo o JSON atualizado
    Writeln(JSONObj.ToJSON);

    Readln;
  finally
    // Liberando memória
    JSONObj.Free;
  end;

end.

Resultado

Após executar o código, o JSON é atualizado com sucesso, e o resultado final é:

{
  "usuario": {
    "nome": "João",
    "idade": 30,
    "endereco": {
      "cidade": "Rio de Janeiro",
      "estado": "RJ"
    }
  }
}

Pontos de Atenção

• Memória: Sempre libere os objetos JSON criados usando Free para evitar vazamentos de memória.
• Reutilização: O método PostValue pode ser usado em qualquer parte do seu código para atualizar valores de objetos JSON.
• Validação: Antes de manipular, sempre verifique se o objeto retornado está atribuindo usando Assigned.

Conclusão

Com o método PostValue, você pode atualizar objetos JSON no Delphi de forma elegante e eficiente. Essa abordagem é ideal para aplicações que manipulam dados complexos e necessitam de uma forma simples de manter os valores atualizados.

Gostou do conteúdo? Tem algo a acrescentar?
Deixe seu comentário abaixo!

Adoraria saber sua opinião sobre como atualizar dados em JSON no Delphi. Se você tem dicas ou dúvidas, compartilhe com a gente!

Vamos trocar ideias e aprender juntos!

Compartilhe o post com outras pessoas se ele te ajudou!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Até o próximo post. Valeu!

#Delphi #JSON #Programação #Desenvolvimento

#Tecnologia #DicasDeProgramação #Codificando #BancoDeDados

#Desenvolvedor #Tutorial

#GiovaniDaCruz

No desenvolvimento de aplicativos com Delphi e Lazarus, uma funcionalidade que muitas vezes passa despercebida, mas que pode ser extremamente útil, é a definição de valores default para propriedades. Este recurso simplifica o design de componentes e controles personalizados, além de melhorar a legibilidade e a manutenção do código.

O que são valores default?

Em Delphi e Lazarus, a declaração default em propriedades serve para definir qual propriedade de um objeto será considerada a propriedade padrão. Isso significa que, em certos contextos, você pode acessar essa propriedade sem precisar especificar explicitamente o nome dela.

Também é possível ter Valores default (ou padrão), que são atribuídos a propriedades de classes e componentes para que, caso o programador não os defina explicitamente, o valor padrão seja usado automaticamente no object inspector. Essa funcionalidade reduz a necessidade de configurações manuais e garante um comportamento previsível do componente.

Como definir propriedades default em Delphi / Lazarus

Quando você declara uma propriedade com a palavra-chave default, o compilador Delphi / Free Pascal permite que você omita o nome da propriedade ao acessá-la em algumas situações, como ao usar o objeto em um contexto onde uma string é esperada, assim como em listas e caixas de combinação.

Exemplo:

type
  TMeuObjeto = class
  private
    FNome: string;
    FLista : array of Integer;
    function GetNumeros(Index: Integer): Integer;
    procedure SetNumeros(Index: Integer; const Value: Integer);

  public
    constructor Create; Virtual;
    property Nome: string read FNome write FNome;

    { Exemplo de Propriedade Default }
    property Numeros[Index: Integer] : Integer read GetNumeros write SetNumeros; default;
  end;

Quando usar:

A declaração default é útil principalmente para componentes visuais e outras classes que precisam ser usadas em contextos onde uma string é esperada, como em listas e caixas de combinação. Nesses casos, a propriedade padrão geralmente é aquela que representa o texto a ser exibido.

Outros pontos importantes:

• Apenas uma propriedade por classe pode ser declarada como default.
• A propriedade default deve ser do tipo string, Integer, char, PChar, Word ou um tipo enumerado.
• O uso de default pode tornar o código mais conciso e legível em algumas situações, mas é importante usá-lo com moderação para não prejudicar a clareza do código.

Exemplo de Programa Completo

(*

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*)

program ProjectPropertyDefault;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
  TMeuObjeto = class
  private
    FNome: string;
    FLista : array of Integer;
    function GetNumeros(Index: Integer): Integer;
    procedure SetNumeros(Index: Integer; const Value: Integer);

  public
    constructor Create; Virtual;
    property Nome: string read FNome write FNome;

    { Exemplo de Propriedade Default }
    property Numeros[Index: Integer] : Integer read GetNumeros write SetNumeros; default;
  end;

var
  MeuObjeto: TMeuObjeto;

{ TMeuObjeto }

constructor TMeuObjeto.Create;
begin
  SetLength(FLista, 10);  // somente para o exemplo
end;

function TMeuObjeto.GetNumeros(Index: Integer): Integer;
begin
  Result := FLista[Index];
end;

procedure TMeuObjeto.SetNumeros(Index: Integer; const Value: Integer);
begin
  FLista[Index] := Value;
end;

begin
  MeuObjeto := TMeuObjeto.Create;
  try
    MeuObjeto.Nome := 'Teste';

    { Acesso normal à propriedade Nome }
    Writeln(MeuObjeto.Nome);

    { Aqui seria o acesso normal, sem default }
    MeuObjeto.Numeros[1] := 123;
    Writeln(IntToStr(MeuObjeto.Numeros[1]));

    { Acesso à propriedade Lista (com default)
     de modo simplificado / direto }
    MeuObjeto[2] := 456;
    Writeln(IntToStr(MeuObjeto[2]));  // <- acesso direto

    Readln;
  finally
    MeuObjeto.Free;
  end;
end.

Como definir valores default em Delphi / Lazarus

Quando você define um valor literal após a palavra-chave default em uma propriedade, como em property Numero: Integer read FValor write FValor default 10;, você está especificando o valor padrão da propriedade em tempo de design. Isso tem um efeito importante no Object Inspector do Delphi / Lazarus.

O efeito no Object Inspector

Quando você coloca um componente no formulário e inspeciona suas propriedades no Object Inspector, a propriedade com um valor default aparecerá com esse valor pré-definido. Mais importante, o valor aparecerá em negrito no Object Inspector enquanto o valor da propriedade for igual ao valor default.

Aqui está um exemplo simples:

type
  TMeuObjeto = class
  private
    FValor: Integer;
  published
    property ValorPadrao: Integer read FValor write FValor default 10;
  end;

Neste exemplo, se você criar uma instância de TMeuObjeto e inspecionar a propriedade ValorPadrao no Object Inspector, você verá o valor 10 exibido em negrito.

Quando o negrito desaparece:

Se você alterar o valor da propriedade ValorPadrao no Object Inspector, o negrito desaparecerá. Isso serve como um indicador visual claro de que o valor da propriedade foi explicitamente modificado pelo desenvolvedor, e não está mais usando o valor padrão.

O efeito no DFM / LFM:

Quando você salva o formulário (arquivo .dfm OU .lfm), o valor da propriedade não será gravado no arquivo DFM se o valor da propriedade for igual ao valor default. Isso economiza espaço no arquivo DFM e o mantém mais limpo.

Exemplo:

Se você deixar ValorPadrao com o valor 10 no Object Inspector (ou seja, o valor padrão), a linha correspondente a essa propriedade não será gravada no arquivo .dfm. No entanto, se você alterar o valor para, digamos, 15, a seguinte linha será gravada no .dfm:

object MeuObjeto1: TMeuObjeto
  ValorPadrao = 15
end

Quando você define um valor literal após a palavra-chave default em uma propriedade, como em property ValorPadrao: Integer read FValor write FValor default 10;, você está especificando o valor padrão da propriedade em tempo de design. Isso tem um efeito importante no Object Inspector do Delphi IDE.

O efeito no Object Inspector:

Quando você coloca um componente no formulário e inspeciona suas propriedades no Object Inspector, a propriedade com um valor default aparecerá com esse valor pré-definido. Mais importante, o valor aparecerá em negrito no Object Inspector enquanto o valor da propriedade for igual ao valor default.

Exemplo:

type
  TMeuObjeto = class
  private
    FValor: Integer;
  published
    property ValorPadrao: Integer read FValor write FValor default 10;
  end;

Neste exemplo, se você criar uma instância de TMeuObjeto e inspecionar a propriedade ValorPadrao no Object Inspector, você verá o valor 10 exibido em negrito.

Quando o negrito desaparece:

Se você alterar o valor da propriedade ValorPadrao no Object Inspector, o negrito desaparecerá. Isso serve como um indicador visual claro de que o valor da propriedade foi explicitamente modificado pelo desenvolvedor, e não está mais usando o valor padrão.

O efeito no DFM / LFM:

Quando você salva o formulário (arquivo .dfm), o valor da propriedade não será gravado no arquivo DFM se o valor da propriedade for igual ao valor default. Isso economiza espaço no arquivo DFM e o mantém mais limpo.

Exemplo:

Se você deixar ValorPadrao com o valor 10 no Object Inspector (ou seja, o valor padrão), a linha correspondente a essa propriedade não será gravada no arquivo .dfm. No entanto, se você alterar o valor para, digamos, 15, a seguinte linha será gravada no .dfm:

object MeuObjeto1: TMeuObjeto
  ValorPadrao = 15
end

Em resumo:

• default 10 (ou qualquer outro valor literal) define o valor padrão da propriedade no Object Inspector.
• O valor padrão aparece em negrito no Object Inspector.
• Valores padrão não são gravados no arquivo .dfm, economizando espaço.
• A alteração do valor no Object Inspector remove o negrito e faz com que o valor seja gravado no .dfm.

Essa funcionalidade é extremamente útil para:

• Clareza visual: Ajuda a identificar rapidamente quais propriedades foram modificadas em relação aos seus valores padrão.
• DFMs mais limpos: Reduz o tamanho dos arquivos .dfm, armazenando apenas as diferenças em relação aos valores padrão.
• Facilidade de uso: Simplifica a configuração inicial dos componentes, fornecendo valores padrão sensatos.

Conclusão

A definição de valores default para propriedades é uma prática simples, mas poderosa, que contribui para componentes mais robustos e fáceis de usar. Tanto no Delphi quanto no Lazarus, esse recurso ajuda a garantir que seus componentes e controles personalizados tenham um comportamento previsível e sejam mais fáceis de integrar em diferentes projetos.

Do mesmo modo, a definição de um valor literal com default em propriedades Delphi / Lazarus tem um impacto direto na experiência de desenvolvimento dentro do IDE, tornando o trabalho com componentes mais eficiente e organizado.

Adoraríamos saber a sua opinião!

Deixe seu comentário abaixo e compartilhe conosco o que você pensa sobre propriedades e valores default.

Sua participação é muito importante para nós!

Compartilhe o post com outras pessoas se ele te ajudou!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Até o próximo post. Valeu!

#Delphi #Lazarus #Programação #DesenvolvimentoDeSoftware

#Componentes #DicasDeDev #DevTips

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Neste exercício, vamos explorar a lógica de programação criando uma representação visual de uma árvore de Natal. O objetivo é praticar o uso de estruturas de repetição, manipulação de strings e formatação de saída. Você aprenderá como calcular o posicionamento de elementos visuais, como estrelas e espaços, para construir uma forma triangular simétrica e adicionar uma base decorativa à árvore. Além disso, encerraremos o programa com uma mensagem de felicitações natalinas, tornando o exercício divertido e comemorativo. Essa atividade é ideal para reforçar conceitos fundamentais de programação.

Exercício

Escreva um programa que desenhe uma árvore de Natal no terminal. O programa deve permitir que o usuário escolha a altura da árvore e, no final, exiba uma mensagem de “Feliz Natal e Próspero Ano Novo!”.

Como desafio adicional, tente fazer um caule e um chão para a árvore.

O que podemos aprender com este exercício?

Estruturas de Repetição

Utilização do laço for para iterar e construir cada linha da árvore, reforçando como manipular sequências.

Manipulação de Strings

Python: Trabalha com concatenação e multiplicação de strings (" " * n, "*" * n), mostrando como gerar padrões.

Pensamento Algorítmico

Incentiva os programadores a dividir um problema maior (desenhar uma árvore e exibir uma mensagem) em subproblemas menores (gerar cada linha, calcular espaços, construir a base).

Criatividade na Programação

O exercício mostra como a programação pode ser criativa e divertida, não apenas funcional. Projetos como este despertam interesse e tornam o aprendizado mais envolvente.

Sugestão de Resposta em Python

'''
    Criado pelo Professor Giovani Da Cruz
    https://giovanidacruz.com.br
'''

# Entrada: Altura da árvore
altura = int(input("Digite a altura da árvore de Natal: "))

# Construção da árvore
for i in range(altura):
    espacos = " " * (altura - i - 1)
    estrelas = "*" * (2 * i + 1)
    print(espacos + estrelas)

# Base da árvore
base = " " * (altura - 2) + "| |"
print(base)

# Desenhando um chao
chao = " " + "¯" * (altura - 3) + "   " + "¯" * (altura - 3)
print(chao)

# Felicitações natalinas
print("\nFeliz Natal e Próspero Ano Novo!")

Explicação

O código em Python solicita ao usuário a altura da árvore e, utilizando um laço for, constrói a árvore linha por linha. Para cada linha, calcula o número de espaços (" " * (altura - i - 1)) para alinhar as estrelas no centro e o número de estrelas ("*" * (2 * i + 1)) para formar cada nível triangular. Cada linha é exibida concatenando os espaços e as estrelas.

Após o desenho da árvore, são adicionadas duas linhas, uma com a base da árvore (| |) centralizada e outra que desenha o chão.

Ao final é exibida uma mensagem de “Feliz Natal e Próspero Ano Novo!”.

Conclusão

Este exercício oferece uma oportunidade rica para desenvolver habilidades práticas e teóricas, enquanto explora linguagens de programação. Ele é um exemplo de como desafios simples podem ensinar lições valiosas e construir confiança em novos programadores!

Sua opinião importa!

Adoramos ouvir nossos leitores! Tem alguma dúvida, sugestão ou experiência para compartilhar sobre o tema?

Gostaria de outras linguagens? Deixe seu comentário abaixo!

Vamos conversar e aprender juntos!

Compartilhe o post com outras pessoas se ele te ajudou!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Até o próximo post. Valeu!

#Programação #Python #Desenvolvimento #Natal

#LógicaDeProgramação #DevLife #Aprendizado #DesafioDeDev

#GiovaniDaCruz

O Ionic é um dos frameworks mais populares para o desenvolvimento de aplicativos híbridos, permitindo criar aplicações móveis para Android, iOS e até mesmo para web com uma única base de código. Baseado em tecnologias web como HTML, CSS e JavaScript, o Ionic oferece uma experiência robusta e flexível para desenvolvedores, independentemente do nível de experiência.

Se você deseja desenvolver aplicativos visualmente atrativos, com alta performance e sem a necessidade de aprender linguagens nativas como Swift (iOS) ou Kotlin (Android), o Ionic pode ser a escolha ideal.

Aplicações híbridas são aplicativos móveis construídos de maneira alternativa a aplicações nativa. São construídos, geralmente, utilizando HTML, CSS e JavaScript, desta maneira se tornaram extremamente populares, pois permite o desenvolvimento multiplataforma, utilizando o mesmo HTML para diferentes sistemas operacionais.

Caso você não saiba o que é um Framework

O framework é um facilitador no desenvolvimento de diversas aplicações e, sem dúvida, sua utilização poupa tempo e custos para quem utiliza, pois de forma mais básica, é um conjunto de bibliotecas utilizadas para criar uma base onde as aplicações são construídas, um otimizador de recursos. Tem como principal objetivo resolver problemas recorrentes com uma abordagem mais genérica. Ele permite ao desenvolvedor focar nos “problemas” da aplicação, não na arquitetura e configurações.

Sendo assim, o que é o Ionic?

Desenvolvido por Max Lynch, Ben Sperry e Adam Bradley da Drifty Co., sua primeira versão teve seu lançamento em 2013 e atualmente encontra-se na versão 4.

Como dito acima, é um Framework para criação de aplicações móveis e desktop de alto desempenho e qualidade, que utiliza as tecnologias web HTML, CSS e JavaScript.

Como diz em seu site, o Ionic ajuda as equipes a criarem e distribuírem belos aplicativos híbridos em várias plataformas, possuindo foco na experiência do usuário ou interação do usuário com o aplicativo (controles, interação, gestos, animações).

Projetado para funcionar e ser exibido em diferentes plataformas, possui um design limpo, simples e funcional, com componentes padrões, tipografia, paradigmas interativos e diversos templates.

Além disso, possui um cliente de linha de comando (CLI) para gerenciar todo projeto criado com o Ionic. O CLI é uma ferramenta que cria aplicativos Ionic de forma rápida e fornece vários comandos úteis para facilitar o desenvolvimento utilizando o Framework. Possui um servidor de desenvolvimento integrado, ferramentas de compilação e depuração, entre outros benefícios.

Como o Ionic funciona?

O Ionic é construído sobre o Angular, React ou Vue.js, dependendo da sua preferência. Ele utiliza o Capacitor ou o Cordova como ponte para acessar recursos nativos do dispositivo, como câmera, GPS e notificações.
Seu diferencial está em seus componentes prontos, que seguem os padrões visuais do Material Design (Google) e Human Interface Guidelines (Apple), garantindo uma interface amigável e consistente para os usuários.

Por que aprender Ionic?

Além da principal vantagem no desenvolvimento de aplicações híbridas, muitas outras vantagens podem ser listadas quando pensamos no Ionic, dentre elas:

• Estabilidade na criação de aplicações híbridas: Apesar de utilizar HTML, CSS e JS para o desenvolvimento das aplicações, o Ionic entrega um produto altamente estável e com desempenho similar ao de aplicativos nativos;
• Multiplataforma: Com o Ionic, podemos desenvolver um único código que seja executado em diferentes sistemas operacionais, diminuindo o tempo de desenvolvimento de novas aplicações.
• Menor tempo de desenvolvimento: Por criar aplicações multiplataforma, o tempo no desenvolvimento dessa aplicação se torna algo vantajoso em relação às aplicações nativas, uma vez que todo código criado será reutilizado para qualquer sistema operacional móvel, diminuindo assim o tempo de desenvolvimento;
• Menor custo: Uma vez que poupamos o tempo em seu desenvolvimento, estamos poupando os custos desta aplicação, fazendo com que, criar aplicações multiplataforma torne-se algo mais rentável e menos custoso;
• Prototipação: Criar telas no Ionic é extremamente fácil, pois possui uma ferramenta para esta finalidade, o Ionic Creator, que é uma ferramenta de “arrasta e solta” para facilitar as ideias de criação de suas aplicações;
• Documentação: Além de possuir uma grande comunidade, a documentação do Ionic é bastante completa, entre outras.

Para que serve o Ionic?

O Ionic serve para desenvolver soluções digitais em múltiplas plataformas.

Isso significa que ele pode ser usado para a criação de aplicativos para os sistemas operacionais Android, iOS, Windows, Linux, entre outros.

Além disso, apesar de ser um framework híbrido, ele responde bem aos hardwares nativos dos dispositivos.

GPS e leitor de câmera são exemplos de recursos nativos, por exemplo. Para utilizá-los com o Ionic, você lança mão dos plugins exclusivos: os Ionic Native.

Na prática, isso representa oferecer uma experiência muito mais completa ao usuário.

Quando usar o Ionic?

O Ionic é perfeito para projetos que precisam de velocidade no desenvolvimento, alcance multiplataforma e interfaces modernas. No entanto, para aplicações que demandam alta performance ou acesso intensivo a recursos nativos, pode ser mais vantajoso optar por um desenvolvimento nativo puro.

Conclusão

O Ionic combina simplicidade, eficiência e flexibilidade, sendo uma excelente opção para startups, desenvolvedores independentes e empresas que desejam alcançar um público amplo sem sacrificar qualidade.

Comece hoje mesmo a explorar o mundo do desenvolvimento híbrido com o Ionic e crie aplicativos que impressionem!

Se você quer mais dicas sobre desenvolvimento de aplicativos ou precisa de ajuda com o Ionic, deixe seu comentário abaixo!

Queremos ouvir você!

Deixe seu comentário e compartilhe sua opinião sobre a linguagem Solidity.

Já trabalhou com contratos inteligentes?

Tem dúvidas ou sugestões?

Vamos conversar!

Compartilhe o post com outras pessoas se ele te ajudou!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Até o próximo post. Valeu!

#Ionic #DesenvolvimentoDeApps #AppsMultiplataforma

#Tecnologia #Programação #WebDevelopment

#DesenvolvimentoHíbrido

#GiovaniDaCruz

Fonte Base: 

https://mundodevops.com/blog/framework-ionic/

https://www.devmedia.com.br/guia/ionic/38372

https://www.treinaweb.com.br/blog/o-que-e-ionic

Em Delphi e Lazarus, TList é uma classe poderosa e versátil para armazenar listas de ponteiros que podem referenciar qualquer tipo de dado. Quando usamos records com TList, obtemos uma maneira eficiente de gerenciar estruturas de dados com tipos fixos e organizados. No entanto, é essencial entender como manipular memória corretamente, já que TList não gerencia automaticamente a alocação e liberação de memória.

Neste post, você aprenderá:

• O que é TList e como funciona.
• O que são records e quando usá-los.
• Como integrar TList e records.
• Boas práticas para manipulação de memória.

O que é TList?

TList é uma classe da unidade Classes em Delphi e Lazarus que armazena ponteiros genéricos em uma lista dinâmica. Ela permite:

• Adicionar elementos dinamicamente.
• Acessar elementos diretamente pelo índice.
• Remover ou limpar elementos de forma eficiente.

Entretanto, como TList armazena ponteiros (Pointer), o programador é responsável por alocar e liberar a memória dos dados associados a esses ponteiros.

Exemplo básico de uso:

var
  Lista: TList;
begin
  Lista := TList.Create;
  try
    // Manipulação de elementos aqui...
  finally
    Lista.Free;
  end;
end;

O que são Records?

Records em Delphi e Lazarus são estruturas de dados estáticas que permitem agrupar diferentes tipos de variáveis. Eles são ideais para representar entidades simples, como coordenadas de um ponto, dados de uma pessoa ou informações de um produto.

Exemplo de definição de record:

type
  TFuncionario = record
    Nome: string;
    Idade: Integer;
    Salario: Double;
  end;

O record acima pode armazenar informações sobre um funcionário, como nome, idade e salário.

Por que usar TList com Records?

Combinar TList com records oferece flexibilidade e desempenho em situações como:

1. Gerenciamento de Dados Complexos: Permite armazenar múltiplos registros de forma dinâmica.
2. Eficiente em Memória: Os registros são mais leves do que classes, ideais para listas grandes.
3. Facilidade de Ordenação e Busca: Pode-se implementar algoritmos customizados para gerenciar os dados armazenados.

Porém, usar TList com records exige atenção especial ao gerenciamento de memória, já que records não são gerenciados automaticamente como objetos.

Integração de TList com Records

Ao armazenar records em um TList, não armazenamos o record diretamente, mas sim um ponteiro para ele. Isso ocorre porque o TList funciona exclusivamente com ponteiros.

Definição de Record com Ponteiro

type
  TFuncionario = record
    Nome: string;
    Idade: Integer;
    Salario: Double;
  end;
  PFuncionario = ^TFuncionario; // Ponteiro para o record

Criando, Adicionando e Manipulando Registros

Veja o exemplo prático e detalhado:

uses
  Classes, SysUtils;

type
  TFuncionario = record
    Nome: string;
    Idade: Integer;
    Salario: Double;
  end;
  PFuncionario = ^TFuncionario; // Ponteiro para o record

var
  ListaFuncionarios: TList;

procedure AdicionarFuncionario(const Nome: string; Idade: Integer; Salario: Double);
var
  Funcionario: PFuncionario;
begin
  New(Funcionario); // Aloca memória para o record
  Funcionario^.Nome := Nome;
  Funcionario^.Idade := Idade;
  Funcionario^.Salario := Salario;
  ListaFuncionarios.Add(Funcionario); // Adiciona o ponteiro na TList
end;

procedure ListarFuncionarios;
var
  I: Integer;
  Funcionario: PFuncionario;
begin
  WriteLn('---------------------------------------------');
  WriteLn(' Lista de Funcionários');
  WriteLn('---------------------------------------------');
  WriteLn(Format('%-20s | %-5s | %-10s', ['Nome', 'Idade', 'Salário']));
  WriteLn('---------------------------------------------');
  
  for I := 0 to ListaFuncionarios.Count - 1 do
  begin
    Funcionario := PFuncionario(ListaFuncionarios[I]);
    WriteLn(Format('%-20s | %-5d | R$ %-10.2f',
      [Funcionario^.Nome, Funcionario^.Idade, Funcionario^.Salario]));
  end;

  WriteLn('---------------------------------------------');
end;

procedure LiberarMemoria;
var
  I: Integer;
begin
  for I := 0 to ListaFuncionarios.Count - 1 do
    Dispose(PFuncionario(ListaFuncionarios[I])); // Libera memória de cada ponteiro
  ListaFuncionarios.Free; // Libera a lista
end;

begin
  // Inicializa a lista
  ListaFuncionarios := TList.Create;

  try
    // Adicionando funcionários
    AdicionarFuncionario('Ana Silva', 30, 3000.50);
    AdicionarFuncionario('Carlos Almeida', 45, 4500.75);
    AdicionarFuncionario('Maria Oliveira', 28, 2800.00);

    // Listando os funcionários
    ListarFuncionarios;

  finally
    // Liberando a memória
    LiberarMemoria;
  end;
end.

Saída no Console

Ao executar o programa, a saída será semelhante a esta:

---------------------------------------------
 Lista de Funcionários
---------------------------------------------
Nome                 | Idade | Salário    
---------------------------------------------
Ana Silva            | 30    | R$ 3000.50
Carlos Almeida       | 45    | R$ 4500.75
Maria Oliveira       | 28    | R$ 2800.00
---------------------------------------------

Boas Práticas ao Usar TList com Records

Gerenciamento de Memória
Sempre libere os ponteiros armazenados no TList antes de liberar a lista com Free. Isso evita vazamentos de memória.

Use Estruturas Modernas Sempre que Possível
Em versões mais recentes do Delphi, considere usar TList<T> (Generics), que simplifica o gerenciamento de memória ao evitar ponteiros.

Evite Misturar Dados
Certifique-se de que todos os itens armazenados na lista são do mesmo tipo, evitando erros de acesso.

Documente o Código
Por lidar com ponteiros, o código pode se tornar confuso. Adicione comentários claros para facilitar o entendimento.

Conclusão

O uso de TList com records é uma solução eficiente para gerenciar dados estruturados em Delphi e Lazarus. Embora exija cuidado com alocação e liberação de memória, oferece grande flexibilidade e desempenho.

Se você utiliza versões mais recentes do Delphi, explorar generics pode ser uma opção mais segura e moderna.

Gostou do artigo?

Deixe suas dúvidas ou compartilhe sua experiência nos comentários!

Lembre de compartilhar este post com amigos e colegas que tenham interesse no assunto!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Até o próximo post. Valeu!

#Delphi #Lazarus

#Programação #TList #Records

#DesenvolvimentoDeSoftware

#BoasPráticas #Desenvolvimento

#GiovaniDaCruz

Segundo Dr. Enéas:

O dado mais importante que separa seres humanos de todos seus irmãos e primos na escala filogenética é o conhecimento.

Só o conhecimento liberta o Homem.

Só através do conhecimento o Homem é Livre.

E em sendo livre ele pode aspirar a uma condição melhor de vida para ele e todos seus semelhantes.

Eu só consigo entender uma sociedade na qual o conhecimento seja a razão ser precípua que o governo dá para a formação do cidadão.

A minha mensagem é positiva. É que o homem tem que saber, conhecer. Em conhecendo, ele é livre.

Vídeo completo da Entrevista

Novembro de 1989, fim do período eleitoral. Entrevista do Doutor Enéas no Jô Soares Onze e Meia.

 Agora é a sua vez!

Qual é a sua opinião sobre a entrevista do Doutor Enéas?

Deixe seu comentário aqui! Vamos continuar essa conversa sobre a importância do conhecimento!

 Obrigado por acompanhar até aqui! Explore outros posts relacionados no blog e continue evoluindo suas habilidades. Tem mais conteúdos sobre diversos assuntos te esperando!

Bons estudos e até o próximo post!

#Conhecimento

#Liberdade

#Saber

#Educação

#GiovaniDaCruz

Se você está desenvolvendo aplicações em Delphi ou Lazarus e precisa acessar a versão de um executável, pode utilizar a API do Windows para isso. Saber como obter essas informações pode ser útil para depuração, manutenção ou quando você deseja exibir a versão do software para os usuários.

Por Que Obter a Versão de um Executável?

Antes de mergulharmos no código, é importante entender por que você pode precisar obter a versão de um executável:

• Manutenção e Atualização: Verificar a versão do executável pode ajudar a garantir que a versão mais recente está sendo utilizada.
• Depuração: Identificar a versão do software em uso pode facilitar a resolução de problemas específicos de versões.
• Interface do Usuário: Exibir a versão do software pode ser uma prática recomendada para aplicações que precisam informar os usuários sobre a versão instalada.

Código para Obter a Versão em Delphi

Aqui está um exemplo de como você pode obter a versão de um executável em Delphi:

uses
  Windows, SysUtils;

function GetFileVersion(const FileName: string): string;
var
  InfoSize, ValueSize: DWORD;
  Info: Pointer;
  Value: PVSFixedFileInfo;
  Version: string;
begin
  Result := '';
  InfoSize := GetFileVersionInfoSize(PChar(FileName), InfoSize);
  if InfoSize = 0 then Exit;
  
  GetMem(Info, InfoSize);
  try
    if not GetFileVersionInfo(PChar(FileName), 0, InfoSize, Info) then Exit;
    
    if VerQueryValue(Info, '\', Pointer(Value), ValueSize) then
    begin
      Version := Format('%d.%d.%d.%d',
        [HiWord(Value^.dwFileVersionMS), LoWord(Value^.dwFileVersionMS),
         HiWord(Value^.dwFileVersionLS), LoWord(Value^.dwFileVersionLS)]);
      Result := Version;
    end;
  finally
    FreeMem(Info);
  end;
end;

Código para Obter a Versão em Lazarus

O código para Lazarus é praticamente idêntico ao de Delphi, uma vez que ambos utilizam a mesma API do Windows. Portanto, você pode usar o código acima também em seus projetos Lazarus sem modificações significativas.

Exemplo de Uso

Aqui está como você pode utilizar a função GetFileVersion para obter e exibir a versão de um executável:

begin
  WriteLn(GetFileVersion('C:\Caminho\Para\Seu\Executavel.exe'));
end;

Certifique-se de substituir 'C:\Caminho\Para\Seu\Executavel.exe' pelo caminho real do seu executável. Quando você executar o código, ele exibirá a versão do arquivo especificado no console.

Considerações Finais

Obter a versão de um executável é uma tarefa simples e poderosa que pode melhorar a funcionalidade e a manutenção das suas aplicações Delphi e Lazarus. Aproveite essas informações para manter seu software atualizado e garantir que seus usuários estejam sempre informados sobre a versão em uso.

Beleza pessoal? Espero que possa ajudar.

Se você tiver alguma dúvida ou sugestão sobre este tópico, sinta-se à vontade para deixar um comentário abaixo!

Um abraço e até o próximo post. Valeu!

#Delphi

#Lazarus

#Desenvolvimento

#API

#Programação

#Tecnologia

#Desenvolvedores

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Venha aprender a usar comentários de linha única e múltiplas linhas, e veja as melhores práticas para documentar e organizar seu código. Transforme seus scripts de PowerShell em ferramentas mais claras e fáceis de manter!

Introdução

Comentários são essenciais em scripts de PowerShell para aumentar a legibilidade e facilitar a manutenção. Eles permitem que os programadores deixem notas explicativas, desativem temporariamente partes do código e documentem a funcionalidade de scripts para outros desenvolvedores ou para si mesmos no futuro. Aqui está um guia simples de como adicionar comentários aos seus scripts PowerShell (.ps1).

Tipos de Comentários em PowerShell

Existem dois tipos principais de comentários que você pode usar em PowerShell: comentários de linha única e comentários de múltiplas linhas.

Comentários de Linha Única

Para adicionar um comentário de linha única, use o caractere #. Tudo o que estiver à direita desse caractere na mesma linha será considerado um comentário e não será executado.

Exemplo:

# Este é um comentário de linha única
Write-Output "Olá, Mundo!" # Este comentário explica o comando anterior

Comentários de Múltiplas Linhas

Se você precisar comentar várias linhas de código, pode usar comentários de múltiplas linhas. Esses comentários começam com <# e terminam com #>.

Exemplo:

<#
Este é um comentário
de múltiplas linhas.
Você pode usar isso para
documentar partes maiores do código.
#>
Write-Output "Olá, Mundo!"

Boas Práticas para Comentários em PowerShell

1. Seja Claro e Conciso: Os comentários devem ser fáceis de entender. Evite explicações excessivamente detalhadas que possam confundir mais do que ajudar.
2. Comente o Porquê, Não o Como: Em muitos casos, o código em si mostra “como” algo é feito. Use os comentários para explicar “por que” algo é feito de uma certa maneira.
3. Atualize os Comentários: Certifique-se de manter seus comentários atualizados à medida que o código muda. Comentários desatualizados podem ser enganosos.
4. Use Comentários para Divisões Lógicas: Em scripts longos, use comentários para dividir o código em seções lógicas, facilitando a navegação.

Exemplo de Script Bem Comentado

# Script de backup de arquivos

# Definir diretório de origem e destino
$sourceDir = "C:\Users\Usuario\Documents"
$backupDir = "D:\Backups\Documents"

# Verificar se o diretório de backup existe
if (-Not (Test-Path -Path $backupDir)) {
    # Criar o diretório de backup se não existir
    New-Item -ItemType Directory -Path $backupDir
}

# Copiar arquivos do diretório de origem para o diretório de backup
Copy-Item -Path "$sourceDir\*" -Destination $backupDir -Recurse -Force

<#
A opção -Recurse permite copiar todos os subdiretórios e seus conteúdos.
A opção -Force permite substituir arquivos no destino, se necessário.
#>

Write-Output "Backup concluído com sucesso!"

Conclusão

Comentar seus scripts PowerShell é uma prática que melhora a legibilidade e a manutenção do código. Use comentários de linha única para explicações rápidas e comentários de múltiplas linhas para descrições mais detalhadas. Sempre mantenha seus comentários claros, atualizados e focados no “porquê” do código.

Esperamos que este guia tenha sido útil para você. Comente seus scripts regularmente para facilitar sua vida e a de outros desenvolvedores que possam trabalhar com seu código no futuro. Boas práticas de comentários são um sinal de um desenvolvedor cuidadoso e profissional.

Obs: A extensão de um arquivo do PowerShell é .ps1. Essa extensão indica que o arquivo contém um script escrito em PowerShell, que pode ser executado no Windows PowerShell ou no PowerShell Core.

Beleza pessoal? Espero que possa ajudar.

Dúvidas ou sugestões? Deixe o seu comentário!

Um abraço e até o próximo post. Valeu!

#PowerShell

#Automação

#Desenvolvimento

#Scripts

#Produtividade

#GiovaniDaCruz

Fala galera da programação, tudo beleza?

Hoje vamos desenvolver um programa simples em diversas linguagens de programação para encontrar o maior e o menor número dentre cinco fornecidos pelo usuário!

Dicas para o exercício

Utilizar variáveis adicionais para armazenar o maior e para armazenar o menor.

Comparar cada número lido com cada uma dessas variáveis adicionais.

Lembre-se de atribuir um valor inicial para as variáveis adicionais, que pode ser, por exemplo, o primeiro número lido.

O que podemos aprender neste exercício?

Este exercício em C++ nos ensina alguns conceitos importantes:

Uso de variáveis: Aprendemos como declarar e usar variáveis em C++, incluindo a atribuição de valores e a atualização dessas variáveis durante a execução do programa.

Estruturas de controle de fluxo: O uso do loop for nos permite iterar sobre um conjunto de números predefinido, enquanto as estruturas condicionais if e else if nos permitem comparar e atualizar variáveis com base em condições específicas.

Algoritmo de encontrar o maior e o menor número: Este exercício nos mostra uma maneira simples de encontrar o maior e o menor número em um conjunto de números fornecidos pelo usuário, usando variáveis adicionais para acompanhar esses valores durante a execução do programa.

Entrada e saída básicas: Aprendemos a usar cin para obter entrada do usuário e cout para exibir saída na tela.

Boas práticas de programação: O exercício também destaca a importância de usar variáveis descritivas e comentários claros para tornar o código mais compreensível e fácil de dar manutenção.

Vamos aos códigos!

Exemplo em C++

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <iostream>
using namespace std;

int main() {
    int numero, maior, menor;

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    cout << "Digite o 1º número: ";
    cin >> numero;
    maior = numero;
    menor = numero;

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for (int i = 2; i <= 5; ++i) {
        cout << "Digite o " << i << "º número: ";
        cin >> numero;

        if (numero > maior) {
            maior = numero;
        } else if (numero < menor) {
            menor = numero;
        }
    }

    // Mostra o maior e o menor número
    cout << "O maior número é: " << maior << endl;
    cout << "O menor número é: " << menor << endl;

    return 0;
}

Este programa solicita ao usuário que insira 5 números e, à medida que os números são inseridos, verifica se são maiores ou menores do que os valores atuais armazenados nas variáveis maior e menor, atualizando-as conforme necessário. No final, imprime o maior e o menor número inserido.

A estratégia utilizada no programa foi a seguinte:

1. Inicialização das variáveis: Começamos declarando três variáveis inteiras: numero, maior e menor. A variável numero será usada para ler os números fornecidos pelo usuário, enquanto maior e menor serão usadas para armazenar o maior e o menor número, respectivamente.
2. Leitura do primeiro número: O programa solicita ao usuário que insira o primeiro número e armazena esse valor nas variáveis maior e menor, pois, no início, esse número é o único e, portanto, o maior e o menor.
3. Loop para os próximos números: Utilizando um loop for, o programa lê os próximos quatro números fornecidos pelo usuário. Começando do segundo número, até o quinto, ele compara cada número com os valores armazenados em maior e menor.
4. Atualização de maior e menor: Se o número lido for maior do que o valor atual de maior, maior é atualizado com esse número. Se o número lido for menor do que o valor atual de menor, menor é atualizado com esse número.
5. Exibição do resultado: Após a leitura de todos os números, o programa exibe o maior e o menor número lido.

Essa abordagem garante que, a cada iteração do loop, os valores de maior e menor são atualizados conforme necessário, resultando nos valores corretos no final da execução do programa.

Exemplo em C

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <stdio.h>

int main() {
    int numero, maior, menor, i;

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    printf("Digite o 1º número: ");
    scanf("%d", &numero);
    maior = numero;
    menor = numero;

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for (i = 2; i <= 5; ++i) {
        printf("Digite o %dº número: ", i);
        scanf("%d", &numero);

        if (numero > maior) {
            maior = numero;
        } else if (numero < menor) {
            menor = numero;
        }
    }

    // Mostra o maior e o menor número
    printf("O maior número é: %d\n", maior);
    printf("O menor número é: %d\n", menor);

    return 0;
}

Este programa realiza exatamente as mesmas operações que o programa em C++ que escrevi anteriormente, mas utiliza a sintaxe da linguagem C. As diferenças principais incluem a troca de cout e cin por printf e scanf, respectivamente, e a remoção do namespace std. O restante da lógica permanece a mesma.

Exemplo em Pascal / Delphi / Lazarus

{

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

}
program EncontrarMaiorMenor;

var
  numero, maior, menor, i: integer;

begin
  // Lê o primeiro número e o considera tanto o maior quanto o menor
  writeln('Digite o 1º número: ');
  readln(numero);
  maior := numero;
  menor := numero;

  // Loop para ler os próximos 4 números e atualizar o maior e o menor
  for i := 2 to 5 do
  begin
    writeln('Digite o ', i, 'º número: ');
    readln(numero);

    if numero > maior then
      maior := numero
    else if numero < menor then
      menor := numero;
  end;

  // Mostra o maior e o menor número
  writeln('O maior número é: ', maior);
  writeln('O menor número é: ', menor);

end.

Este programa em Pascal faz a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em Pascal é um pouco diferente das outras linguagens, mas a lógica geral é a mesma.

Exemplo em Python

'''

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

'''
# Lê o primeiro número e o considera tanto o maior quanto o menor
numero = int(input("Digite o 1º número: "))
maior = numero
menor = numero

# Loop para ler os próximos 4 números e atualizar o maior e o menor
for i in range(2, 6):
    numero = int(input("Digite o {}º número: ".format(i)))
    
    if numero > maior:
        maior = numero
    elif numero < menor:
        menor = numero

# Mostra o maior e o menor número
print("O maior número é:", maior)
print("O menor número é:", menor)

Este programa em Python realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em Python é mais simples e legível, o que torna o código mais fácil de entender.

Exemplo em C# / C Sharp

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
using System;

class Program
{
    static void Main(string[] args)
    {
        int numero, maior, menor;

        // Lê o primeiro número e o considera tanto o maior quanto o menor
        Console.Write("Digite o 1º número: ");
        numero = Convert.ToInt32(Console.ReadLine());
        maior = numero;
        menor = numero;

        // Loop para ler os próximos 4 números e atualizar o maior e o menor
        for (int i = 2; i <= 5; i++)
        {
            Console.Write("Digite o {0}º número: ", i);
            numero = Convert.ToInt32(Console.ReadLine());

            if (numero > maior)
            {
                maior = numero;
            }
            else if (numero < menor)
            {
                menor = numero;
            }
        }

        // Mostra o maior e o menor número
        Console.WriteLine("O maior número é: {0}", maior);
        Console.WriteLine("O menor número é: {0}", menor);
    }
}

Este programa em C# realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em C# é semelhante à de outras linguagens como Java e C++, mas com algumas diferenças na maneira como a entrada e saída são tratadas.

Exemplo em Java

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numero, maior, menor;

        // Lê o primeiro número e o considera tanto o maior quanto o menor
        System.out.print("Digite o 1º número: ");
        numero = scanner.nextInt();
        maior = numero;
        menor = numero;

        // Loop para ler os próximos 4 números e atualizar o maior e o menor
        for (int i = 2; i <= 5; i++) {
            System.out.print("Digite o " + i + "º número: ");
            numero = scanner.nextInt();

            if (numero > maior) {
                maior = numero;
            } else if (numero < menor) {
                menor = numero;
            }
        }

        // Mostra o maior e o menor número
        System.out.println("O maior número é: " + maior);
        System.out.println("O menor número é: " + menor);

        scanner.close();
    }
}

Este programa em Java realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. Java possui uma sintaxe semelhante à de C#, mas com algumas diferenças na manipulação de entrada e saída e na estrutura do loop.

Exemplo em Rust

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
use std::io;

fn main() {
    let mut maior;
    let mut menor;

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    println!("Digite o 1º número:");
    let mut numero = String::new();
    io::stdin().read_line(&mut numero).expect("Falha ao ler a entrada");
    let numero: i32 = numero.trim().parse().expect("Entrada inválida");
    maior = numero;
    menor = numero;

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for i in 2..=5 {
        println!("Digite o {}º número:", i);
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Falha ao ler a entrada");
        let numero: i32 = input.trim().parse().expect("Entrada inválida");

        if numero > maior {
            maior = numero;
        } else if numero < menor {
            menor = numero;
        }
    }

    // Mostra o maior e o menor número
    println!("O maior número é: {}", maior);
    println!("O menor número é: {}", menor);
}

Este programa em Rust realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. Rust possui uma sintaxe única e segura, com um sistema de tipos poderoso que garante a segurança do programa em tempo de compilação.

Exemplo em Go

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
package main

import (
    "fmt"
)

func main() {
    var numero, maior, menor int

    // Lê o primeiro número e o considera tanto o maior quanto o menor
    fmt.Print("Digite o 1º número: ")
    fmt.Scanln(&numero)
    maior = numero
    menor = numero

    // Loop para ler os próximos 4 números e atualizar o maior e o menor
    for i := 2; i <= 5; i++ {
        fmt.Printf("Digite o %dº número: ", i)
        fmt.Scanln(&numero)

        if numero > maior {
            maior = numero
        } else if numero < menor {
            menor = numero
        }
    }

    // Mostra o maior e o menor número
    fmt.Println("O maior número é:", maior)
    fmt.Println("O menor número é:", menor)
}

Este programa em Go realiza a mesma tarefa que os programas anteriores: lê 5 números do usuário, encontra o maior e o menor entre eles e os exibe na tela. A sintaxe em Go é diferente de outras linguagens, mas é bastante simples e intuitiva.

Conclusão

O exercício de desenvolver um programa para encontrar o maior e o menor número entre cinco fornecidos pelo usuário foi uma ótima oportunidade para explorar e comparar diferentes linguagens de programação. Ao escrever o mesmo algoritmo em linguagens como C++, C, Pascal, Python, C#, Java, Rust e Go, pude perceber as nuances e diferenças entre essas linguagens, além de fortalecer meu entendimento sobre os conceitos fundamentais de programação.

Este exercício demonstra a versatilidade e a diversidade de opções disponíveis para os desenvolvedores ao escolherem uma linguagem para resolver um determinado problema. Cada linguagem tem sua própria sintaxe, estilo e conjunto de recursos, mas todas compartilham a capacidade de expressar soluções para problemas complexos de maneira clara e eficiente.

Além disso, essa experiência reforçou a importância do pensamento algorítmico e da lógica de programação, habilidades essenciais que transcendem a linguagem específica utilizada. Independentemente da linguagem escolhida, a capacidade de quebrar um problema em etapas menores, identificar padrões e desenvolver soluções eficazes é fundamental para o sucesso na programação.

Em resumo, este exercício foi uma oportunidade valiosa para aprimorar minhas habilidades de programação, expandir meu conhecimento sobre diferentes linguagens e reforçar princípios fundamentais de desenvolvimento de software.

Beleza pessoal? Espero que tenham gostado.

Dúvidas ou sugestões? Deixe o seu comentário!

Um abraço e até o próximo post. Valeu!

#Programação

#Desenvolvimento

#Aprendizado

#Coding

#Tech

#LinguagensDeProgramação

#GiovaniDaCruz