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

[edição não verificada][edição verificada]
Conteúdo apagado Conteúdo adicionado
Abacaxi (discussão | contribs)
Sem resumo de edição
Abacaxi (discussão | contribs)
Sem resumo de edição
Linha 84:
 
Então temos as seguintes situações:
* Criar colunas – queremos criar variáveis e funções membro
* Criar linhas – queremos criar instancias. (dentro e fora da declaração da estrutura)
* Definir funções membro fora da declaração da estrutura
* Atribuir/ler valores ás células
* Acrescentar colunas (após primeira iniciação)
* Acrescentar linhas (após primeira iniciação)
 
 
 
 
 
== Declarar instâncias (objectos) da estrutura ==
 
Podemos declarar os objectos de duas formas:
* Ao mesmo tempo que declaramos a estrutura
<pre>
struct product {
Linha 105 ⟶ 101:
} apple, banana, melon;
</pre>
* Ou como uma variável normal
<pre>
struct product
Linha 138 ⟶ 134:
</pre>
 
== Acessar as variáveis membro das estruturas ==
'''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;
<pre>
strcpy(p1.name, "Tiago");
p1.altura =1.9;
</pre>
 
A forma genérica é:
'''Pergunta''': como objectos podemos ter o quê?
<pre>
os objectos são como que constantes e não tanto como variáveis, ie, apenas estamos a chamar um nome a valores de variáveis.
structure-varname.member-name
por isso faz sentido poderemos ter arrays, afinal eles são apenas uma forma de criar vários nomes.
</pre>
e ponteiros? ter ponteiros apontar para onde? para outro objecto. sim pode fazer sentido.
e funções? não isto não me parece que faça sentido.
e estruturas?
 
ou seja
== Aceder as variáveis membro das estruturas ==
<pre>
[objecto_estrutura][member_estrutura]
</pre>
 
Exemplo
<pre>
#include <stdio.h>
const int MAX = 3;
struct Person
{
char name[100];
int height;
};
int main ()
{
Person p[MAX];
for (int x = 0; x < MAX; x++)
{
printf("Enter person's name: ");
getline(cin, p[x].name);
printf("Enter height in meters: ");
cin >> p[x].height;
}
printf("Outputting person data\n");
printf("======================\n");
for (int x = 0; x < MAX; x++){
cout << "Person #" << x + 1 << "'s name is "
<< p[x].name << " and height is "
<< p[x].height << endl;
}
return 0;
}
</pre>
 
== Iniciar uma estrutura ==
 
Podemos iniciar uma estrutura usando uma '''lista de 2iniciação''', que seria algo maneirascomo:
* Usando uma '''lista de iniciação'''
esta seria algo:
<pre>
Person p1 = {"Jeff Kent", 72};
Linha 161 ⟶ 193:
Person p1 = {72, "Jeff Kent"}; //não iria funcionar- erro de compilação
</pre>
 
== Ponteiros para estruturas ==
 
<pre>
struct movies_t
{
string title;
int year;
};
movies_t amovie;
movies_t * pmovie;
</pre>
 
Nós criámos algo
<pre>
movies_t title year
amovie
* pmovie
</pre>
 
Vejamos que temos um ponteiro como instância.
<pre>
// pointers to structures
#include <stdio.h>
struct movies_t
{
char title[100];
int year;
};
int main ()
{
string mystr;
movies_t amovie;
movies_t *pmovie;
pmovie = &amovie; //atribuímos valor ao ponteiro
printf("Enter title: ");
fgets(pmovie->title, 100, stdin); //operador ->
printf("Enter year: ";
scanf("%d", &pmovie->year);
printf("\nYou have entered:\n");
printf("%s (%d)\n", pmovie->title, pmovie->year); //operador ->
return 0;
}
</pre>
Como já devem ter deduzido o operador -> será muito similar a
pmovie->title é equivalente a (*pmovie).title
 
Mas olhem que é diferente a:
*pmovie.title que equivalente a *(pmovie.title)
 
== Passando estruturas com argumento do funções ==
A estrutura é passada como ponteiro.
 
<pre>
#include <stdio.h>
struct Person
{
string name;
int height;
};
void setValues(Person*);
void getValues(const Person*);
int main ()
{
Person p1;
setValues(&p1);
printf("Outputting person data\n");
printf("======================\n");
getValues(&p1);
return 0;
}
void setValues(Person* pers)
{
printf("Enter person's name: ");
fgets(pers.name, 100, stdin);
printf("Enter height in inches: ");
scanf("%d", &pers.height);
}
void getValues(const Person* pers)
{
printf("Person's name is %s and height is %d.", pers.name, pers.height);
}
</pre>
 
== Estruturas aninhadas ==
 
A ideia é ter uma estrutura dentro de outra estrutura.
<pre>
#include <stdio.h>
struct Date //estrutura chamada de date
{
int month;
int day;
int year;
};
struct Person
{
string name;
int height;
Date bDay; //temos uma nova variável, mas notem a tipologia
};
void setValues(Person*);
void getValues(const Person*);
int main ()
{
Person p1;
setValues(&p1);
printf("Outputting person data\n");
printf("======================\n");
getValues(p1);
return 0;
}
void setValues(Person* pers)
{
printf("Enter person's name: ");
fgets(pers.name, 100, stdin);
printf("Enter height in inches: ");
scanf("%d", &pers.height);
printf("Enter month, day and year of birthday separated by spaces: ");
cin >> pers.bDay.month >> pers.bDay.day >> pers.bDay.year;
}
void getValues(const Person* pers)
{
cout << "Person's name: " << pers.name << endl;
cout << "Person's height in inches is: " << pers.height << endl;
cout << "Person's birthday in mm/dd/yyyy format is: "
<< pers.bDay.month << "/" << pers.bDay.day
<< "/" << pers.bDay.year << endl;
}
</pre>
 
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.
 
 
 
 
 
'''Pergunta''': Por que não podemos acrescentar mais membros (campos) nas estruturas?
 
Porque elas são compiladas estaticamente com posição de memória já alocada e tipo já conhecido em tempo de compilação
 
'''Pergunta''': Ao invés de termos apenas variáveis nas estruturas poderíamos ter também funções?
 
Sim, como Ponteiros para funções.