Programar em C/Estruturas: diferenças entre revisões

== Declarar uma estrutura ==

A sintaxe é:

struct <identificador> {

<tipo> campo_um ;

<tipo> campo_dois ;

};

 

Aqui o tipo struct indica que vamos criar uma estrutura.

<b>Primeiro Método :</b><br>

 

struct minha_estrutura

{

char fruta[40];

} ;

 

Aqui o identificador do tipo "struct" é "minha_estrutura" dentro dessa estrutura temos três campos o ultimo é

 

Para ter acesso aos membros definidos dentro da estrutura utilizamos um operador de seleçao de membro "."(um ponto).

nova_estrutura.fruta[0] ;

Nos da o primeiro caracter da palavra contida dentro do membro "fruta".

 

== Matriz (uma maneira de ver a coisa) ==

 

{| border 1

|Person || String Name || int height

Podemos declarar os objectos ao de duas formas:

* Ao mesmo tempo que declaramos a estrutura

struct product {

int weight;

float price;

} apple, banana, melon;

* Ou como uma variável normal

struct product

{

product apple, banana, melon;

}

E até podemos declarar um array delas

Person p[20];

 

Para cada objecto vão ser feito uma cópia dos elementos da estrutura.

Agora isso significa que os objectos são distintos entre si em termos de reserva de memória? ie, á medida que enumero os objectos vão ser reservado para cada objecto o tamanho x de bytes? ou somam-se todos os objectos e reserva-se para todos os objectos de uma forma seguida? Penso que deve ser a 1ª opção.

 

Se tivermos apenas um objecto (ou variável da estrutura) não é necessário darmos o nome da estrutura

struct {

char item[40]; // name of item

int lead_time; // number of days before resupply

} temp;

 

'''Pergunta''': neste caso como é que chamamos o objecto fora da declaração da estrutura?

 

Agora queremos dar valores a cada uma das pessoas, queremos dar o nome e a altura, para isso faríamos;

 

Se quiséssemos imprimir o valor guardado

cout << "The name of p1 is " << p1.name;

 

Um '''erro''' usual é fazer

 

A forma genérica é:

structure-varname.member-name

ou seja é o

[objecto_estrutura][member_estrutura]

 

 

Exemplo

#include <iostream>

#include <string>

return 0;

}

 

== Iniciar uma estrutura ==

* Usando uma '''lista de iniciação'''

esta seria algo:

Person p1 = {"Jeff Kent", 72};

isto basicamente é igual a arrays, apenas com a diferença de termos tipologias diferentes. Logo a ordem vai interessar, por exemplo se escrevêssemos

 

* Usando '''construtores'''

Os construtores são funções que são criadas automaticamente sempre que tentamos criar um objecto. A esses que são criados automaticamente são os chamados de defaut.

Se escrevermos o código

#include <iostream>

#include <string>

return 0;

}

 

O resultado é

 

Podemos ter um constructor sem argumentos que ao contrário do defaut constructor designa valores defaut ás variáveis membro.

struct Person

{

}

};

 

* O nome do constructor é sempre igual ao nome da estrutura, sem excepção.

 

Refazendo o nosso exemplo

#include <iostream>

#include <string>

return 0;

}

 

Repare que demos valores defaut ás variáveis. Agora não estamos no caso de ter p1.name=???

Termos um constructor sem argumentos é um melhoramento face ao defaut constructor pois agora temos valores defaut para as variáveis membro.

Porém seria melhor se conseguíssemos inicializar as variáveis membro com valores dados pelo utilizador enquanto o programa estivesse e a correr. E realmente podemos fazer se passarmos argumentos.

#include <iostream>

#include <string>

return 0;

}

Repare que os argumentos do construtor têm de estar na ordem esperada

 

 

== Separar o constructor prototype da implementação ==

#include <iostream>

#include <string>

return 0;

}

 

* Vamos ver a função main(): declarámos 2 variáveis uma int e outra string. Pedimos para a pessoa escrever o nome e colocámos o valor na variável string, depois pedimos a altura e colocámos na variável int. Depois chamámos o constructor com dois argumentos e passamos as variáveis anteriores como argumentos. Por fim mandámos imprimir no ecrã os valores das variáveis membro da estrutura.

* Repare que para definirmos fora o construtor recorremos ao operador scope ::

Person::Person()

Person::Person(string s, int h)

* Repare que no prototype dos constructor apenas tivemos de dizer a tipologia dos parâmetros

 

 

A ideia é ter uma estrutura dentro de outra estrutura.

#include <iostream>

#include <string>

<< "/" << pers.bDay.year << endl;

}

 

Reparem que a estrutura Date tem de ser declarada antes da estrutura Person, pois caso contrário o compilador não entendia a tipologia declarada na estrutura Person.

 

Agora para termos os valores da estruturura é

cin >> pers.bDay.month >> pers.bDay.day >> pers.bDay.year;

 

== Passando estruturas com argumento do funções ==

#include <iostream>

#include <string>

cout << "Person's name is " << pers.name << " and height is " << pers.height << endl;

}

 

A estrutura é passada por referência ou por address

== Ponteiros para estruturas ==

 

struct movies_t

{

movies_t amovie;

movies_t * pmovie;

 

Nós criámos algo

movies_t title year

amovie

* pmovie

 

Vejamos que temos um ponteiro como instância.

// pointers to structures

#include <iostream>

return 0;

}

Como já devem ter deduzido o operador -> será muito similar a

 

Mas olhem que é diferente a: