>> [Música tocando]
>> DOUG LLOYD: OK.
Nós trabalhamos com números inteiros, nós trabalhamos com os personagens,
temos trabalhado carros alegóricos, duplos, strings e bools.
Nós já esgotou praticamente todos dos [inaudível] tipos que
estiveram disponíveis para todos nós junto.
Mas agora queremos fazer algo mais.
Como fazemos isso?
Como podemos criar diferentes tipos de dados?
Podemos fazer isso usando estruturas.
Então estruturas permitirá a unificação variáveis ​​de diferentes tipos
em um único, novo tipo de variável, qual podemos atribuir o seu próprio nome de tipo.
Este é realmente um forte coisa a ser capaz de fazer,
porque nós podemos agora grupo elementos de diferentes tipos de dados
juntos, que têm uma ligação lógica.
Temos sido capazes de fazer isso com matrizes tipo de, certo?
Nós podemos variáveis ​​do grupo do mesmo tipo de dados
juntos numa unidade grande de memória, uma matriz.
>> Mas não temos sido capazes de misturar até diferentes tipos de dados em conjunto.
Não podemos, por exemplo, associar um número inteiro, e um personagem, e um duplo tudo
na mesma coisa e chamar que uma única unidade.
Mas com as estruturas, ou frequentemente referido como estruturas,
nós realmente pode.
Assim, uma estrutura é uma espécie de como uma variável super.
É uma variável que contenha outras variáveis ​​dentro do mesmo.
Então aqui está um exemplo de uma estrutura muito simples.
Isto é o que a sintaxe ficaria como para criar uma estrutura de um carro.
Agora, vamos passar a sintaxe aqui.
Struct, que é a palavra-chave que indica
que eu estou criando um novo tipo de dados aqui.
Em particular, o nome do tipo de dados é vai ser carro struct, como veremos.
Mas este é o tipo de ponta off para o compilador que este
como um grupo de variáveis ​​que está acontecendo para ser considerado parte do mesmo tipo
em um minuto.
>> Carros, apenas o nome da estrutura.
Mais uma vez, o tipo de dados aqui vai ser o carro struct, não apenas carro.
Mas se você tem diferente-- se você criar várias estruturas
no mesmo programa, você precisa distinguir entre e struct.
Carro para struct, eu também pode ter estudante struct, por exemplo,
no mesmo programa.
Dentro das chaves são todos os campos chamados,
ou os membros da estrutura.
Então, quais são algumas das coisas que são inerentes em um carro?
Bem, ele tem geralmente um ano, tem um nome de modelo, e uma placa de licença,
um conta-quilómetros que tem geralmente um certo número de milhas sobre ele,
e talvez um tamanho do motor.
E como você pode ver, eu estou misturando-se inteiros e caracteres e duplas.
Eles estão todos indo para ser parte deste novo tipo de dados.
>> Por fim, a última coisa que eu preciso fazer, não se esqueça este pequeno ponto e vírgula
no fim.
Depois que terminar de definir a estrutura, é preciso colocar um ponto e vírgula no final.
É uma sintática muito comum erro, porque com uma função,
por exemplo, você teria apenas chaveta aberta, perto chaveta.
Você não colocou um ponto e vírgula no final de uma definição de função.
Isto parece uma função definição, mas não é,
e assim o ponto e vírgula não é apenas um lembrete de que você
precisa colocá-lo lá, porque o compilador de outra forma não vai
sabe o que fazer com ele.
É um erro muito comum para fazer acidentalmente
quando você está definindo primeiro estruturas.
>> ESTÁ BEM.
Então, nós geralmente definir as nossas estruturas no topo dos nossos programas
porque provavelmente está indo para ser utilizado por várias funções.
Nós não queremos definir uma struct dentro de uma função,
porque então nós podemos only-- o âmbito da estrutura realmente
só existe dentro dessa função.
Nós provavelmente gostaria de definir uma estrutura para que possamos usá-lo em múltiplas funções,
ou talvez em múltiplos arquivos que são amarrados
para criar o nosso programa único.
Às vezes, também, em vez de definir a estrutura
no topo, onde você colocar o seu libra e inclui a sua libra define,
por exemplo, você pode colocá-los em arquivos dot h separados, que você, em seguida,
libra incluir a si mesmo.
>> Portanto, temos estruturas, mas agora precisamos começar dentro deles.
Como é que vamos ficar por dentro de uma estrutura para acesso
esses sub-variáveis, essas variáveis que existe no interior da estrutura?
Bem, nós temos uma coisa chamada o operador ponto, o que nos permite
para acessar os campos da estrutura.
Assim, por exemplo, digamos que eu tenho declarado meus dados estrutura do tipo em algum lugar
no topo do meu programa, ou talvez em um arquivo dot h que eu tenho libra incluído.
Ora, se eu quiser criar um novo variável desse tipo de dados, o que posso dizer,
struct carro, meu carro, ponto e vírgula.
Assim como eu poderia dizer int x, ou nome da seqüência ponto e vírgula.
>> O tipo de dados aqui é carro struct, o nome da variável é o meu carro,
e então eu posso usar o operador ponto para acessar os vários campos de meu carro.
Então eu posso dizer o meu carro ano ponto é igual a 2,011.
Isso é perfeitamente bem.
Ano, se você se lembra, foi definida como um campo inteiro dentro deste carro struct
tipo de dado.
Assim, qualquer variável dos dados carro struct tipo, como meu carro, posso dizer que o meu carro
ano ponto é igual a e depois atribuir -lhe algum valor inteiro de 2011.
Meu ponto é igual a placa do carro CS50.
Meu hodômetro cartão de ponto é igual a 50505 ponto e vírgula.
Todos esses são perfeitamente bem e isso é
como podemos acessar o campos da estrutura.
Estruturas, no entanto, não é necessário a ser criado na pilha.
Assim como qualquer outra variável, pode alocá-los dinamicamente.
Se temos um programa que pode estar gerando muitas estruturas,
nós não sabemos quantas nós vamos precisar,
então precisamos dinamicamente alocar essas estruturas
como o nosso programa está sendo executado.
E por isso, se nós estamos indo para acessar o campos de uma estrutura nesse contexto,
Lembre-se que primeiro precisamos dereference o apontador para a estrutura,
e, em seguida, uma vez que a remoção de referência ponteiro, então podemos acessar os campos.
Se temos apenas um Ponteiro para a estrutura,
não podemos apenas dizer campo ponteiro dot nome e obter o que estamos procurando.
Há a etapa extra de dereferencing.
Então, vamos dizer que em vez do previous--
tal como no exemplo anterior, em vez de declará-lo
na pilha, carro struct, meu carro, ponto e vírgula, eu digo carro struct,
estrela, um ponteiro para uma carro struct chamado meu carro,
equivale ao tamanho de malloc de carro struct.
Tamanho vamos descobrir quantas bytes seu novo tipo de dados ocupa.
Você não necessariamente só precisa usar tamanho, largura, int ou char, ou qualquer
dos tipos de dados embutidos.
O compilador é inteligente o suficiente para descobrir quantos bytes
são obrigados por sua nova estrutura.
Então eu me malloc unidade de memória grande o suficiente para segurar um carro struct,
e eu recebo um ponteiro de volta para esse bloco de memória,
e esse ponteiro é atribuído para o meu carro.
>> Agora, se eu quiser o acesso os campos do meu carro,
I primeiro dereference meu carro usando o operador de remoção de referência, estrela
que temos visto desde os ponteiros vídeos, e, em seguida, depois que eu dereference,
então eu posso usar o operador ponto para acessar os vários campos de meu carro.
Estrelar meu carro dot ano é igual a 2011.
Isso teria o efeito queremos neste caso,
porque nós temos dinamicamente alocados meu carro.
>> Isso é meio chato, certo?
Há um processo de 2 passos agora.
Agora temos que dereference-- temos um operador de estrela,
e temos um operador ponto.
E como você poderia esperar, porque Programadores C amo caminhos mais curtos
para fazer as coisas, há uma caminho mais curto para fazer isso.
Há um outro operador chamado de flecha, o que torna este processo muito mais fácil.
A forma como funciona é seta ele primeiro dereferences
o ponteiro do lado esquerdo lado do operador,
e, em seguida, depois de ter desreferenciado o ponteiro à esquerda,
ele acessa o campo à direita.
E assim já tivemos esse tipo de Star meu carro dot todo este material,
como não havia muita coisa acontecendo lá.
Mas o que podemos fazer é, em vez isto-- meu ano seta carro é igual a 2011.
>> Novamente, o que está acontecendo aqui?
Em primeiro lugar, eu estou dereferencing meu carro.
Que por sua vez, é um ponteiro aqui.
Em seguida, depois de ter desreferenciado meu carro, eu
pode, então, acessar os campos ano, prato, e conta-quilómetros
assim como eu poderia antes de ter primeiro estrela usado para eliminar referência o meu carro,
e ponto para acessar o campo.
Então você pode ter estruturas, você pode ter ponteiros para estruturas,
e você tem maneiras de acesso os domínios dessas estruturas,
se você tem ponteiros para -los ou as próprias variáveis.
Dot ou seta, dependendo como a variável foi declarada.
Eu sou Doug Lloyd, este é CS50.