Tutoriais de programação - página 3
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
Construtores OOP - Tipos de construtores que você precisa saber (básicos para o domínio)
Construtores OOP - Tipos de construtores que você precisa saber (básicos para o domínio)
Neste vídeo, discutiremos diferentes tipos de Construtores, sua finalidade e por que eles são essenciais na programação. Fornecerei exemplos e explicarei o funcionamento de fundo dos Construtores. Mas antes de mergulharmos, quero recomendar uma ferramenta que uso há anos chamada PBS Studio. É um poderoso analisador de código estático que ajuda a rastrear bugs e melhorar a qualidade do código. Ele se integra facilmente com vários IDEs e oferece suporte a linguagens como C, C++, C# e Java. Você pode encontrar o link para download e até descobrir maneiras de obtê-lo gratuitamente se for estudante. Agora, vamos voltar ao vídeo.
Para começar, vamos criar uma classe chamada "User" com membros públicos: "firstName", "lastName", "age" e "email". Atualmente, atribuímos valores manualmente a essas propriedades para cada usuário que criamos. No entanto, essa abordagem se torna impraticável à medida que o número de usuários cresce.
Em vez disso, exploraremos uma solução melhor usando Construtores. Os construtores são usados para construir objetos e automatizam o processo de inicialização das propriedades do objeto. Começaremos explicando o funcionamento dos Construtores por meio de exemplos.
Para fins de demonstração, vamos remover o segundo usuário e imprimir as informações do primeiro usuário. Ao executar o programa, você notará que a saída exibe valores vazios para firstName, lastName e email, e um número grande ou pequeno para age. Exploraremos por que isso acontece e a ausência de erros.
A razão por trás desse comportamento é o Construtor padrão fornecido pelo C++. Ele inicializa as propriedades com valores padrão, como o grande número que vemos para a idade. No entanto, quando criamos uma variável simples, como "teste", sem inicializá-la, encontramos um erro porque os tipos simples não possuem Construtores padrão.
Agora, vamos examinar as características dos Construtores. Primeiro, os construtores têm o mesmo nome da classe e nenhum tipo de retorno. Em segundo lugar, eles precisam ser colocados na seção pública da classe. Em terceiro lugar, os construtores padrão não têm parâmetros. Quarto, C++ gera automaticamente um construtor padrão se você não criar um. Quinto, Construtores parametrizados recebem parâmetros para inicializar as propriedades do objeto. Por fim, um Construtor padrão é invocado automaticamente quando um objeto dessa classe é criado.
Vamos implementar nosso próprio Construtor padrão atribuindo valores padrão às propriedades. Com essa alteração, sempre que criarmos um usuário, nosso Construtor padrão será invocado. Agora, quando imprimirmos as informações do usuário, veremos os valores padrão que atribuímos.
Seguindo em frente, vamos explorar o segundo tipo de Construtor, o Construtor parametrizado. Ao contrário do Construtor padrão, o Construtor parametrizado aceita valores específicos como parâmetros e os utiliza para instanciar as propriedades do objeto. Fornecerei um exemplo de um Construtor parametrizado que recebe parâmetros para firstName, lastName e age.
Com esses parâmetros, podemos atribuir os valores fornecidos às propriedades correspondentes. Isso nos permite criar usuários com informações específicas diretamente durante a criação do objeto.
Isso cobre o básico dos Construtores e seu uso. Fique ligado para mais exemplos e insights em vídeos futuros.
Funções Friend e classes em C++ (Programação para iniciantes)
Funções Friend e classes em C++ (Programação para iniciantes)
Neste vídeo, estou animado para ensinar sobre as funções de amigo e as classes de amigo em C++. Esse conceito de amizade na programação é semelhante à amizade na vida real. Assim como seus amigos têm acesso a áreas privadas de sua vida que outros não têm, funções de amigo e classes de amigo na programação orientada a objetos têm acesso a membros privados e protegidos de uma classe.
Neste vídeo, você aprenderá como e quando usar funções de amigo e classes de amigo. Para demonstrar, usaremos o Visual Studio Community, e também apresentarei uma excelente extensão chamada Visual Assist. Você pode encontrar o link de download na descrição abaixo. O Visual Assist é um assistente de codificação inteligente que muitos desenvolvedores profissionais usam, especialmente para grandes projetos ou desenvolvimento de jogos com mecanismos como o Unreal Engine. Ele aprimora a conclusão do código, oferece sugestões inteligentes para refatoração, fornece trechos de código e melhora a navegação e a pesquisa em seu projeto.
Agora, vamos mergulhar no tópico das funções de amigo. Para explicar esse conceito, vamos criar um problema e resolvê-lo usando funções amigas. Vamos criar uma classe chamada "EquilateralTriangle" para representar um triângulo com todos os três lados do mesmo comprimento. A classe terá variáveis privadas para comprimento lateral, circunferência e área. Também adicionaremos um método setter público para definir o comprimento do lado e calcular a circunferência e a área dentro desse método.
No entanto, se tentarmos acessar os membros privados fora da classe, encontraremos erros. Uma solução é tornar públicos os membros privados ou criar getters públicos, mas isso os expõe a todos. Em vez disso, podemos usar funções de amigo para conceder acesso seletivamente. Criaremos uma função global chamada "PrintResults" que imprimirá a circunferência e a área do triângulo. Ao declarar essa função como amiga da classe EquilateralTriangle, ela obtém acesso aos membros privados.
Mas lembre-se, escolha bem suas funções amigas e evite o uso excessivo para manter o encapsulamento. Além disso, em C++, você também pode ter classes amigas. Se movermos a função "PrintResults" para dentro de uma classe chamada "Homework" e torná-la uma função de membro pública, podemos declarar "Homework" como uma classe amiga de "EquilateralTriangle". Desta forma, a classe "Homework" pode acessar os membros privados e protegidos de "EquilateralTriangle".
É importante observar que a amizade na programação não é mútua ou herdada. Use funções de amigo e classes de amigo criteriosamente e lembre-se de que herança e sobrecarga de operador também envolvem casos de uso comuns para funções de amigo. Confira meu vídeo sobre sobrecarga do operador (link na descrição) para obter mais informações e um exercício de lição de casa relacionado.
Espero que você ache este vídeo útil para entender e utilizar funções e classes de amigos em seus projetos de programação. Fique ligado para mais conteúdo interessante e não se esqueça de conferir a extensão do Visual Assist para Visual Studio!
Destrutores em Programação: Demonstração Prática
Destrutores em Programação: Demonstração Prática
Neste vídeo, ensinarei sobre destrutores na programação. Você aprenderá o que são destruidores, como usá-los e quando usá-los. Certifique-se de assistir ao vídeo inteiro porque tenho uma surpresa especial para você no final. Antes de mergulharmos nos destruidores, é importante entender os construtores. Se você não está familiarizado com construtores, assista ao meu vídeo anterior vinculado aqui e na descrição.
Destruidores são funções especiais invocadas quando um objeto está sendo destruído. Eles executam tarefas de limpeza necessárias, como liberar recursos como memória ou arquivos mantidos pelo objeto. Deixar de liberar esses recursos pode degradar o desempenho, a estabilidade e levar a vazamentos de memória.
Antes de começarmos a discutir os destruidores, quero apresentar a você uma ferramenta que adoro usar chamada PBS Studio. É um analisador de código estático que me ajuda a escrever um código melhor sem bugs. Ele analisa seu código em busca de possíveis problemas e bugs, economizando tempo e dinheiro ao detectar erros antes que eles entrem em produção. É fácil de integrar com IDEs populares e oferece suporte a várias linguagens de programação. Você pode baixá-lo no link na descrição e experimentá-lo gratuitamente. Se você é um estudante, verifique o site deles para opções gratuitas.
Agora, vamos nos aprofundar nos destruidores. Um destruidor é uma função especial com um nome idêntico ao nome da classe, precedido por um til (~). Ele não possui um tipo de retorno, não recebe nenhum parâmetro e deve ser colocado na seção pública de sua classe. Só pode haver um destruidor por classe.
Para ilustrar os destruidores, vamos criar uma classe chamada "Livro" com duas propriedades: "título" e "autor". Também criaremos um construtor e um destruidor. Lembre-se, o destruidor deve desalocar todos os recursos mantidos pelo objeto.
Dentro do construtor, atribuiremos os parâmetros passados às propriedades correspondentes. Dentro do destruidor, enviaremos uma mensagem indicando que o destruidor foi invocado para um livro específico.
Agora, vamos criar alguns objetos de livro para ver quando o construtor e o destruidor são invocados. Vamos depurar o programa e observar a ordem de invocação.
Se sua classe não envolver ponteiros, o compilador manipulará a desalocação de memória automaticamente. No entanto, se você estiver trabalhando com ponteiros, precisará desalocar manualmente a memória no destruidor para evitar vazamentos de memória. Lembre-se de usar "delete[] arrayName" para arrays e definir ponteiros para nullptr após a desalocação.
Espero que este vídeo tenha ajudado você a entender os destruidores e sua importância no gerenciamento de recursos. Em meu próximo vídeo, exploraremos os construtores de cópia, portanto, fique atento.
Construtores de cópia C++ (tutorial para iniciantes + exemplos práticos)
Construtores de cópia C++ (tutorial para iniciantes + exemplos práticos)
Olá a todos, sejam bem vindos ao meu canal. Neste vídeo, ensinarei sobre construtores de cópia, que é um tópico importante, mas confuso para iniciantes. Antes de assistir a este vídeo, certifique-se de assistir ao meu vídeo anterior sobre diferentes tipos de construtores, incluindo construtores padrão e parametrizados (link na descrição). Além disso, confira meu vídeo sobre ponteiros e arrays dinâmicos (link na descrição), pois ajudará você a entender melhor esse tópico.
Neste vídeo, explicarei tudo o que você precisa saber sobre construtores de cópia. Os iniciantes geralmente entendem o conceito por trás dos construtores de cópia, mas lutam para entender quando e como usá-los, bem como os possíveis bugs e erros que podem ocorrer. Vou cobrir todos esses aspectos passo a passo.
Vamos começar examinando o código do meu vídeo anterior. Criei uma classe chamada "Livro" com propriedades como título, autor e um ponteiro chamado "taxas". O ponteiro "taxas" representa uma matriz dinâmica onde os usuários podem inserir classificações para o livro. Há também um "contador de taxas" para controlar o tamanho do array. Se você não está familiarizado com ponteiros e arrays dinâmicos, recomendo assistir ao meu vídeo sobre esse assunto (link na descrição).
Implementei um construtor parametrizado para a classe Book, que usa title e author como parâmetros e cria um objeto book com base nesses valores. Também incluí um destruidor, que é importante para liberar a memória alocada pelo construtor. É crucial usar um analisador de código como o PVS-Studio para detectar erros ocultos e pontos fracos em seu código. Pessoalmente, recomendo usar o PVS-Studio, pois é eficaz para encontrar erros e fornecer sugestões para corrigi-los. Você pode baixá-lo gratuitamente usando o link na descrição.
Agora, vamos nos concentrar no tópico dos construtores de cópia. O propósito de um construtor de cópia é criar um novo objeto baseado em um objeto existente. Ele permite que você faça uma cópia de um objeto e use-o para criar um novo. Por padrão, C++ fornece um construtor de cópia padrão. No entanto, ao trabalhar com ponteiros, é necessário criar um construtor de cópia personalizado para evitar erros.
Sem um construtor de cópia personalizado, o uso de ponteiros pode levar a exceções e erros. Vamos considerar o seguinte cenário: desejo criar o "Livro3" com base nos dados do "Livro1". Desejo copiar todas as propriedades de "Livro1" para criar "Livro3". É aqui que o construtor de cópias entra em ação.
Para criar um construtor de cópia, siga estas regras:
Vamos criar o construtor de cópia. No construtor de cópia, receberemos o objeto original como uma referência constante (const Book& original). Isso evita qualquer modificação no objeto original dentro do construtor de cópia.
Agora, vamos abordar um erro comum cometido por iniciantes ao criar um construtor de cópia. O erro está em copiar o ponteiro diretamente em vez de alocar nova memória e copiar o conteúdo. Se copiarmos o ponteiro, tanto o original quanto a cópia apontarão para o mesmo local de memória. Como resultado, quando o destruidor for invocado, ele tentará liberar a memória duas vezes, levando a erros.
Para corrigir esse problema, precisamos alocar nova memória para a cópia e copiar o conteúdo do ponteiro original. Em vez de atribuir diretamente o ponteiro, criaremos um novo array dinâmico e copiaremos os elementos. Isso garante que o original e a cópia tenham locais de memória separados.
Seguindo essas diretrizes, podemos criar um construtor de cópia correto que evite erros relacionados à memória.
Espero que esta explicação esclareça o conceito de construtores de cópia e sua importância.
Codifique-você-mesmo! Tetris - Programação do zero (C++ rápido e simples)
Codifique-você-mesmo! Tetris - Programação do zero (C++ rápido e simples)
Olá! Hoje vamos embarcar na empolgante jornada de criar nossa própria versão do Tetris. Antes de nos aprofundarmos na codificação, deixe-me dar uma prévia do que estaremos construindo.
Como você pode ver, temos uma forma clássica de Tetris na tela. Seremos capazes de girar essas formas, graças ao poder da codificação. O jogo inclui detecção de colisão, o que garante que as peças interajam corretamente entre si. Se conseguirmos completar uma linha colocando estrategicamente as peças aleatórias, ela desaparecerá e nossa pontuação aumentará de acordo. No entanto, se não tivermos cuidado e a pilha de peças chegar ao topo, o jogo termina.
Agora, você deve estar se perguntando por que estamos focando no mecanismo de jogo em vez dos gráficos. Embora a estética seja importante e possa atrair os jogadores, a verdadeira essência de um jogo está em seu mecanismo - a parte responsável por implementar a jogabilidade, a lógica, as regras, os desafios e muito mais. Os mecanismos gráficos sempre podem ser adicionados posteriormente e você pode até trazer um artista para embelezar seu jogo. Mas, para realmente entender o desenvolvimento de jogos, você precisa entender os fundamentos da construção de um mecanismo de jogo.
Para começar, precisamos de alguns recursos do jogo. No Tetris, esses recursos são as diferentes formas chamadas de "blocos de tetromino". Armazenaremos essas formas como strings, o que facilitará nossa visualização. Existem sete formas comuns usadas no Tetris, e as representaremos usando caracteres como pontos (.) para espaços vazios e X maiúsculo para a própria forma. Ao organizar esses caracteres, criamos strings que retratam visualmente as formas.
Agora, em vez de usar matrizes multidimensionais para representar as formas 2D, empregaremos uma matriz unidimensional e manipularemos os índices usando cálculos matemáticos simples. Essa abordagem nos permite lidar com rotações e reflexões das formas com mais eficiência. Usaremos fórmulas para determinar os índices apropriados para cada rotação. Por exemplo, multiplicando a coordenada X por 4, podemos obter o índice desejado para uma rotação de 90 graus. Essa técnica nos poupará de criar recursos separados para cada variação de forma possível.
Além dos blocos de tetromino, também precisamos de um campo de jogo. Definiremos as dimensões do campo usando variáveis de largura e altura. Nesse caso, usaremos um tamanho de campo de 12 células de largura e 18 células de altura. Para representar os elementos do campo de jogo, usaremos uma matriz de caracteres sem sinal. A cada célula será atribuído um valor para indicar seu conteúdo, como espaço vazio, parte de uma forma ou paredes delimitadoras.
Para visualizar nosso jogo, utilizaremos o prompt de comando como um buffer de tela. Ao criar um array com as dimensões da janela do prompt de comando, podemos desenhar nele os elementos do nosso jogo. Usaremos personagens específicos para representar diferentes elementos do jogo, como as formas, os espaços vazios e as paredes delimitadoras. Em seguida, exibiremos o conteúdo do array na tela do prompt de comando.
Agora, vamos falar sobre o loop do jogo. Os loops de jogo são componentes vitais de qualquer mecanismo de jogo, pois controlam a sequência dos elementos do jogo. No caso do Tetris, nosso loop de jogo lidará com o tempo, a entrada do usuário, a lógica do jogo e a renderização de saída.
O tempo é crucial para garantir uma jogabilidade consistente em diferentes sistemas. Queremos que o jogo rode no mesmo ritmo, independentemente da velocidade do computador. Usaremos mecanismos de temporização para controlar a velocidade com que as formas caem e as atualizações do jogo.
Em seguida, abordaremos a entrada do usuário. Como estamos criando uma versão simples de linha de comando do Tetris, não dependeremos de entradas baseadas em eventos. Em vez disso, lidaremos com entradas básicas do usuário, como teclas de seta ou outras teclas designadas.
Neste código, implementaremos a manipulação de entrada de teclado para um jogo, focando especificamente em quatro teclas: a seta para a esquerda, a seta para a direita, a seta para baixo e a tecla "Z" para girar a peça do jogo.
Para obter o estado atual das teclas pressionadas pelo usuário, utilizaremos a função "get async key state". Ao iterar por meio de uma matriz que representa o estado das teclas, podemos determinar se cada tecla está pressionada ou não. Esta função retorna um valor booleano: true se a tecla for pressionada e false se não for. Para verificar o estado de uma chave específica, usamos uma expressão de string constante que representa os códigos de chave virtual para cada chave.
Ao verificar o estado dessas quatro teclas, podemos criar uma matriz que contém valores verdadeiros ou falsos indicando se cada tecla foi pressionada ou não. Isso simplifica o processo e nos dá um array representando o estado atual das chaves.
Vamos considerar a tecla esquerda como exemplo. Quando o usuário pressiona a tecla esquerda, precisamos verificar se a peça do jogo pode caber à esquerda de sua posição atual. Para fazer isso, utilizamos uma função chamada "encaixe da peça", que considera a peça atual, sua rotação e a posição X atual. Subtraindo 1 da posição X atual, podemos determinar se a peça se encaixa à esquerda. Se couber, atualizamos a posição X atual de acordo.
Da mesma forma, para a chave direita, realizamos uma verificação semelhante para ver se a peça pode caber à direita de sua posição atual. Se puder, atualizamos a posição X atual de acordo.
Quando o usuário pressiona a tecla para baixo, precisamos manipular o movimento vertical da peça. Como a posição superior esquerda do campo de jogo é sempre (0, 0), podemos simplesmente incrementar a posição Y para mover a peça para baixo. Realizamos verificações para garantir que mover a peça para a esquerda, para a direita ou para baixo a mantenha dentro dos limites do campo de jogo.
Para otimizar o código, podemos substituir as instruções if aninhadas por operadores AND lógicos. Isso simplifica o código e melhora sua concisão. Além disso, utilizamos instruções condicionais para adicionar ou subtrair 1 da posição X atual com base no resultado da condição, simplificando ainda mais o código. A mesma otimização é aplicada ao manipular a rotação da peça quando o usuário pressiona a tecla "Z".
No Tetris, o jogo força periodicamente a peça a descer a cada poucos décimos de segundo, simulando a gravidade. Conseguimos isso utilizando o contador de ticks do jogo. Inicialmente, a peça cai lentamente, mas conforme o jogo avança, diminuímos o tempo entre a queda de cada peça, tornando o jogo mais rápido e desafiador. Ao acumular os ticks do jogo e compará-los com a velocidade atual, determinamos quando forçar a peça para baixo. Isso faz com que a peça caia em intervalos regulares, criando o efeito da gravidade no jogo.
Para bloquear a peça atual no campo de jogo, atualizamos a matriz de campo com os valores da matriz tetromino. Isso é feito iterando cada elemento da matriz tetrominó e atualizando a posição correspondente na matriz de campos. Se um elemento na matriz do tetrominó for um "X", incrementamos o valor correspondente na matriz do campo em 1. Isso marca a posição como ocupada pela peça atual.
Quando uma linha é formada no campo de jogo, queremos indicá-la visualmente ao jogador. Substituímos a linha por um marcador especial ou executamos qualquer outro efeito visual para indicar a conclusão da linha.
Depois de indicar visualmente a linha concluída, precisamos lidar com a limpeza da linha e atualizar o campo de jogo de acordo. Percorremos cada linha do campo de jogo começando de baixo e verificamos se a linha está preenchida. Se uma linha estiver preenchida, nós a limpamos definindo todos os seus elementos como 0. Em seguida, movemos todas as linhas acima dela uma posição para baixo para preencher a linha limpa. Este processo é repetido até que todas as linhas preenchidas tenham sido apagadas.
Para acompanhar a pontuação do jogador, nós a incrementamos toda vez que uma linha é limpa. A pontuação pode ser baseada no número de linhas limpas ou pode ter um sistema de pontuação mais complexo, dependendo do design do jogo.
Para lidar com as condições de game over, precisamos verificar se a peça atual pode caber em sua posição inicial no topo do campo de jogo. Se não couber, o jogo termina e interrompemos o loop do jogo ou acionamos qualquer ação de fim de jogo necessária.
Por fim, para lidar com o loop do jogo, utilizamos um cronômetro ou mecanismo semelhante que aciona uma função de atualização em intervalos regulares. Essa função lida com a atualização do estado do jogo, incluindo a verificação da entrada do usuário, movendo a peça para baixo e executando as ações necessárias com base no estado atual do jogo.
Resumindo, este código implementa a manipulação de entrada de teclado para um jogo, focando especificamente em teclas como setas e a tecla "Z". Ele verifica o estado dessas teclas, manipula o movimento da peça do jogo de acordo, implementa a gravidade e o bloqueio da peça, limpa as linhas concluídas, atualiza o campo de jogo, rastreia a pontuação do jogador e verifica as condições de fim do jogo. O loop do jogo garante que o estado do jogo seja atualizado em intervalos regulares, criando uma experiência de jogo dinâmica e interativa.
C++ CURSO COMPLETO Para Iniciantes (Aprenda C++ em 10 horas)
C++ CURSO COMPLETO Para Iniciantes (Aprenda C++ em 10 horas)
Este é um curso completo de programação C++. Consiste em várias palestras cujo objetivo é levá-lo do nível iniciante ao avançado de programação. Recomendo assistir o vídeo inteiro porque as aulas posteriores requerem o conhecimento das anteriores.
Conteúdo:00:00:00 – Objetivos do curso
00:01:31 – Faça isso antes de iniciar o curso
00:02:41 – Introdução ao C++ (O que é C++? Que tipo de aplicativos você pode construir com C++? Por que C++ foi criado?)
00:06:39 – O que é código fonte, código objeto, compilador, algoritmo?
00:08:42 - Visual Studio 2019 – Criando um primeiro projeto (configuração)
00:11:32 - Noções básicas do Visual Studio 2019 explicadas e o primeiro programa “Hello World”
00:29:51 - Introdução às variáveis
00:44:36 – Regras para nomear variáveis
00:52:15 – Tipos de dados em C++ e como usar o operador sizeof
01:01:58 - Estouro de tipo de dados
01:05:00 – O que é tabela ASCII
01:09:50 - Programa simples e divertido para cifrar palavras em ASCII
01:18:12 - Instrução if/else (crie um programa que verifica números pares/ímpares + explicação do fluxograma)
01:35:52 - Instrução if/else aninhada (Construa um programa que determine o tipo de um triângulo + fluxograma)
01:55:50 - Operadores em C++ (operadores aritméticos, relacionais, lógicos, de atribuição)
02:21:02 - Trocando valores de duas variáveis com ou sem uma terceira variável
02:29:20 – Criar aplicativo de Calculadora de IMC + fluxograma
02:49:55 - Operador Ternário (Condicional) (Criar um aplicativo de jogo de adivinhação)
03:01:00 - Declaração de switch/caso parte 1 (aplicativo Build Calculator)
03:26:36 - Instrução switch/case parte 2 (Construir programa que verifica o número de dias em um mês)
03:39:35 - While loop parte 1 + exemplo de loop infinito
03:53:39 - Loop while parte 2 (Construa um programa para contar dígitos de um número)
04:12:39 - Loop while parte 3 (Construa um programa para inverter os dígitos de um número)
04:25:25 - Faça loop while (Programa para validação de PIN)
04:39:09 – Qual é a diferença entre o loop While e o loop Do While
04:40:34 - For loop (Construa um programa para calcular o fatorial de um número)
04:58:12 – Loops aninhados (Aninhamento do loop while e do loop for)
05:11:08 – Loop for aninhado (aplicativo Build Multiplication table)
05:21:45 – Programa para desenhar formas retangulares
05:33:05 – Programa para desenhar triângulos e formas de triângulos invertidos/invertidos
05:44:30 – Introdução às funções
05:56:02 – Funções com parâmetros/argumentos (múltiplos e padrão)
06:11:42 - Instrução de retorno da função (Construir programa para verificar números primos)
06:37:39 - Sobrecarga de função
06:48:06 – Crie um aplicativo de caixa eletrônico
07:03:03 - Funções e modelos genéricos
07:14:30 – Recursão e funções recursivas
07:30:01 – Introdução ao OOP, O que são classes e objetos
07:42:06 – Construtores OOP e métodos de classe
07:57:10 – Encapsulamento OOP, GIT: https://github.com/TrueCodeBeauty/EncapsulationCpp
08:08:31 – Herança OOP, GIT: https://github.com/TrueCodeBeauty/InheritanceCpp
08:24:59 – OOP Polymorphisam, GIT: https://github.com/TrueCodeBeauty/PolymorphismCpp
08:40:04 - Introdução aos ponteiros
08:51:14 - Ponteiros vazios
09:06:27 - Ponteiros e matrizes
09:19:18 - Retorna vários valores de uma função usando ponteiros
09:34:50 - Arrays dinâmicos, criar/alterar arrays em tempo de execução
09:48:35 – Arrays dinâmicos multidimensionais, Array bidimensional
10:07:00 - Detecção de erros no código usando o PVS Studio
10:17:19 - Explicando vazamentos de memória
10:26:25 - Erros de gravação
FUNÇÕES C++ (2020) - O que são funções?
FUNÇÕES C++ (2020) - O que são funções? TUTORIAL DE PROGRAMAÇÃO
Bem-vindo ao primeiro vídeo do meu canal! Se você é iniciante em C++, não deixe de conferir minha lista de reprodução sobre C++ para iniciantes, onde você encontrará conceitos importantes que precisa entender e saber para trabalhar com C++. Neste vídeo, discutiremos as funções C++, essenciais para se tornar um bom programador não apenas em C++, mas na maioria das linguagens de programação.
Antes de começar, inscreva-se no meu canal e clique no ícone do sino para receber notificações quando eu publicar meu próximo vídeo. Se você estiver interessado em ver o conteúdo dos bastidores e como realmente é a vida do desenvolvedor, siga-me no Instagram e no Twitter através de minhas contas "CodeBeauty".
Agora, vamos mergulhar no tópico de funções. Uma função é um bloco de código agrupado para resolver um problema específico ou executar uma tarefa específica. O código dentro de uma função é executado somente quando a função é chamada ou invocada. Todo programa C++ contém pelo menos uma função, que é a função principal. A execução do seu programa começa na primeira linha da função principal e termina na última linha ou quando uma instrução return é encontrada (abordaremos as instruções return posteriormente neste curso).
Para criar sua própria função, há algumas coisas que você precisa saber. Primeiro, você precisa especificar o tipo de retorno da função. Por enquanto, usaremos o tipo de retorno "void", o que significa que a função não retorna nada. Em seguida, você dá um nome à sua função. Dentro dos parênteses, você pode definir quaisquer argumentos ou parâmetros que sua função receba. Neste caso, não teremos argumentos, então os parênteses estão vazios. Por fim, você define o corpo da função entre chaves.
Em nosso exemplo, criamos uma função chamada "função" com um tipo de retorno void e sem argumentos. Dentro do corpo da função, usamos a instrução "cout" para exibir "Hello from function" e adicionamos uma linha final. No entanto, simplesmente criar a função não executa seu código. Para executar a função, você precisa invocá-la ou chamá-la. Em nosso caso, chamamos a função após a instrução "cout" na função principal digitando seu nome seguido de parênteses.
Depois de compilar e executar o programa, você verá a saída "Hello from main" seguida de "Hello from function". Isso ocorre porque a função principal é executada primeiro e, em seguida, a função que criamos é executada quando é invocada.
Para tornar seu código mais legível, é recomendável declarar e definir suas funções separadamente. A declaração inclui o tipo de retorno, o nome da função e quaisquer parâmetros e deve ser colocada antes da função principal. A definição, que contém o corpo da função, é colocada após a função principal. Dessa forma, se outra pessoa estiver lendo seu código, ela poderá navegar facilmente para a função específica que precisa entender.
Lembre-se de que as funções tornam seu código reutilizável. Em vez de escrever o mesmo código várias vezes, você pode escrevê-lo uma vez dentro de uma função e invocá-la sempre que precisar. Essa prática ajuda a reduzir a redundância e torna seu código mais fácil de gerenciar.
Em vídeos futuros, exploraremos as funções com mais detalhes. Não se esqueça de se inscrever no meu canal e ativar as notificações para se manter atualizado com o próximo conteúdo. Obrigado por assistir, e vejo vocês no próximo vídeo!
C++ FUNCTIONS (2020) - O que é parâmetro/argumento de função (múltiplo, padrão) TUTORIAL DE PROGRAMAÇÃO
C++ FUNCTIONS (2020) - O que é parâmetro/argumento de função (múltiplo, padrão) TUTORIAL DE PROGRAMAÇÃO
Olá pessoal! Bem-vindo de volta ao meu canal. Se você é um iniciante em C++, estou feliz por você estar aqui. Antes de mergulharmos no tópico de hoje, quero lembrá-lo de conferir minha lista de reprodução C++ para iniciantes. Abrange conceitos essenciais e inclui muitos exercícios para ajudá-lo a praticar. Além disso, não se esqueça de se inscrever no meu canal e clicar no sininho para receber notificações sempre que eu lançar um novo vídeo. Você também pode me seguir em meus perfis de mídia social, CodeBeauty Instagram e Twitter, para dar uma espiada na vida de um desenvolvedor. Tudo bem, sem mais delongas, vamos pular para a lição de hoje.
Neste vídeo, quero discutir os parâmetros ou argumentos da função C++. Então, o que exatamente são parâmetros e argumentos? Se você ainda não assistiu ao meu vídeo anterior sobre funções C++, recomendo vê-lo (link fornecido). Às vezes, uma função precisa receber um valor ou variável específica para executar uma determinada tarefa. Esses valores ou variáveis são chamados de parâmetros.
Agora, vamos aprender como criar uma função que aceita parâmetros em C++. Para fazer isso, definimos uma função com um tipo de retorno void. Vamos nomear a função "introduceMe". Dentro dos parênteses, especificamos os parâmetros que a função receberá. O corpo da nossa função será colocado entre chaves.
Para definir um parâmetro, começamos informando o tipo do parâmetro, seguido de seu nome. No nosso caso, queremos passar o nome do nosso usuário para a função, então o parâmetro será do tipo string. Chamaremos o parâmetro de "nome". A função apresentará nosso usuário imprimindo "Meu nome é" seguido do nome fornecido.
Para invocar ou chamar nossa função, simplesmente usamos seu nome, "introduceMe". Como nossa função requer um argumento (o parâmetro name), precisamos passar um valor ao chamar a função. Neste caso, vamos passar o nome "Selena" como argumento.
Quando executamos o programa, a função apresentará com sucesso o usuário com o nome fornecido. Ele imprimirá "Meu nome é Selena" como esperado.
Se quisermos introduzir vários usuários, podemos chamar a função novamente com diferentes argumentos. Por exemplo, podemos copiar a linha de invocação e passar um nome diferente, como "Anna". A função apresentará os dois usuários de acordo.
Agora, vamos explorar a passagem de vários argumentos para uma função. Para fazer isso, separamos os parâmetros com vírgulas. Além do parâmetro name, vamos adicionar mais dois parâmetros: city (do tipo string) e age (do tipo int). Modificaremos a função para incluir também informações sobre a cidade e a idade do usuário.
Dentro da função, usaremos o "cout" do C++ para imprimir a cidade e a idade do usuário junto com seu nome. Estruturaremos a saída da seguinte maneira: "Sou de [cidade] e tenho [idade] anos".
Quando invocamos a função, passamos os valores para todos os três parâmetros: nome, cidade e idade. Por exemplo, podemos chamar a função e passar "Selena" como nome, "Moscou" como cidade e 25 como idade. A função apresentará ao usuário todas as informações fornecidas.
Podemos repetir o processo para um segundo usuário. Vamos passar "Anna" como o nome, "New York" como a cidade e 27 como a idade. Ao executar o programa veremos que ambos os usuários foram apresentados com seus respectivos dados.
Em seguida, vamos explorar os parâmetros padrão. Às vezes, você pode querer definir um valor padrão para um parâmetro. Esse valor será usado se nenhum argumento for fornecido para esse parâmetro ao chamar a função.
Para especificar um valor padrão, nós o atribuímos durante a declaração do parâmetro. Por exemplo, vamos definir o valor padrão para o parâmetro "age" como 18. Agora, se chamarmos a função sem fornecer uma idade, ela assumirá o valor padrão.
Vamos invocar a função para um terceiro usuário, passando apenas o nome e a cidade, mas omitindo a idade. Como esperado, a função apresentará ao usuário o valor de idade padrão de 18.
Isso encerra nossa discussão sobre os parâmetros e argumentos da função C++. Espero que você tenha achado este vídeo útil e que tenha uma compreensão sólida de como trabalhar com parâmetros de função em C++. Se você tiver alguma dúvida ou precisar de mais esclarecimentos, deixe um comentário abaixo e ficarei feliz em ajudá-lo. Fique ligado para mais tutoriais de C++ e não se esqueça de curtir e compartilhar este vídeo se você achou valioso. Obrigado por assistir e feliz codificação!
C++ FUNCTIONS (2020) - Declaração de retorno de funções, como verificar o número primo
C++ FUNCTIONS (2020) - Functions return statement, Como verificar números primos TUTORIAL DE PROGRAMAÇÃO
Olá a todos, sejam bem vindos ao meu canal. Neste vídeo, quero discutir instruções de retorno e tipos de funções de retorno em C++. Se você é iniciante, verifique meu curso C++ para iniciantes, que fornece exemplos úteis para ajudá-lo a começar a aprender C++. Não se esqueça de se inscrever no meu canal e clicar no sininho de notificação para ficar atualizado sobre novos vídeos. Além disso, se você estiver interessado em se tornar um desenvolvedor e obter informações sobre a vida do desenvolvedor, siga-me no Instagram e no Twitter em @truecodebeauty (links na descrição do vídeo). Sem mais delongas, vamos mergulhar no assunto de hoje.
Um tipo de retorno de uma função pode ser qualquer tipo de dados, incluindo int, float, bool, char, double ou até mesmo tipos de dados definidos pelo usuário. Também pode ser void, indicando que a função não retorna nada. Em vídeos anteriores, expliquei que uma função é um bloco de código projetado para executar uma tarefa específica. As funções podem ser categorizadas em dois tipos: aquelas que retornam um valor e aquelas que não retornam.
As funções que não retornam um valor normalmente executam uma ação específica, como exibir um menu para o usuário. Por outro lado, as funções que retornam um valor são usadas para realizar cálculos ou operações e fornecer um resultado. É importante observar que uma função só pode retornar um valor e, uma vez encontrada a instrução return, a execução da função é interrompida.
Para ilustrar a importância das funções, vamos considerar um exemplo sem o uso de funções. Vamos criar um programa para determinar se um número é primo ou não. Um número primo é divisível apenas por um e por ele mesmo. Primeiro, vamos pedir ao usuário para digitar um número. Em seguida, iteramos todos os números entre 2 e o número inserido pelo usuário menos 1. Se o número for divisível por qualquer um desses valores, não é primo. Caso contrário, é primo. Por fim, exibiremos o resultado.
Agora, vamos refatorar o programa usando funções para tornar o código mais legível e reutilizável. Vamos criar uma função chamada "isPrimeNumber" que recebe um argumento inteiro e retorna um valor booleano indicando se o número é primo ou não. Dentro da função, implementaremos a mesma lógica de antes, verificando a divisibilidade e definindo um sinalizador de acordo. Por fim, retornaremos o valor do sinalizador.
Ao usar funções, podemos encapsular a lógica para determinar números primos, tornando o código mais fácil de entender e reutilizar.
C++ FUNCTIONS (2020) - O que é sobrecarga de funções? TUTORIAL DE PROGRAMAÇÃO
C++ FUNCTIONS (2020) - O que é sobrecarga de funções? TUTORIAL DE PROGRAMAÇÃO
Olá pessoal! Bem-vindo de volta ao meu canal. No vídeo de hoje, vamos mergulhar no conceito de sobrecarga de funções em C++. A sobrecarga de função nos permite criar várias funções com o mesmo nome, mas com parâmetros diferentes. Então, vamos explorar o que é sobrecarga de função e como ela funciona.
Para começar, vamos abrir nosso Visual Studio e criar uma função chamada "sum". Começaremos definindo o tipo de retorno da nossa função, que será um inteiro. Se você não estiver familiarizado com os tipos de retorno, recomendo assistir ao meu vídeo sobre o assunto (link fornecido). Em seguida, especificaremos o nome de nossa função como "soma" e declararemos dois parâmetros. Ambos os parâmetros serão do tipo inteiro e os nomearemos "a" e "b" respectivamente.
Agora, vamos criar outra função com o mesmo nome, "sum", mas desta vez com retorno do tipo double. Vamos declarar dois parâmetros do tipo double, denominados "a" e "b".
Além disso, vamos criar uma terceira função chamada "sum" com um tipo de retorno float. Desta vez, passaremos três parâmetros, todos do tipo float. Vamos nomeá-los "a", "b" e "c", respectivamente.
Após declarar nossas funções, notamos que elas estão sublinhadas, indicando que faltam suas definições. Vamos prosseguir fornecendo as definições para cada função. Começaremos com a primeira função que retorna um número inteiro.
Dentro das chaves, definiremos uma variável chamada "resultado" do tipo int. Atribuiremos a ela o valor de "a + b", que representa a soma dos dois parâmetros. Por fim, usaremos a palavra-chave "return" para retornar o valor de "resultado" da função.
Como alternativa, em vez de criar uma variável separada, podemos retornar diretamente a soma de "a" e "b" sem atribuí-la a uma variável. Isso pode tornar o código mais curto e mais legível.
A seguir, vamos definir a segunda função que retorna um double. Copiaremos a declaração, adicionaremos as chaves e, dentro dela, usaremos a palavra-chave "return" seguida de "a + b". Como os parâmetros são do tipo double, a soma será realizada com precisão dupla.
Agora, vamos definir a terceira função que retorna um float. Copiaremos a declaração, adicionaremos as chaves e, dentro dela, usaremos a palavra-chave "return" seguida de "a + b + c". Novamente, como todos os parâmetros são do tipo float, a soma será realizada de acordo.
Para testar nossas funções, vamos invocá-las na função "principal". Usaremos a instrução "cout" para exibir os resultados. Vamos começar chamando a primeira função, "sum", e passando dois valores inteiros, como 4 e 3. Vamos gerar o resultado usando "cout" e terminar a linha.
Quando executamos o programa, podemos esperar ver o resultado da soma de 4 e 3, que deve ser 7. Se o programa for executado com sucesso, testamos nossa primeira função.
Em seguida, vamos testar a segunda função chamando "sum" e passando dois valores duplos, como 4,4 e 3,3. Mais uma vez, exibiremos o resultado usando "cout" e terminaremos a linha.
Ao executarmos o programa, devemos ver o resultado da soma de 4,4 e 3,3, que deve ser 7,7. Se a saída estiver correta, testamos com sucesso nossa segunda função.
Finalmente, vamos testar a terceira função chamando "sum" e passando três valores flutuantes, como 4.4, 3.3 e 2.2. Vamos mostrar o resultado usando "cout" e terminar a linha.
A execução do programa deve exibir o resultado da soma de 4,4, 3,3 e 2,2, que deve ser a soma correta. Verifique a saída usando uma calculadora, se necessário.
Em resumo, o que demonstramos aqui é sobrecarga de função. Criamos três funções com o mesmo nome, "sum", mas com parâmetros e tipos de retorno diferentes. A primeira função leva dois inteiros, a segunda leva dois doubles e a terceira leva três floats. Quando invocamos essas funções, o compilador determina a função apropriada a ser chamada com base nos argumentos fornecidos.
A sobrecarga de função nos permite escrever um código mais conciso e legível usando o mesmo nome para funções que executam tarefas semelhantes. Não precisamos criar funções separadas com nomes diferentes para cada variação.
Espero que agora você entenda o conceito de sobrecarga de funções e como isso pode ser útil em C++. Se você gostou deste vídeo, por favor, inscreva-se no meu canal e clique no ícone de sininho para receber notificações de vídeos futuros. Você também pode me seguir em minhas outras plataformas de mídia social (links fornecidos na descrição).
Obrigado por assistir, e vejo você no meu próximo vídeo. Tchau!