Programar em C++/Estruturas: diferenças entre revisões
| [edição verificada] | [edição verificada] |
Conteúdo apagado Conteúdo adicionado
Movido do livro de C |
|||
Linha 84:
As estruturas em C++ também podem conter funções além de dados. Este fato vem da idéia de modelo de objeto que as estruturas mantém nesta linguagem. Objetos devem ter propriedades (variáveis) e métodos (funções membro), por isso temos a possibilidade de criar funções dentro do corpo das estruturas, com a finalidade de lidar com os dados que elas mantém.
== Construtores ==
Os construtores são funções que são criadas automaticamente sempre que tentamos criar um objeto. Eles funcionam da mesma maneira que construtores de classe. A esses que são criados automaticamente são os chamados de defaut.
Se escrevermos o código
<pre>
#include <iostream>
#include <string>
using namespace std;
const int MAX = 3;
struct Person
{
string name;
int height;
};
int main ()
{
Person p1;
cout << "The person's name is " << p1.name << " and height is " << p1.height << endl;
system (“pause”);
return 0;
}
</pre>
O resultado é
The person's name is and height is -858993460
Aqui é criado um defaut constructor no momento em que criamos a instancia p1 ie com a linha Person p1;
Como as variáveis membro não foram iniciadas, o valor de name está vazio e o na variável height está um valor qualquer – que é lixo!
;Constructor sem argumentos
Podemos ter um constructor sem argumentos que ao contrário do defaut constructor designa valores defaut ás variáveis membro.
<pre>
struct Person
{
string name;
int height;
Person() //constructor sem argumentos
{
name = "No name assigned";
height = -1;
}
};
</pre>
*O nome do constructor é sempre igual ao nome da estrutura, sem excepção.
*O constructor não retorna qualquer valor, sem excepção
Refazendo o nosso exemplo
<pre>
#include <iostream>
#include <string>
using namespace std;
const int MAX = 3;
struct Person {
string name;
int height;
Person()
{
name = "No name assigned";
height = -1;
}
};
int main ()
{
Person p1;
cout << "The person's name is "<< p1.name << " and height is " << p1.height << endl;
system (“pause”);
return 0;
}
</pre>
Repare que demos valores defaut ás variáveis. Agora não estamos no caso de ter p1.name=???
Por mais instâncias que criemos eles vão ter sempre valores padrão.
;Constructor com argumentos
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.
<pre>
#include <iostream>
#include <string>
using namespace std;
const int MAX = 3;
struct Person
{
string name;
int height;
Person() //constructor sem argumentos
{
name = "No name assigned";
height = -1;
}
Person(string s, int h) //constructor com 2 argumentos
{
name = s;
height = h;
}
};
int main ()
{
int metro;
string strName;
cout << "Entre com o nome da pessoa: ";
getline(cin, strName);
cout << "Enter height in metro: ";
cin >> metro;
cin.ignore();
Person p1(strName,metro);
cout << "The person's name is " << p1.name << " and height is " << p1.height << endl;
system (“pause”);
return 0;
}
</pre>
Repare que os argumentos do construtor têm de estar na ordem esperada
;Separar o constructor prototype da implementação
<pre>
#include <iostream>
#include <string>
using namespace std;
const int MAX = 3;
struct Person {
string name;
int height;
Person(); //constructor sem argumento
Person(string, int); //constructor com dois parametros, apenas é necessário dizer a tipologia dos parâmetros – o nome não é necessário)
};
Person::Person()
{
name = "No name assigned";
height = -1;
}
Person::Person(string s, int h)
{
name = s;
height = h;
}
int main ()
{
int metro;
string strName;
cout << "Enter person's name: ";
getline(cin, strName);
cout << "Enter height in inches: ";
cin >> metro;
cin.ignore();
Person p1(strName, inches);
cout << "The person's name is " << p1.name << " and height is " << p1.height << endl;
system (“pause”);
return 0;
}
</pre>
* 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 ::
<pre>
Person::Person()
Person::Person(string s, int h)
</pre>
* Repare que no prototype dos constructor apenas tivemos de dizer a tipologia dos parâmetros
{{Indentar/fim}}
| |||