Olá, seja bem-vindo de volta. Nesta aula, quero fornecer uma
demonstração de
nosso desafio anterior, que foi fazer com que você
entendesse como alocar memória dinamicamente usando malloc.
Faremos apenas uma leitura simples do teclado e, em
seguida, exibiremos uma string, mas vamos usá-la
com ponteiros alocados dinamicamente, ponteiros
de caracteres.
Então, vamos trazer blocos de código para criar um novo projeto.
E vamos apenas citar este exemplo de alocação de memória dinâmica.
E a primeira coisa que você precisa fazer
quando for utilizar a alocação dinâmica de memória é ter certeza de que está incluindo a biblioteca padrão.
Felizmente, quando você cria um projeto em blocos de código,
ele o inclui automaticamente para você.
Mas a razão pela qual precisamos incluir a lib padrão é porque malloc,
a função malloc está lá. E malloc, lembre-se, é a principal
função para alocar memória. Você também tem calloc.
Calloc é realmente importante porque calloc
fará alguns dos cálculos legais de quantos bytes você
precisa, porque são dois parâmetros.
Mas o que é realmente bom sobre calloc é que ele inicializa todos os dados
em zeros se eles forem ints e assim por diante, uma função muito boa.
Você tem realocar. Realloc irá estender a memória que
já foi alocada. Então você passa em um ponteiro.
A partir desse ponteiro, ele determina quanta memória é alocada
para ele e copia tudo o que estava lá para um novo local
de memória, e então você também especifica quantos bytes
a mais deseja alocar apenas adiciona-o ao novo local de memória, realmente bom recurso.
Mas lembre-se de que, ao alocar memória para inteiros usando malloc,
você deve determinar quanta memória deseja alocar bytes, mas geralmente
deseja usar o operador sizeof.
Então aqui vamos chegar a isso.
No meu método principal, criarei um inteiro e apenas direi
que será apenas o tamanho. vai inserir o tamanho de quantos bytes
eles desejam alocar em tempo de execução, então isso vai armazenar o tamanho.
A outra coisa que quero criar é um ponteiro char, e
isso será apenas texto. E vou inicializar isso
como null porque não está apontando para nada logo de cara.
Agora, a primeira coisa que quero fazer é pedir ao usuário para inserir o tamanho.
Então, vou dizer printf,
vou dizer insira o limite do texto.
E eles vão inserir um número para quantos bytes desejam ser alocados, na
verdade, o número de caracteres.
E então vou ler isso usando scanf.
Scanf, o primeiro parâmetro é o tipo do especificador de formato para o tipo dos dados.
Isso vai ser percentual d porque estou lendo um número inteiro.
E então lembre-se, o scanf pega um ponteiro.
Agora sabemos que funções que
levam ponteiros, você precisa de um endereço para passar.
Então, se vou passar em tamanho, tamanho não é um endereço a menos que eu use o endereço da operadora.
Então, vou para o e comercial e
direi o tamanho, que vai ler o número de bytes.
Assim que tiver o número de bytes, posso alocar memória para ele usando a função malloc.
E malloc irá retornar um ponteiro vazio.
E o ponteiro será o primeiro
endereço dessa memória recém-alocada. Assim, você pode atribuí-lo diretamente ao texto.
Porque lembre-se, o texto é um ponteiro.
Queremos apontar o texto para este novo endereço que está sendo retornado.
Como malloc retorna um ponteiro void, temos que lançá-lo.
O tipo de dado para o qual estamos apontando é um caractere, então queremos dizer char
star e, então, podemos chamar a função malloc.
A função malloc leva o número de bytes.
E então o número de bytes, se você acabou de passar o número de bytes, isso só
vai alocar aquela quantidade de bytes. Mas dependendo do tipo dos dados,
o tipo dos dados pode ser de dois ou quatro bytes.
Portanto, se você quiser alocar 10
caracteres, certifique-se de multiplicar
10 caracteres pelo tamanho de char.
Agora vamos
dizer n vezes sizeof. O operador sizeof é freqüentemente usado na
função malloc porque é independente
da máquina e dirá quanto você realmente precisa alocar.
Agora, isso é mais relevante quando você tem números inteiros. Lembre-se, inteiros, dependendo do sistema em
que você está, da arquitetura que está executando, os
inteiros podem ser representados por quatro bytes, dois bytes, geralmente
dois ou quatro bytes.
Se você dissesse que quero armazenar um inteiro, então
vou apenas criar quatro bytes de memória, bem, isso pode não estar
correto porque, e se forem dois bytes.
Portanto, você sempre deseja
fazer quantos inteiros ou quantos caracteres deseja criar e depois multiplicar pelo
tamanho do caractere em seu sistema. O operador Sizeof fornecerá o número de
bytes que um caractere ocupa. Portanto, se você quiser criar 10
caracteres, diga 10 vezes o tamanho do caractere. Se você quiser criar 10
inteiros para armazenar 10
inteiros, diga 10 vezes o tamanho de int, isso é realmente importante.
Agora, com a função calloc, você não precisa fazer isso. Na verdade, o
Calloc usa dois parâmetros. E o primeiro parâmetro
é o ponteiro, eu acho, e o
segundo parâmetro é o tamanho dos bytes.
Então, se você disser 24 int, tudo o que você faz é passar
apenas 24 e alocar automaticamente para você.
Portanto, calloc é uma ferramenta muito boa de usar porque você não precisa fazer essa multiplicação.
Portanto, para calloc, o primeiro parâmetro é o tamanho.
Portanto, se você quiser criar 10 int, basta passar 10.
E então o segundo parâmetro é
o tamanho do byte. Então você não precisa fazer a multiplicação. Isso economiza um pouco da etapa.
Agora que alocamos memória, você quer ter
certeza de que o texto não é nulo antes de tentar remover a referência do texto.
Portanto, você sempre deseja envolver isso em um texto não, e isso dirá que
não é nulo ou você pode apenas fazer explicitamente e dizer se
o texto não é igual a nulo.
Sempre quero fazer isso porque é muito,
muito perigoso tentar des-referenciar um ponteiro.
Tudo pode acontecer. Você pode ser capaz de gravar dados nele.
afim disso. Ele simplesmente o escreveria em algum outro lugar da memória. Portanto, isso
iria bagunçar o seu programa ou você pode ter uma falha de segmentação e o programa pode travar.
Mas, contanto que você realmente aloque essa memória,
agora você pode realmente ler alguns dados.
Você pode usar git s ou scanf aqui.
Mas o que você quer
fazer é imprimir, inserir algum texto e
também queremos adicionar alimentações de linha aqui para que sejam fáceis de ler.
E usaremos o scanf, pois é com isso que estamos familiarizados.
E o scanf vai apenas ler em
porcentagem.
Na verdade, vou te mostrar um truque.
Vou usar scanf para ler o próximo caractere para que
ele faça uma pausa e então usarei get s para ler o texto.
E gets é apenas outra função, geralmente você pode usar o f gets. Você apenas tem que configurá-lo para configurá-lo para
o fluxo de entrada.
Mas get vai ler o fluxo de entrada padrão, que por padrão é o teclado.
E get leva um ponteiro. Então tudo que temos que fazer é passar o
texto porque já é um ponteiro, não precisamos colocar o endereço do operador.
E a coisa boa com get pede é que você pode ler em várias strings separadas por espaços.
Assim que lemos os gets,
podemos apenas imprimi-lo. Portanto, podemos dizer texto inserido se inserido
for uma palavra por cento s barra invertida n e,
em seguida, texto de vírgula. O texto é um ponteiro.
Printf pega um ponteiro. Não temos que retirar sua referência.
Porque se você apenas exibir o
texto, o texto exibirá o valor do ponteiro que será um endereço.
Na verdade, queremos exibir o valor para o qual o texto está apontando.
E então terminamos. Oh não, definitivamente não terminamos. Queremos ligar para o nosso grátis.
Queremos liberar nosso ponteiro.
Mesmo assim, quando sairmos, a memória estará livre. Ainda queremos ter certeza de que
o liberamos e, provavelmente, também queremos apenas por segurança, queremos definir o texto igual a nulo.
Portanto, vamos construir isso e ver o que acontece.
E eu tenho um problema porque não estou lendo
na variável certa.
então aqui eu não estou usando a variável certa. Quero usar o tamanho e
parece
que estamos bem.
Então, vamos lá, a única diferença aqui é que você não precisa remover a
referência do texto porque o texto é um ponteiro de caractere.
Você só precisa remover a referência se estiver no ponteiro e assim por diante. Assim, quando você usa
o percentual s, ele automaticamente sabe como des-referenciar o
ponteiro do caractere.
Essa é uma diferença quando você usa ponteiros de caracteres
em relação a outros ponteiros. Os outros ponteiros você tem
que des-referenciar para obter o valor porque você não pode realmente copiar
strings para arrays de string e assim por diante.
Você nunca seria capaz de fazer o texto da estrela
igual a, você sempre teria que usar a cópia str se quiser copiar o texto.
Porque lembre-se das palestras, você não pode realmente
atribuir dados a um array, e um ponteiro de caractere é um array.
Então aqui parece correto. Não há razão para cancelar a referência.
Queremos construir isso e, em seguida, queremos executá-lo.
E você notará que colocamos o limite do texto.
Então digamos que colocamos 5, 6 para Jason e ele
imprime a entrada é Jason.
E você pode brincar com este programa. Mas, novamente, os resultados
disso incluem a biblioteca padrão quando você está fazendo malloc.
Inicialize seus ponteiros de personagem para nulo. Faça um scanf, use
o E comercial porque o tamanho não é um ponteiro.
Quando você está fazendo mallocing, malloc retorna um ponteiro void, então você tem que lançar.
Você sempre quer entrar no seu malloc. Faça o operador
sizeof para o que você deseja alocar. Vezes, quantos caracteres reais são
ou inteiros. Isso é mais aplicável a inteiros
e tipos de dados primitivos tecnicamente para caracteres. Você pode apenas fazer o tamanho, isso deve funcionar bem.
Você sempre deseja verificar se há nulo, certifique-se de que não seja nulo.
Quando você vai usar seqüência de caracteres.
E então apenas inserimos algum texto, armazenado em nosso arquivo, e o imprimimos.
E, por último, mas não menos importante, sempre queremos liberar nossos ponteiros para que
possamos devolvê-los à pilha. Espero que isto ajude. Obrigada.