Olá, seja bem-vindo de volta.
Eu gostaria de fornecer uma solução para desafio anterior nesta palestra.
Uma demonstração de como você pode ter ponteiros como elementos dentro da estrutura
e também passe em torno de ponteiros duas funções
que são estruturas.
Então, vamos trazer o código blocos, crie um novo projeto.
Isso vai ser um console aplicativo e vamos nomear este
exemplo de ponteiros de estrutura
E então, se você se lembrar do requisitos para
isso, era basicamente apenas um tipo de produto estrutura que armazenava um nome de item, uma quantidade,
um preço e um valor.
E o nome do item estava indo para ser um ponteiro de personagem.
Você ia ter um quantidade que basicamente multiplicou a
quantidade no preço.
E então tínhamos duas funções que terá como parâmetros
ponteiros para uma estrutura.
Então, a primeira coisa que somos vamos
fazer é criar nossa estrutura.
E eu mencionei isso antes, mas é bom
criar a estrutura globalmente porque se você quiser use-o em várias funções.
Criando a estrutura está realmente definindo isso.
Você não está alocando memória.
Então não há mal nenhum colocando-o globalmente.
E eles geralmente vão para dentro o arquivo de cabeçalho de qualquer maneira.
Então, para criar uma estrutura, nós apenas dizemos struct.
Vamos chamar este item, e vamos ter quatro elementos.
Vamos ter um personagem ponteiro, que vamos chamar apenas de
nome do item.
Vamos ter uma quantidade.
Nós vamos ter um float para o preço, e teremos
um float para o valor.
E é assim que podemos definir nossa estrutura, bem básica.
Agora, dentro de nossa função principal, nós deseja criar uma variável para o tipo de estrutura e
também um ponteiro.
Então, a primeira coisa que queremos fazer é que queremos apenas dizer struct item com
o nome da estrutura e então vamos chamar esse item.
E isso é apenas criando um ponteiro estranho.
Isso vai alocar memória para as quatro variáveis e elementos
dentro da estrutura.
E então queremos criar nosso ponteiro agora, e podemos apenas dizer item de estrutura.
Vamos dizer p item porque geralmente nomeamos nossos ponteiros
com o prefixo p.
Então dizemos o asterisco, e dizemos p item.
E então na próxima linha,
queremos apenas atribuir ao nosso item de ponteiro, nosso item.
Portanto, precisamos usar o endereço de e dizemos item.
E então aqui temos memória alocado para elementos em nossa estrutura para
nosso ponteiro.
Não temos memória alocado para o nosso ponteiro de caractere,
que é o nome do nosso item, então essa seria a próxima etapa.
Agora você pode perguntar por que precisamos para criar a estrutura do item.
Nós realmente não.
Poderíamos apenas criar o ponteiro e o ponteiro só criará memória para esse ponteiro
de item de estrutura.
Ele irá alocar memória para o int e floats,
mas ainda temos que fazer a alocação do nome do item.
Eu só gosto de fazer isso porque esta é geralmente a boa prática.
Normalmente o que você faria com a primeira estrutura de item é
que você o inicializaria e, teria alguma inicialização.
Mas não precisamos fazer isso.
Então, a primeira coisa que queremos fazer é alocar memória para o nome do nosso item.
Então, podemos basicamente usar um operador especial para acessar elementos se for
um ponteiro.
Lembre-se, para estruturas que são ponteiros, você tem o traço maior do que o
símbolo que você pode usar para acessar os elementos.
Caso contrário, você teria que remover a referência o ponteiro para acessar os elementos.
Poderíamos fazer algo como isso entre parênteses.
Poderíamos remover a referência do ponteiro, então
teríamos que fazer algo como star p item e, em seguida, usar o ponto para acessar os elementos.
Isso é perfeitamente válido para fazer algo assim.
Mas é uma espécie de sintaxe extra que você realmente não precisa.
Então c tem sintaxe especial que você pode usar sempre que sua estrutura for
um ponteiro se você deseja acessar os elementos.
Você pode basicamente dizer o nome do ponteiro que é p item e, em seguida,
use o traço maior que.
E, neste caso, queremos alocar memória para o nome do item.
Então, vamos atribuir a ele o que é retornado da função malloc.
Lembre-se, a função malloc retorna um ponteiro vazio.
Então, temos que lançar para uma estrela de personagem.
Mas podemos apenas chamar malloc, apenas digamos malloc e o tamanho dos
bytes que queremos criar.
Neste caso, diremos apenas 30, e vamos multiplicar pelo tamanho de char, apenas no
caso de char ser um tamanhos diferentes em computadores diferentes.
E isso vai alocar memória para o nome do nosso item.
Precisamos fazer isso porque o nome do item é um ponteiro dentro da estrutura.
Não tem memória alocado para ele quando você
o atribui a uma outra estrutura.
Portanto, temos que fazer isso.
Agora a primeira coisa que você quer a
fazer depois de alocar a memória é verificar o malloc.
portanto, queremos verificar se há nulo aqui.
Vamos apenas dizer se p item, se é nulo, o que diria que é nulo.
Caso contrário, você diria que se não, você poderia apenas diga voltar ou sair provavelmente seria melhor, saia do programa
se nós não foi capaz de alocar memória e você pode
passá-la para um negativo.
Caso contrário, queremos ler em um item, então queremos criar uma função.
A função que vamos para criar é chamado de item de leitura.
Vamos colocar uma declaração de função aqui em cima da estrutura.
Vai ser apenas leitura de dados na estrutura que passamos para ele.
Não vai retornar nenhum dado.
Então, podemos apenas dizer ler item e leva uma estrutura, e isso vai ser um
ponteiro.
Portanto, é um item de estrutura, asterisco I.
Agora podemos fazer disso uma constante então os valores mudam, mas
nós estamos mudando os valores.
Mas poderíamos dizer estrutura constante, o os valores não poderiam ser alterados para o ponteiro
para o qual ele está apontando.
Se fizéssemos a constante depois o asterisco, isso diria que o endereço não pode mudar
ou certo antes do asterisco algo assim depois
do nome.
Isso diria que o endereço não pode mudar, mas
isso é redundante porque estamos passando por valor de cópia.
Temos nosso item de leitura.
E enquanto estou aqui eu posso bem como meu item de impressão.
Essa só vai ser a função declaração, protótipo de função.
Aqui vai ser muito semelhante, também pegue um ponteiro.
Pode ter um espaço se quiser após o asterisco ou não?
Agora podemos definir nossa leitura item abaixo do nosso método principal.
E isso vai ler em valores do item e, em seguida,
calcule o valor total.
Então, podemos dizer void read item, tenha nosso ponteiro.
E aqui dentro, nós só queremos para usar alguns scanfs realmente.
Vamos imprimir algumas mensagens para dizer ao usuário para inserir informações.
Então, vamos dizer entre nome do produto e, em seguida, vamos
lê-lo.
Então, vamos dizer scanf, e temos um ponteiro para uma estrutura, para que possamos
acessá-la usando o traço então maior que.
Queremos ler para o scanf, o o nome do produto é um buffer de caracteres.
Então, queremos dizer por cento se então vamos dizer I, vamos armazená-lo no
nome do item.
E poderíamos voltar e usar o intellisense basta ir para o nome do item.
Não temos que usar o endereço do operador porque é
um ponteiro de caractere.
Queremos então imprimir e obter o preço,
provavelmente deseja adicionar alguns feeds de linha aqui, insira o preço.
Vamos armazenar isso na estrutura.
Portanto, novamente, o preço é flutuante.
Vou dizer por cento f, mas também vamos acessá-lo porque é um ponteiro, ainda queremos
use o traço então maior que.
Exceto desta vez, nós vamos diga o preço, e precisamos obter o endereço dele, então vamos coloque um
E comercial na frente dele porque o preço não
é um indicador.
E então vamos fazer o mesma coisa para a quantidade.
Portanto, a quantidade é um número inteiro.
Então podemos dizer porcentagem d, ainda precisamos para obter o
endereço dele, mas queremos armazená-lo em um elemento diferente, queremos armazená-lo na quantidade.
Agora que armazenamos ou pedimos o usuário insira três
itens de informação, agora podemos realmente calcular o valor, armazenado algo
no valor.
O valor é apenas o quantidade vezes o preço.
Então, ainda queremos acessar o estrutura usando nossa sintaxe, queremos
lançá-la, queremos assinar a quantidade vezes o preço.
E essa é a função de leitura do item.
Pega um ponteiro de estrutura.
E então, quando modificamos este ponteiro dentro do item lido, ele
será modificado fora da função.
Então, qualquer estrutura que nós passar para esta função, ela
será modificada.
Vai armazenar todos os itens, o nome do item, preço
e quantidade e quantidade.
Então isso lê os dados.
Neste ponto, você gostaria de teste e você provavelmente deseja
compilar e testar antes disso.
Mas agora podemos chamar o item de leitura método up em nosso principal e
repassá-lo em nossa estrutura que criamos.
Então podemos dizer ler item, e podemos apenas dizer p item.
Não temos que passar no endereço porque é um ponteiro,
então apenas passamos nossa estrutura.
E então a próxima coisa que nós o que podemos fazer é imprimi-lo.
E o que isso vai mostrar a você é que os dados são salvos,
p item está sendo modificado dentro da função e está sendo salvo fora da função,
a função principal realmente salvou esses valores.
Então, podemos dizer passagem de item de impressão no ponteiro novamente, e então podemos definir a função de
impressão do item.
O item de impressão é bastante básico.
Não retorna nada, então dizemos vazio e dizemos que o
item de impressão leva um ponteiro.
Então, nós apenas dizemos struct item star Eu, o que você quiser dar.
E então apenas imprimimos os dados para a estrutura que foi passada.
Então faríamos algo como printf nome por cento s, I nome do item, I preço,
I quantidade e I quantidade e, em seguida, formataremos os dados.
Qual é a última coisa que
temos para fazer principalmente depois de imprimir os dados, o função livre realmente importante.
Temos que ligar de graça porque nós deseja liberar a memória que alocamos para
o nome do item.
Então, podemos apenas dizer p item grátis e acesse o nome do item.
Não queremos libertar todo o estrutura
porque toda a estrutura será excluída no pilha quando a função retorna.
Queremos apenas libertar o que maltratamos
Nós apenas alocamos para o item nome para que possamos libertá-lo e, em
seguida, voltar do principal.
Então, vamos em frente e tente construir isso.
E temos um erro.
Vamos ver se diz struct item star.
Então, tivemos um erro onde as funções foram definidas acima
da estrutura.
Mas a função de tomar um parâmetro como um tipo de estrutura.
Portanto, temos que ter a estrutura definido acima onde o estamos usando.
Então eu movo as funções até as linhas 12 e 13.
Agora podemos compilar.
Vamos prosseguir e executar isso.
E vamos ver o que temos aqui.
Temos mais um erro.
Você tem que ter certeza de que verifique o item p para nulo.
Se você apenas disser se p item para verdade, sempre será verdade.
Então você pode verificar para dizer não é verdade com o
símbolo not significando que não é nulo ou pode verificar se é nulo.
Então, acabei de adicionar o nulo lá.
Agora vamos executá-lo, nós Deveria estar bom para ir.
Podemos inserir o nome do produto.
Diremos serial, e vamos digamos que o preço é 1. 99
E diremos que temos cinco deles.
E agora vamos imprimi-lo, e dizemos dólar de série 99.
5, o valor total é 9. 95
O preço embora eu não goste como o preço é impresso.
Então, vamos consertar isso.
Em nosso item de impressão, podemos apenas dizer para o preço para 2 f flutua,
agora vamos ficar um pouco melhor e vamos executá-lo.
Vamos pegar um pouco um pouco de melhor formato.
Quatro deles e agora isso parece um pouco melhor e está
tudo pronto para continuar.
Então, novamente, o programa básico usando estruturas e indicadores.
Criamos a estrutura no topo.
Temos um membro que contém um ponteiro, é muito
eficiente fazer isso porque podemos apenas copie e endereços em oposição
a matrizes de caracteres.
Temos nossas duas declarações de função, leia o item de impressão do item
que leva a destruição dos ponteiros
E então criamos o ponteiro e atribuí-lo a uma estrutura regular
dentro do nosso principal.
Alocamos memória na linha 22.
Certificamo-nos de que a memória é alocado com sucesso, caso não
saia do programa.
E então chamamos nossos dois funções que levam
ponteiros para estruturas, os transmitem.
E por último, mas não menos importante, liberamos a memória e saímos
do programa.
E as funções são bem direto.
Você pega aquele ponteiro.
Você acessa o ponteiro usando o traço então maior que.
E você consegue o endereço de para scanfs que não
possuem ponteiros como elementos.
E é basicamente isso.
Vou salvar este programa, você dá uma olhada nisso.
Deixe-me saber se você tiver alguma dúvida. Obrigada.