Tutoriais de programação - página 4
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
FUNÇÕES C++ (2020) - O que é recursão? Aprenda funções recursivas!
FUNÇÕES C++ (2020) - O que é recursão? Aprenda funções recursivas! TUTORIAL DE PROGRAMAÇÃO
A recursão é um processo no qual uma função invoca a si mesma e a função correspondente é chamada de função recursiva.
A recursão é um daqueles tópicos de programação que muitas vezes confundem os alunos e, neste vídeo, estou explicando como funciona a recursão e também comparando diferentes soluções para o mesmo problema (usando loops e usando recursão).
Como construir um aplicativo ATM em C++? (Para iniciantes)
Como construir um aplicativo ATM em C++? (Para iniciantes) - TUTORIAL DE PROGRAMAÇÃO (2020)
Bem-vindo ao meu canal! Sou Saldina e crio vídeos relacionados à programação. Se você estiver interessado nisso, considere se inscrever no meu canal e dar um joinha neste vídeo.
Neste vídeo, mostrarei como criar um aplicativo de caixa eletrônico. Primeiro, vamos planejar as funcionalidades do aplicativo. Vamos precisar do seguinte:
Agora, vamos começar implementando a função "Mostrar menu". Vamos criar uma função chamada "showMenu" que exibe as opções do menu para o usuário.
Após definir o menu, invocaremos a função "showMenu" para exibi-lo. Em seguida, permitiremos que o usuário escolha uma opção.
Para lidar com a escolha do usuário, usaremos um switch case. Para cada caso, realizaremos a ação correspondente. No caso da opção 1, mostraremos o saldo. No caso da opção 2, solicitaremos o valor do depósito e atualizaremos o saldo de acordo. No caso da opção 3, solicitaremos o valor do saque e verificaremos se é válido antes de atualizar o saldo. Finalmente, adicionaremos uma opção 4 para sair do programa.
Para permitir que o usuário interaja repetidamente com o menu, usaremos um loop do-while. O loop continuará até que o usuário selecione a opção 4.
Sinta-se à vontade para aprimorar o programa adicionando mais recursos, como transferência de dinheiro entre contas. Compartilhe seu código nos comentários e eu o revisarei. Não se esqueça de curtir, se inscrever e ativar o sininho. Vejo você no próximo vídeo!
FUNÇÕES C++ (2020) - O que são funções e modelos genéricos? TUTORIAL DE PROGRAMAÇÃO
FUNÇÕES C++ (2020) - O que são funções e modelos genéricos? TUTORIAL DE PROGRAMAÇÃO
Olá a todos, sejam bem vindos ao meu canal! Meu nome é Saldina e crio vídeos relacionados a programação. Se você estiver interessado em programação, inscreva-se no meu canal e dê um joinha neste vídeo. Seu apoio me ajuda a alcançar mais pessoas e espalhar conhecimento de programação.
Neste vídeo, quero falar sobre genéricos e modelos em C++. Os genéricos nos permitem usar o mesmo código com diferentes tipos de dados. Isso significa que podemos ter uma única função que trabalha com diferentes tipos de dados.
Vamos dar um exemplo para entender esse conceito. Suponha que queremos criar uma função que troca os valores de duas variáveis. Inicialmente, criamos a função para trocar duas variáveis inteiras, mas podemos estendê-la para trabalhar também com outros tipos de dados.
Para criar uma função genérica, usamos modelos em C++. Definimos um tipo de modelo usando a palavra-chave "template" seguida do nome do tipo, geralmente referido como "T." Dentro da função, substituímos o tipo de dado específico por "T". Isso torna a função genérica e capaz de trabalhar com diferentes tipos de dados.
Não precisamos mais criar funções separadas para cada tipo de dados. A função de modelo pode ser usada com qualquer tipo de dados que suporte a lógica de troca.
Para testar a função, criamos variáveis do tipo desejado e as passamos para a função swap genérica. O mecanismo de inferência de tipo em C++ nos permite omitir a especificação do tipo explicitamente.
Ao usar genéricos e modelos, podemos eliminar a duplicação de código e escrever um código mais flexível e reutilizável. Essa abordagem nos permite lidar com diferentes tipos de dados sem criar funções separadas para cada tipo.
Espero que este vídeo tenha ajudado você a entender o conceito de genéricos e modelos em C++. Se você achou útil, por favor, inscreva-se no meu canal e dê um joinha neste vídeo. Seu apoio é muito apreciado. Obrigado por assistir, e vejo você no meu próximo vídeo. Adeus!
Expressões lambda em C++ moderno (tutorial detalhado passo a passo)
Expressões lambda em C++ moderno (tutorial detalhado passo a passo)
Bem vindos ao meu canal, pessoal! Neste vídeo, discutirei um tópico crucial no C++ moderno, que são as expressões lambda, também conhecidas como lambdas. Você provavelmente já ouviu falar de lambdas antes, e hoje vou explicar tudo o que você precisa saber para começar a escrever um código mais rápido e limpo usando lambdas no C++ moderno.
Abordarei os conceitos mais importantes, mas lembre-se de que lambdas é um tópico amplo com muito a aprender. Se você quiser exemplos e práticas adicionais, fornecerei um livro gratuito na descrição que se concentra em lambdas no C++ moderno. Sinta-se à vontade para conferir.
As expressões lambda foram introduzidas no C++ moderno e estão disponíveis no C++11 e superior. Seu principal objetivo é permitir que você escreva funções anônimas embutidas. Então, o que são funções anônimas embutidas? As funções regulares permitem que você escreva um código uma vez e o reutilize invocando a função sempre que precisar desse código novamente, eliminando a necessidade de código redundante. Por outro lado, uma função inline é uma função pequena e simples que não deve ser reutilizada como funções regulares. Eles geralmente são usados para pequenos trechos de código que não requerem um nome e não valem o esforço de criar uma função separada. É aqui que os lambdas se destacam, pois fornecem uma maneira de escrever funções sem nome que são concisas, fáceis de ler, rápidas de executar e mantêm tudo em um só lugar.
Agora, vamos mergulhar no código. Para esta demonstração, usarei o C++Builder, o IDE ideal para criar aplicativos de interface de usuário C++. Se você estiver interessado em aprender sobre os aplicativos de interface do usuário C++, fornecerei um link na descrição onde você pode baixar o C++Builder. Para começar, vamos criar um aplicativo de console. Clique em “Arquivo”, depois em “Novo outro” e selecione “Aplicativo de console”. Certifique-se de que C++ esteja selecionado e clique em "OK". Aqui está o nosso código inicial. Vamos fazer algumas adições a ele.
Primeiro, adicionarei um comando de "pausa do sistema" para manter a janela do console aberta após a execução do código. Em seguida, incluirei a biblioteca "iostream" para operações de entrada/saída. Agora, nosso código está pronto para ser executado e, se executarmos o programa, veremos a mensagem "Hello, World!" mensagem no console. Agora, vamos dar uma olhada na estrutura de uma expressão lambda. Vou remover o código anterior e começaremos com um exemplo simples. Para criar um lambda, usamos a seguinte sintaxe: colchetes angulares (cláusula de captura), parênteses (parâmetros) e colchetes (definição de função).
Dentro da cláusula capture, podemos especificar as variáveis do escopo envolvente que queremos usar dentro do lambda. Por enquanto, vamos deixar a cláusula de captura vazia e focar nos parâmetros. Podemos definir os parâmetros dentro dos parênteses. Neste exemplo, usarei um único parâmetro, "p". Por fim, definimos o corpo da função lambda dentro das chaves. Agora, vamos criar um exemplo em que encontraremos um problema e o resolveremos usando lambdas. Como trabalharemos com um vetor, precisamos incluir a biblioteca "vetor". Vou criar um vetor de inteiros chamado "v" e inicializá-lo com alguns valores. Em seguida, apresentarei uma função útil da biblioteca "algoritmo" chamada "for_each". Essa função itera sobre elementos em um intervalo, como nosso vetor, e aplica uma determinada função a cada elemento.
Dentro da função "for_each", especificaremos o intervalo usando "v.begin()" e "v.end()". Agora, vamos definir o que queremos fazer com cada elemento. Inicialmente, mostrarei um problema com o código e, em seguida, apresentarei lambdas como solução. Adicionei uma estrutura com um operador sobrecarregado que imprime o parâmetro. Esperamos que a função "for_each" imprima todos os elementos no vetor. Se executarmos o código, veremos que não funciona como esperado. Imprime apenas o último elemento. Isso ocorre porque o operador sobrecarregado é passado por valor e copia o parâmetro para cada chamada, resultando em saída incorreta. Para corrigir isso, podemos substituir o operador sobrecarregado por uma expressão lambda. Vou copiar a sintaxe da expressão lambda que discutimos anteriormente e colá-la dentro da função "for_each". Agora, vamos executar o código novamente.
Como você pode ver, a expressão lambda funciona perfeitamente e imprime todos os elementos do vetor. A expressão lambda simplifica o código e melhora a legibilidade. Ele também garante que o parâmetro correto seja passado para cada chamada, evitando o problema que encontramos anteriormente. Agora, vamos explorar outro recurso útil dos lambdas, que é a capacidade de capturar variáveis do escopo delimitador. Esse recurso permite que lambdas acessem variáveis e as usem dentro do lambda. No entanto, por padrão, os lambdas capturam variáveis por valor, o que significa que eles criam uma cópia da variável.
Em nosso próximo exemplo, criarei uma variável chamada "multiplicador" e a definirei como 2. Dentro do lambda, usarei essa variável para multiplicar cada elemento do vetor. Desta vez, usarei um loop for baseado em intervalo em vez da função "for_each" para fins de demonstração. Se executarmos o código, veremos que os elementos do vetor são multiplicados por 2, graças à variável capturada. No entanto, há uma limitação na captura de variáveis por valor. Não podemos modificar a variável capturada dentro do lambda.
Para ultrapassar esta limitação, podemos capturar a variável por referência, permitindo-nos modificar o seu valor. Demonstrarei isso adicionando uma operação de incremento à expressão lambda. Agora, se executarmos o código, veremos que os elementos no vetor são multiplicados por 2 e depois incrementados por 1. Capturar variáveis do escopo envolvente fornece flexibilidade e permite que os lambdas trabalhem com dados externos sem problemas. É importante ter em mente que a captura de variáveis por referência pode ter implicações, como gerenciamento de tempo de vida e possíveis corridas de dados. Portanto, tenha cuidado ao usar esse recurso e certifique-se de que a variável capturada permaneça válida durante a execução do lambda.
Para resumir, as expressões lambda são ferramentas poderosas no C++ moderno para escrever código conciso e legível. Eles permitem que você crie funções anônimas embutidas, reduzindo a necessidade de funções separadas para pequenos trechos de código. Lambdas também podem acessar variáveis de seu escopo envolvente, fornecendo flexibilidade e aprimorando a reutilização de código.
Espero que você tenha achado este vídeo útil para entender as expressões lambda no C++ moderno. Se você tiver alguma dúvida, sinta-se à vontade para perguntar nos comentários abaixo. Não se esqueça de curtir este vídeo e se inscrever no meu canal para mais tutoriais de C++. Obrigado por assistir e feliz codificação!
Dicas e truques do Visual Studio para profissionais - Tutorial do Visual Studio
Dicas e truques do Visual Studio para profissionais - Tutorial do Visual Studio
Olá pessoal! Meu nome é Leslie Richardson e trabalho como gerente de programa na equipe de Depuração e Diagnóstico do Visual Studio. Neste vídeo, estou animado para discutir um novo recurso no Visual Studio 2019 chamado recurso de pesquisa para Autos, Locals e Watch windows. Esse recurso foi projetado para aprimorar muito sua experiência de depuração e economizar um tempo valioso, tornando-o mais produtivo.
Para demonstrar esse recurso, vamos considerar um cenário em que tenho um aplicativo .NET Core aberto no Visual Studio 2019. Nesse aplicativo, tenho uma lista que contém vários objetos de receita. O desafio que enfrento é localizar receitas específicas dentro dessa lista, o que pode ser bastante tedioso, especialmente quando a lista contém 61 objetos. Expandir manualmente cada objeto, encontrar a propriedade do título e verificar se ela corresponde aos meus critérios de pesquisa, como "salada", é uma tarefa demorada.
Para simplificar esse processo, utilizarei um recurso chamado "Exibição do depurador". Esse recurso me permite personalizar como os objetos são exibidos em várias janelas do depurador, incluindo Autos, Locals e Watch windows. Ao adicionar o atributo "Debugger Display" à definição de classe dos meus objetos, posso especificar qual propriedade deve ser mostrada na coluna de valor dessas janelas. Neste caso, quero visualizar cada receita por seu título, então defino o atributo "Debugger Display" para exibir a propriedade do título da receita.
Agora, ao expandir novamente a lista de receitas, consigo ver imediatamente o título de cada objeto, facilitando muito a localização das receitas desejadas sem precisar expandir cada uma individualmente. Esta é uma melhoria significativa, mas com 61 itens, ainda pode levar algum tempo para encontrar as receitas específicas nas quais estou interessado. É aqui que o recurso de pesquisa da janela do relógio é útil.
Em vez de rolar manualmente ou expandir a lista, posso simplesmente usar a funcionalidade de pesquisa fornecida. Eu digito meu termo de pesquisa, como "salada", e aperto enter. O Visual Studio me leva imediatamente à primeira ocorrência da palavra-chave, economizando muito tempo e esforço. Também posso utilizar o botão "Find Next" para navegar por outras correspondências encontradas pelo Visual Studio. Para navegar para frente e para trás na lista de correspondências, posso ajustar o parâmetro da etapa de pesquisa, que determina a profundidade da pesquisa.
Além do recurso de pesquisa, também quero mencionar que o recurso Exibição do depurador está disponível para usuários de código gerenciado, como aqueles que usam C#, F# ou Visual Basic. Para usuários C++, há um recurso equivalente chamado NATVIS disponível. Com o NATVIS, você precisa criar um arquivo XML separado onde possa definir as propriedades a serem exibidas nas janelas do depurador.
Espero que esta explicação tenha sido útil. Obrigado por assistir!
Agora, vamos explorar como podemos tornar a interface do Visual Studio mais organizada e melhorar seu desempenho. Quando abrimos soluções no Visual Studio, ele lembra o estado dos documentos, posições de rolagem e seções expandidas/recolhidas no Solution Explorer desde a última vez que o usamos. Embora isso possa ser útil, também consome ciclos de CPU e nem sempre é desejável. Para começar do zero e melhorar o desempenho, podemos alterar algumas configurações.
No menu Ferramentas > Opções, na seção Projetos e Soluções, há duas configurações a serem consideradas. A opção "Reabrir documentos no carregamento da solução" lembra os documentos abertos anteriormente e a opção "Restaurar o estado da hierarquia do projeto do explorador de soluções no carregamento da solução" lembra o estado expandido/recolhido do Gerenciador de Soluções. Ao desmarcar essas opções, o Visual Studio não restaurará o estado anterior ao abrir uma solução. Em vez disso, ele começará do zero, sem nenhum documento aberto ou seções expandidas no Solution Explorer. Isso pode ajudar a melhorar o desempenho e fornecer um novo começo para cada solução.
Ao trabalhar com Git no Visual Studio, existem vários recursos que podem melhorar sua produtividade e colaboração. A janela Git Changes fornece uma visão abrangente do seu repositório Git e permite que você prepare, confirme e envie alterações diretamente de dentro do Visual Studio. Você pode acessar esta janela indo em View > Git Changes. Além disso, o Visual Studio fornece uma ferramenta interna Git diff que destaca as diferenças entre diferentes versões do seu código. Você pode acessar esse recurso clicando com o botão direito do mouse em um arquivo no Solution Explorer e selecionando "Comparar com não modificado" ou "Comparar com o mais recente".
Outro recurso útil no Visual Studio é a capacidade de refatorar o código. A refatoração ajuda a melhorar a estrutura e a legibilidade do seu código sem alterar seu comportamento. O Visual Studio fornece uma variedade de opções de refatoração, como renomear variáveis ou métodos, extrair código em métodos ou classes separados e reorganizar blocos de código. Para acessar essas opções de refatoração, clique com o botão direito do mouse no código que deseja refatorar e selecione "Refatorar" no menu de contexto. Você também pode usar atalhos de teclado para operações comuns de refatoração, como Ctrl + R, Ctrl + R para renomear um símbolo.
Para aprimorar ainda mais sua experiência de codificação, você pode aproveitar os trechos de código no Visual Studio. Trechos de código são modelos de código predefinidos que podem ser inseridos rapidamente em seu código digitando um atalho e pressionando a tecla Tab. O Visual Studio fornece uma ampla variedade de trechos de código internos para diferentes linguagens de programação e estruturas. Você também pode criar seus próprios trechos de código personalizados para automatizar tarefas de codificação repetitivas. Para acessar e gerenciar trechos de código, vá para Ferramentas > Gerenciador de trechos de código.
A depuração é uma parte essencial do processo de desenvolvimento e o Visual Studio oferece recursos avançados de depuração. Você pode definir pontos de interrupção em seu código para pausar a execução e inspecionar o estado de variáveis e objetos. Durante a depuração, você pode usar a janela Watch para monitorar os valores de variáveis ou expressões específicas. A janela Immediate permite executar código e avaliar expressões durante a depuração. Você também pode aproveitar os pontos de interrupção condicionais, que são acionados apenas quando uma condição específica é atendida, e os pontos de rastreamento, que imprimem mensagens na janela Saída sem pausar o depurador.
O Visual Studio também oferece suporte a testes de unidade, que são cruciais para garantir a qualidade e a exatidão do seu código. Você pode criar testes de unidade usando várias estruturas de teste, como MSTest, NUnit ou xUnit. O Visual Studio fornece uma janela Test Explorer que exibe todos os testes disponíveis em sua solução e permite executá-los ou depurá-los individualmente ou em grupos. Você pode usar atributos para definir métodos de teste e asserções para verificar os resultados esperados. O Visual Studio também oferece análise de cobertura de código, que mostra quanto do seu código é coberto por testes de unidade.
Ao trabalhar com grandes projetos ou soluções, pode ser difícil navegar e entender a base de código. O Visual Studio fornece vários recursos para auxiliar na navegação e compreensão do código. O Solution Explorer permite que você explore a estrutura de sua solução e navegue rapidamente para arquivos ou classes específicas. Você também pode usar o recurso Navegar para (Ctrl + ,) para pesquisar símbolos, arquivos ou tipos em sua solução. O recurso CodeLens exibe informações adicionais sobre seu código, como referências, alterações e cobertura de teste, diretamente no editor.
Para desenvolvimento da Web, o Visual Studio oferece excelente suporte para tecnologias populares da Web, como HTML, CSS e JavaScript. O editor HTML fornece recursos como IntelliSense, formatação de código e a capacidade de visualizar suas páginas HTML diretamente no editor. O editor CSS oferece recursos semelhantes, incluindo seletores de cores, IntelliSense para propriedades CSS e visualização ao vivo de alterações CSS. O Visual Studio também dá suporte à depuração de JavaScript, permitindo que você defina pontos de interrupção, inspecione variáveis e percorra seu código para identificar e corrigir problemas.
O Visual Studio tem um vasto ecossistema de extensões e plug-ins que podem aprimorar sua experiência de desenvolvimento. Essas extensões fornecem funcionalidade adicional, suporte a idiomas e ferramentas para estruturas ou plataformas específicas. Você pode navegar e instalar extensões diretamente do Visual Studio acessando Extensões > Gerenciar extensões. Algumas extensões populares incluem o ReSharper, que oferece análise avançada de código e ferramentas de refatoração, e o Visual Studio Code, que fornece um editor de código leve e multiplataforma.
Ao trabalhar em projetos colaborativos, o Visual Studio oferece integração com plataformas de colaboração como Azure DevOps e GitHub. Você pode conectar facilmente seu projeto do Visual Studio a um repositório Git remoto e executar operações comuns do Git, como push, pull e alterações de mesclagem. O Visual Studio também fornece ferramentas para revisões de código, rastreamento de itens de trabalho e integração contínua e fluxos de trabalho de implantação.
O Visual Studio oferece suporte a uma ampla variedade de linguagens e estruturas de programação, incluindo .NET, C++, Python, JavaScript e muito mais. Ele fornece recursos específicos de idioma, como IntelliSense, trechos de código e recursos de depuração personalizados para cada idioma. Você pode instalar extensões e SDKs específicos de linguagem para aprimorar ainda mais a experiência de desenvolvimento de suas linguagens de programação preferidas.
Para otimização de desempenho e solução de problemas, o Visual Studio oferece ferramentas de criação de perfil que ajudam a identificar gargalos e vazamentos de memória em seus aplicativos. O Performance Profiler permite analisar o desempenho do seu código e identificar áreas que podem ser otimizadas. O Memory Profiler ajuda a detectar e diagnosticar problemas relacionados à memória em seus aplicativos. Essas ferramentas de criação de perfil fornecem informações e relatórios detalhados para ajudá-lo a otimizar seu código e melhorar o desempenho do aplicativo.
O Visual Studio também fornece suporte para desenvolvimento de aplicativos móveis para plataformas como Android e iOS. Você pode criar aplicativos móveis de plataforma cruzada usando estruturas como Xamarin ou React Native. O Visual Studio oferece ferramentas para projetar interfaces de usuário, depurar aplicativos móveis e implantá-los em emuladores ou dispositivos físicos. Você também pode aproveitar os serviços de nuvem, como aplicativos móveis do Azure, para integração e armazenamento de back-end.
Além dos aplicativos tradicionais da área de trabalho e da Web, o Visual Studio dá suporte ao desenvolvimento de aplicativos de Internet das Coisas (IoT). Você pode criar aplicativos para dispositivos como Raspberry Pi, Arduino e outros dispositivos IoT usando o Visual Studio. As ferramentas de desenvolvimento do Visual Studio IoT fornecem modelos de projeto, suporte de depuração e opções de implantação para cenários de IoT.
O Visual Studio também oferece recursos de desenvolvimento em nuvem com integrações para plataformas de nuvem populares como o Azure. Você pode criar, gerenciar e implantar recursos de nuvem diretamente no Visual Studio. Ele fornece ferramentas para criar e implantar aplicativos em nuvem, integrando-se com serviços em nuvem e monitorando seus recursos em nuvem.
Esses são apenas alguns dos muitos recursos e capacidades que o Visual Studio oferece aos desenvolvedores. É um IDE poderoso e versátil que pode atender a uma ampla gama de necessidades e fluxos de trabalho de desenvolvimento. Esteja você trabalhando em pequenos projetos ou grandes soluções corporativas, o Visual Studio fornece as ferramentas e os recursos para simplificar seu processo de desenvolvimento e aumentar sua produtividade.
Código EA completo para MetaTrader 5 em 20 minutos!
Código EA completo para MetaTrader 5 em 20 minutos!
Hoje, estamos animados para começar a gravar nosso primeiro EA (Expert Advisor) para a plataforma de negociação MetaTrader. Este EA foi projetado para ser um sistema de negociação para o MetaTrader e, em nosso vídeo, também faremos um rápido backtest para avaliar seu desempenho.
Para começar, lançamos a plataforma MetaTrader e acessamos o MetaEditor clicando em "Ferramentas" e selecionando "MetaQuotes Language Editor" no menu suspenso. O MetaEditor é onde criamos nossos consultores especializados, bem como scripts e indicadores para o MetaTrader.
Para criar um novo consultor especialista, clicamos no botão "Novo" no canto superior esquerdo do MetaEditor. No assistente que aparece, selecionamos a primeira opção e clicamos em "Avançar". Podemos então dar um nome ao nosso EA, como "Primeiro EA" e clicar em "Avançar" novamente. Ignoramos a seleção de opções adicionais e continuamos clicando em "Concluir".
Agora temos o código inicial para o nosso EA. Para começar, limpamos o código removendo comentários desnecessários, como os comentários cinzas que não fornecem nenhuma funcionalidade ao próprio código. Excluímos as cinco primeiras linhas e algumas outras linhas desnecessárias, conforme nossa preferência.
Antes de começarmos a codificar, vamos considerar o que queremos que nosso EA faça. Para este vídeo, nosso objetivo é fazer com que o EA abra uma negociação de compra em um horário específico e feche-a em outra hora predeterminada do dia. Para conseguir isso, precisamos de duas variáveis de entrada: uma para o tempo de abertura e outra para o tempo de fechamento.
Voltando ao MetaEditor, declaramos essas duas variáveis de entrada em uma nova seção chamada "Variáveis". Usamos a palavra-chave "input" para especificar que essas variáveis podem ser alteradas de fora do código. Definimos seus tipos como inteiros, pois queremos inserir valores de hora específicos. Por exemplo, podemos nomear as variáveis "openHour" e "closeHour".
Após declarar as variáveis, compilamos o código para garantir que não haja erros. Se tudo estiver correto, podemos ver que não há mensagens de erro na caixa de ferramentas.
Em seguida, voltamos para a plataforma MetaTrader e arrastamos nosso EA para qualquer gráfico. Podemos ver o nome, a versão e o link do EA no navegador em "Expert Advisors". Ao expandir o EA, podemos acessar as variáveis de entrada e alterar seus valores sem modificar o código.
Agora, vamos passar para a função "OnTick", que é chamada toda vez que o preço muda. Queremos verificar se atingimos o horário de abertura especificado pelo usuário. Para fazer isso, precisamos recuperar a hora atual do símbolo e do servidor. Criamos uma variável chamada "time" do tipo "datetime" e utilizamos a função "TimeCurrent" para atribuir a ela a hora atual.
Com o horário atual armazenado em nossa variável "tempo", podemos agora verificar se ele corresponde ao horário de abertura. Usamos uma instrução "if" para comparar a variável "openHour" com o componente de hora do horário atual ("time.hour"). Se a condição for verdadeira, entramos no bloco "if".
Dentro do bloco "if", abrimos uma posição usando a função "OrderSend". Especificamos o símbolo, a direção da negociação (compra), o tamanho do lote (1 lote) e o preço de venda como parâmetros. Além disso, definimos os valores de stop loss e take profit de acordo com nossas preferências.
Depois de compilar o código e executar um backtest usando o testador de estratégia MetaTrader, observamos que o EA abre uma posição no horário de abertura especificado. No entanto, notamos que várias posições são abertas devido a movimentos de preços subsequentes, acionando a função "OnTick" novamente.
Para evitar que várias posições sejam abertas, introduzimos uma variável booleana chamada "isTradeOpen" para rastrear se uma negociação já está aberta. Inicialmente, definimos o valor de "isTradeOpen" como falso. Antes de abrir uma nova posição, verificamos se "isTradeOpen" é falso. Se for, abrimos a posição e definimos o valor de "isTradeOpen" como verdadeiro. Dessa forma, mesmo que a função "OnTick" seja acionada várias vezes, ela só abrirá uma nova posição se ainda não houver uma negociação aberta.
Depois de implementar essa lógica, compilamos o código novamente e executamos um backtest. Desta vez, observamos que o EA abre uma posição no horário de abertura especificado e não abre nenhuma posição adicional até que a anterior seja fechada.
Passando para o fechamento da negociação no horário de fechamento especificado, precisamos introduzir outra verificação na função "OnTick". Depois de abrir a posição, comparamos o horário atual com o horário de fechamento especificado pelo usuário. Se forem iguais, inserimos um bloco "se".
Dentro do bloco "if", fechamos a negociação usando a função "OrderClose". Fornecemos o número do ticket da posição a fechar, bem como o tamanho do lote e o preço da oferta como parâmetros. Além disso, podemos definir parâmetros adicionais, como stop loss e valores de lucro, se desejado.
Compilamos o código novamente e executamos um backtest para verificar se a negociação foi fechada no horário de fechamento especificado. Durante o backtest, podemos verificar o histórico de negociação para garantir que as posições sejam abertas e fechadas de acordo com os horários especificados.
Criamos com sucesso nosso primeiro EA para a plataforma de negociação MetaTrader. O EA é projetado para abrir uma negociação de compra em um horário de abertura específico e fechá-lo em um horário de fechamento predeterminado. Implementamos variáveis de entrada para permitir a personalização dos horários de abertura e fechamento sem modificar o código. Ao introduzir verificações e variáveis, garantimos que apenas uma negociação seja aberta por vez e que seja fechada no horário de fechamento especificado.
Programação mql5 de cruzamento de média móvel EA
Programação mql5 de cruzamento de média móvel EA
Olá, aqui é Toby, e no vídeo de hoje, mostrarei como codificar um consultor especialista em crossover de média móvel simples para MetaTrader 5. Vamos começar.
Primeiro, vamos definir o que queremos que o consultor especialista faça. Queremos que o EA abra uma posição de compra quando a média móvel rápida (linha azul) cruza acima da média móvel lenta (linha vermelha) e abra uma posição de venda quando a média móvel rápida cruza abaixo da média móvel lenta. Também adicionaremos um stop loss e take profit ao EA, bem como variáveis de entrada para os períodos das médias móveis.
Para começar a codificar, abra o MetaEditor no MetaTrader 5. Crie um novo consultor especialista usando o modelo e nomeie-o como "Moving Average". Limpe o código removendo linhas e comentários desnecessários. Em seguida, adicione variáveis de entrada para os períodos das médias móveis rápidas e lentas. Defina valores padrão para essas variáveis e exiba-os na guia de entrada das configurações do EA.
Verifique a entrada do usuário na função OnInit para garantir que valores válidos sejam inseridos. Se a entrada for inválida (zero ou negativa), exiba uma mensagem de alerta e interrompa o EA. Crie alças para as médias móveis rápidas e lentas usando a função ma. Defina o símbolo, o período e as variáveis de entrada para cada média móvel. Verifique se a criação de identificadores foi bem-sucedida. Caso contrário, exiba uma mensagem de alerta e interrompa o EA. Crie variáveis globais para armazenar os valores do indicador. Use matrizes dinâmicas para os buffers rápidos e lentos. Na função OnTick, copie os últimos valores do indicador para os buffers e verifique se há dados suficientes disponíveis. Caso contrário, retorne e exiba uma mensagem de alerta.
Imprima os valores dos indicadores na tela para verificar se tudo está funcionando corretamente. Use a função Comentário para exibir os valores das médias móveis rápidas e lentas.
No testador de estratégia, teste o EA para verificar se os valores do indicador são exibidos corretamente. Agora, podemos verificar se há um cruzamento das médias móveis. Se a média móvel rápida estiver abaixo da média móvel lenta na barra 1 e acima da média móvel lenta na barra 0, temos um cruzamento. Abra uma posição de compra neste caso.
Para abrir posições, use a classe CTrade. Defina uma variável de negociação e prossiga com as ações necessárias. Compile o código e teste o EA no testador de estratégia para verificar se a condição de cruzamento está funcionando corretamente e as posições são abertas de acordo.
Isso é tudo para codificar o consultor especialista em cruzamento de média móvel no MetaTrader 5. E então podemos usar a função trade.Buy para abrir uma posição de compra. Especificamos o volume da posição, que pode ser um valor fixo ou baseado na sua estratégia de gerenciamento de risco. Por enquanto, vamos usar um volume fixo de 0,1 lotes. Agora precisamos adicionar uma condição para verificar uma posição de venda. Se a média móvel rápida estiver acima da média móvel lenta para a barra 1 e abaixo para a barra atual, temos um cruzamento na direção oposta. Neste caso, queremos abrir uma posição de venda. Podemos usar a função trade.Sell para fazer isso.
Finalmente, podemos adicionar um stop loss e obter lucro em nossas posições. Usaremos as funções trade.SetStopLoss e trade.SetTakeProfit. Vamos definir um stop loss de 100 pips e obter lucro de 200 pips para este exemplo. Agora temos um código completo para nosso consultor especialista em cruzamento de média móvel simples. Podemos compilá-lo e testá-lo na plataforma MetaTrader 5.
Depois de compilar o código sem erros, você pode salvar o consultor especialista e usá-lo no MetaTrader 5. Lembre-se de testar e otimizar seu consultor especialista antes de usá-lo com dinheiro real.
Intervalo Breakout Programação mql5 EA | Parte 1/4
Intervalo Breakout Programação mql5 EA | Parte 1/4
Olá, aqui é Toby, e no vídeo de hoje, mostrarei como codificar um consultor especialista (EA) de intervalo de intervalo de tempo para MetaTrader 5. O objetivo é obter resultados semelhantes à estratégia mostrada no vídeo.
Primeiro, vamos discutir a lógica por trás do EA. Vamos definir um intervalo de tempo simples, começando em um horário específico e terminando em outro horário. O EA salvará os preços mais altos e mais baixos dentro desse intervalo. Se o preço ultrapassar o preço mais alto após o intervalo, o EA entrará em uma negociação de compra. Por outro lado, se o preço cair abaixo do intervalo, o EA entrará em uma negociação de venda. Além disso, definiremos um horário de fechamento para fechar todas as posições. Essa lógica direta guiará nosso EA.
Para começar a codificar, abra o MetaEditor e crie um novo consultor especialista. Limpe o código do modelo, de acordo com a preferência pessoal, removendo linhas desnecessárias.
Em seguida, defina as variáveis de entrada para a hora de início, duração do intervalo, hora de fechamento, tamanho do lote e número mágico. Essas entradas permitem que os usuários personalizem o comportamento do EA. É importante verificar os valores de entrada para evitar entradas incorretas. Por exemplo, podemos garantir que o número mágico não seja zero ou negativo, os lotes não sejam negativos, a hora de início e a duração estejam dentro de intervalos válidos e a hora de fechamento não seja igual à hora de início mais a duração do intervalo.
Após definir as variáveis de entrada e verificar seus valores, passamos para a criação das variáveis globais. Essas variáveis serão usadas em todo o EA. Agrupamos as variáveis relacionadas ao intervalo em uma estrutura denominada "estrutura de intervalo". Essa estrutura contém variáveis para hora de início, hora de término, hora de fechamento, preços altos e baixos e sinalizadores para entrada, quebra alta e quebra baixa.
Adicionalmente, definimos o construtor da estrutura, onde predefinimos os valores iniciais das variáveis. Isso ajuda a inicializar a estrutura com valores padrão. Também adicionamos comentários após cada variável para descrever sua finalidade.
Nós compilamos o código para verificar se há erros e garantir que tudo esteja funcionando corretamente.
Por fim, criamos mais algumas variáveis, como "MqlTick" e "last_tick" do tipo MetaTrader 5 "MqlTick". Também definimos uma variável do tipo "CTrade" para lidar com operações relacionadas ao comércio.
Neste ponto, configuramos as variáveis e estruturas necessárias para nosso EA. Na próxima parte, vamos mergulhar na codificação da lógica real do EA na função "OnTick". Na próxima parte do vídeo, focaremos na codificação da lógica real do Expert Advisor na função OnTick. No entanto, antes de prosseguirmos, vamos primeiro revisar o que fizemos até agora.
Começamos definindo as variáveis de entrada para o EA, como hora de início do intervalo, duração, hora de fechamento, tamanho do lote e número mágico. Também adicionamos verificações de validação de entrada para garantir que o usuário insira valores válidos para essas entradas. Em seguida, criamos uma estrutura chamada rangeStructure para armazenar as variáveis relacionadas ao intervalo, incluindo hora de início, hora de término, hora de fechamento, alta e baixa da faixa e sinalizadores para entrada, quebra alta e quebra baixa. Em seguida, definimos um construtor para rangeStructure para inicializar as variáveis com valores padrão. Além disso, declaramos algumas variáveis globais, incluindo uma instância do rangeStructure, duas variáveis do tipo MqlTick para armazenar os ticks atuais e anteriores e um objeto CTrade para lidar com as operações de negociação.
Agora, vamos passar para a implementação da função OnTick para codificar a lógica principal do EA. Aqui está a continuação do vídeo: Na função OnTick, primeiro atualizaremos as informações do tick atual usando a função SymbolInfoTick. Isso nos permite acessar os preços de compra e venda, bem como o tempo do tick. A seguir, verificaremos se o tempo do tick atual está dentro do intervalo definido pelo usuário. Para fazer isso, comparamos o tempo atual do tick com o horário inicial e final do intervalo. Se o tempo do tick estiver dentro do intervalo, definimos o flagEntry como true, indicando que estamos dentro do intervalo.
Depois disso, verificamos se há um rompimento alto. Se o preço atual do tick exceder a máxima anterior do intervalo e o flagHighBreakout for falso, iniciamos uma negociação de compra. Definimos o flagHighBreakout como true para evitar entradas repetidas. Da mesma forma, verificamos um rompimento baixo. Se o preço atual do tick cair abaixo da mínima anterior do intervalo e o flagLowBreakout for falso, iniciamos uma negociação de venda. Definimos o flagLowBreakout como true para evitar várias entradas. Por fim, verificamos se o tempo do tick atual é igual ao tempo de fechamento. Nesse caso, fechamos todas as posições abertas usando o método trade.CloseAll.
Essa é a lógica básica do EA. Claro, existem elementos adicionais que você pode adicionar para aprimorar sua funcionalidade, como níveis de stop-loss e take-profit, regras de gerenciamento de dinheiro e filtros comerciais adicionais. No entanto, neste vídeo, focamos no conceito central da estratégia de intervalo de intervalo de tempo.
Lembre-se, este EA serve como ponto de partida e você pode personalizá-lo ainda mais de acordo com seus requisitos e preferências de negociação.
Na próxima parte do vídeo, continuaremos com o processo de codificação, adicionando o código necessário para implementar a lógica discutida. Se você achou este vídeo útil, não se esqueça de deixar um like e se inscrever no meu canal para se manter atualizado com os próximos vídeos. Se você tiver alguma dúvida ou precisar de ajuda, sinta-se à vontade para deixar um comentário e terei prazer em ajudar. Obrigado por assistir, e vejo você no próximo vídeo. Tchau!
Intervalo Breakout EA mql5 Programming| Parte 2/4
Intervalo Breakout EA mql5 Programming| Parte 2/4
Olá, aqui é Toby, e no vídeo de hoje, continuaremos codificando nosso EA de intervalo de tempo para MetaTrader 5. Se você ainda não assistiu ao primeiro vídeo, pode encontrar o link aqui. No vídeo anterior, expliquei a lógica do EA e o que estamos tentando codificar.
Agora, vamos mudar para o MetaEditor e retomar a codificação. Estaremos trabalhando na função OnTick, que é chamada toda vez que o preço muda para o nosso símbolo. Nesta função, codificaremos nosso cálculo de intervalo e a verificação de rompimento. Primeiro, precisamos obter o tick atual para o símbolo. Armazenamos o tick atual em uma variável chamada currentTick, e também temos uma variável PreviousTick para armazenar o tick anterior.
Em seguida, verificamos se precisamos calcular um novo intervalo. Existem várias condições para calcular um novo intervalo.
Se tivermos um tempo de fechamento de intervalo definido e o tempo de tique atual for maior ou igual ao tempo de fechamento de intervalo, calculamos um novo intervalo.
Se os sinalizadores de quebra alta e quebra baixa forem definidos como verdadeiros, calculamos um novo intervalo.
Se for a primeira vez que executamos o EA e ainda não calculamos um intervalo, calculamos um novo intervalo.
Se o horário final do intervalo não for zero e estivermos atrás do intervalo e não o inserirmos, calculamos um novo intervalo.
Também verificamos se temos alguma posição aberta. Se não houver posições abertas, procedemos ao cálculo de um novo intervalo.
Uma vez que determinamos que precisamos calcular um novo intervalo, chamamos a função CalculateRange. Nesta função, redefinimos todas as variáveis de intervalo para seu estado padrão. Em seguida, calculamos o horário de início do intervalo obtendo o início do dia e adicionando o horário de início do intervalo de entrada em minutos. Se o horário de início calculado já tiver passado, passamos para o dia seguinte, considerando sábado e domingo como dias de fim de semana. Da mesma forma, calculamos o horário de término do intervalo adicionando a duração do intervalo de entrada em minutos ao horário de início. Se o horário final cair em um sábado ou domingo, mudamos para o próximo dia válido.
Também calculamos o tempo de fechamento do intervalo usando a mesma lógica do cálculo do horário de início e término. Para visualizar os tempos calculados no gráfico, criamos objetos usando a função ObjectCreate. Criamos um objeto de linha vertical para a hora de início do intervalo e excluímos todos os objetos desenhados anteriormente.
Este é o progresso que fizemos até agora e continuaremos a codificar no próximo vídeo.
Intervalo Breakout Programação mql5 EA | Parte 3/4
Intervalo Breakout Programação mql5 EA | Parte 3/4
Olá, aqui é o Toby, e no vídeo de hoje, continuaremos codificando nosso EA inovador. Nos vídeos anteriores, já calculamos o horário de início, término e fechamento do intervalo. Agora, queremos codificar o intervalo alto e o intervalo baixo, bem como as condições de rompimento e o fechamento da posição. Se você ainda não assistiu aos vídeos anteriores, pode encontrar os links na descrição abaixo. Vamos pular para o MetaEditor e começar a codificar.
Primeiro, iremos para a função OnTick. Começaremos verificando se estamos dentro do intervalo e salvamos os valores altos e baixos. Usamos uma instrução if para verificar se a hora atual está entre os horários de início e término do intervalo. Se for, atualizamos os valores altos e baixos de acordo. Também definimos um sinalizador de entrada como true para indicar que tínhamos um tique dentro do intervalo. Em seguida, atualizamos os objetos do gráfico para o intervalo alto e baixo.
Em seguida, passamos para a função DrawObject para desenhar os níveis alto e baixo do intervalo. Copiamos o bloco de código para o tempo de fechamento e fazemos as alterações necessárias para o nível alto. Usamos o nome do objeto "Range High" e desenhamos uma linha de tendência desde o horário de início do intervalo até o preço máximo do intervalo. Também atualizamos a dica de ferramenta para exibir o valor alto do intervalo. Fazemos o mesmo para o intervalo baixo, alterando o nome do objeto e desenhando uma linha de tendência desde o horário de início do intervalo até o preço mínimo do intervalo.
Para desenhar uma linha do final do intervalo até o horário de fechamento, indicando uma quebra, copiamos o bloco de código novamente e o modificamos de acordo. Mudamos o nome do objeto e desenhamos uma linha de tendência desde o horário final do intervalo até o horário de fechamento. Também definimos o estilo de linha como pontilhado.
Depois de compilar e executar um teste visual, podemos ver o intervalo alto, o intervalo baixo e as linhas de quebra exibidas no gráfico. Agora, vamos codificar as condições de breakout. Adicionamos uma nova função chamada CheckBreakouts dentro da função OnTick. Primeiro, verificamos se estamos após o horário de término do intervalo. Também garantimos que o sinalizador de entrada seja definido como verdadeiro, indicando que tivemos um tique dentro do intervalo. Se essas condições forem atendidas, procedemos à verificação de rompimentos altos e baixos.
Para uma quebra alta, verificamos se o sinalizador de quebra alta é falso e se o preço de venda do último tick é maior ou igual ao intervalo alto. Nesse caso, abrimos uma posição de compra usando a função PositionOpen. Da mesma forma, para uma quebra de baixa, verificamos se o sinalizador de quebra de baixa é falso e se o preço de lance do último tick está abaixo ou igual ao intervalo baixo. Se essas condições forem atendidas, abrimos uma posição de venda.
Compilamos o código e executamos um teste visual para confirmar que as posições são abertas quando ocorre um rompimento. Em seguida, implementamos o fechamento da posição. Antes de calcular um novo intervalo, verificamos se o tempo atual é maior ou igual ao tempo de fechamento do intervalo. Nesse caso, chamamos a função ClosePositions. Esta função percorre todas as posições abertas com o número mágico especificado e as fecha usando a função PositionClose. Usamos um loop de contagem regressiva para garantir que todas as posições sejam fechadas, mesmo que o número total de posições mude durante o loop.
Por fim, compilamos o código e executamos um teste visual para confirmar que as posições são fechadas quando o tempo de fechamento do intervalo é atingido.
É isso para este vídeo. Se você tiver alguma dúvida, sinta-se à vontade para deixá-la nos comentários abaixo. Não se esqueça de curtir e se inscrever para mais vídeos de codificação. Obrigado por assistir!