Artigo Diretório
1. Noções básicas de matrizes de objetos
O método de declarar um array de objetos é o mesmo que declarar um array de tipos padrão:
stock mystuff[4];// creates an array of 4 Stock objects
quando o programa cria um objeto de classe que não é inicializado explicitamente, o construtor padrão é sempre chamado. A declaração acima requer que esta classe não defina explicitamente nenhum construtor (neste caso, um construtor padrão implícito que não faz nada será usado) ou defina um construtor padrão explícito (como este exemplo Dessa forma). Cada elemento (mystuff [0], mystuff [1], etc.) é um objeto Stock, e você pode usar o método Stock:
// apply update() to 1st element
mystuff[0].update();
// apply show() to 4th element
mystuff[3].show();
const Stock * tops = mystuff[2].topval(mystuff[1]);
// compare 3rd and 2nd elements and set tops
// to point at the one with a higher total value
Você pode usar o construtor para inicializar os elementos da matriz. Nesse caso, o construtor deve ser chamado para cada elemento:
const int STKS =4;
Stock stocks [STKS] = {
Stock("NanoSmart",12.5,20),
Stock("Boffo Objects",200,2.0),
Stock("Monolithic Obelisks",130,3.25),
Stock("Fleep Enterprises",60,6.5)
};
O código aqui inicializa a matriz usando um formato padrão: uma lista separada por vírgulas de valores entre parênteses.
Entre eles, cada chamada do construtor representa um valor.
Se a classe contém vários construtores, você pode usar diferentes construtores para diferentes elementos:
const int STKS = 10;
Stock stocks [STKS] = {
Stock("NanoSmart",12.5,20),
Stock(),
Stock("Monolithic Obelisks",130,3.25),
};
O código acima usa o Stock(const string & co,long n,double pr)estoque de inicialização [0] e o estoque [2], e usa o construtor Stock () para inicializar o estoque [1].
Uma vez que esta declaração inicializa apenas parte dos elementos do array, os 7 elementos restantes serão inicializados usando o construtor padrão.
O esquema de inicialização de um array de objetos é primeiro criar um elemento do array usando o construtor padrão, então o construtor entre chaves criará um objeto temporário e então copiará o conteúdo do objeto temporário para o elemento correspondente.
Portanto, para criar uma matriz de objetos de classe, essa classe deve ter uma estrutura padrão.
2. Um exemplo que demonstra uma série de objetos
1. Você pode criar com êxito uma matriz de objeto sem fornecer um construtor padrão?
object_array.cpp
#include <iostream>
#include <string>
/*
author:梦悦foundation
公众号:梦悦foundation
可以在公众号获得源码和详细的图文笔记
*/
using namespace std;
const int SIZE = 3;
class Demo {
private:
int iDemo;
string str;
public:
Demo(int iDemo, const string & str);
void Show();
};
Demo::Demo(int iDemo, const string &str = "meng-yue")
{
this->iDemo = iDemo;
this->str = str;
}
void Demo::Show()
{
cout << "iDemo:" << iDemo << ", str:" << str << endl;
}
int main(int argc, char *argv[])
{
int i = 0;
cout << "---------------开始--->公众号:梦悦foundation---------------" << endl;
Demo d[SIZE];
for (i = 0; i < SIZE; i++) {
cout << "d[" << i << "]:";
d[i].Show();
}
cout << "---------------结束--->公众号:梦悦foundation---------------" << endl;
return 0;
}
Demo d[SIZE];Crie 3 instâncias da classe Demo, que chamará o construtor padrão.
A compilação reportará um erro porque nenhum construtor padrão é fornecido!
object_array.cpp: In function ‘int main(int, char**)’:
object_array.cpp:35:13: error: no matching function for call to ‘Demo::Demo()’
Demo d[SIZE];
^
object_array.cpp:20:1: note: candidate: Demo::Demo(int, const string&)
Demo::Demo(int iDemo, const string &str = "meng-yue")
^~~~
object_array.cpp:20:1: note: candidate expects 2 arguments, 0 provided
object_array.cpp:11:7: note: candidate: Demo::Demo(const Demo&)
class Demo {
^~~~
object_array.cpp:11:7: note: candidate expects 1 argument, 0 provided
object_array.cpp:11:7: note: candidate: Demo::Demo(Demo&&)
object_array.cpp:11:7: note: candidate expects 1 argument, 0 provided
meng-yue@ubuntu:~/MengYue/c++/object_class/04$
Existem duas maneiras de resolver esse problema, uma é fornecer um construtor padrão e a outra é adicionar valores padrão aos construtores existentes.
1. Fornece um construtor padrão
object_array01.cpp
class Demo {
private:
int iDemo;
string str;
public:
Demo();
Demo(int iDemo, const string & str);
void Show();
};
Demo::Demo(int iDemo, const string &str = "meng-yue")
{
this->iDemo = iDemo;
this->str = str;
}
Demo::Demo()
{
this->iDemo = 1;
this->str = "default";
}
Desta forma, a compilação não relatará erros e pode ser executada com sucesso.
Resultado corrente: todos os valores iniciais padrão são impressos
meng-yue@ubuntu:~/MengYue/c++/object_class/04$ ./object_array
---------------开始--->公众号:梦悦foundation---------------
d[0]:iDemo:1, str:default
d[1]:iDemo:1, str:default
d[2]:iDemo:1, str:default
---------------结束--->公众号:梦悦foundation---------------
meng-yue@ubuntu:~/MengYue/c++/object_class/04$
2. Altere o construtor original para um método com parâmetros padrão
object_array02.cpp
class Demo {
private:
int iDemo;
string str;
public:
Demo(int iDemo, const string & str);
void Show();
};
Demo::Demo(int iDemo = 3, const string &str = "meng-yue")
{
this->iDemo = iDemo;
this->str = str;
}
Desta forma, o construtor com valores padrão para todos os parâmetros também é correspondido!
resultado da operação:
meng-yue@ubuntu:~/MengYue/c++/object_class/04$ ./object_array02
---------------开始--->公众号:梦悦foundation---------------
d[0]:iDemo:3, str:meng-yue
d[1]:iDemo:3, str:meng-yue
d[2]:iDemo:3, str:meng-yue
---------------结束--->公众号:梦悦foundation---------------
meng-yue@ubuntu:~/MengYue/c++/object_class/04$
3. Pensando: e se houver dois construtores? Ele relatará um erro?
object_array03.cpp
class Demo {
private:
int iDemo;
string str;
public:
Demo();
Demo(int iDemo, const string & str);
void Show();
};
Demo::Demo(int iDemo = 3, const string &str = "meng-yue")
{
this->iDemo = iDemo;
this->str = str;
}
Demo::Demo()
{
this->iDemo = 1;
this->str = "default";
}
Resultado da compilação:
meng-yue@ubuntu:~/MengYue/c++/object_class/04$ g++ -o object_array03 object_array03.cpp
object_array03.cpp: In function ‘int main(int, char**)’:
object_array03.cpp:43:13: error: call of overloaded ‘Demo()’ is ambiguous
Demo d[SIZE];
^
object_array03.cpp:21:1: note: candidate: Demo::Demo(int, const string&)
Demo::Demo(int iDemo = 3, const string &str = "meng-yue")
^~~~
object_array03.cpp:27:1: note: candidate: Demo::Demo()
Demo::Demo()
^~~~
meng-yue@ubuntu:~/MengYue/c++/object_class/04$
Erro de compilação, porque esses dois construtores podem ser chamados, o compilador não sabe qual chamar, então um erro é relatado!
4. Construtor para inicializar os elementos do array.Neste caso, o construtor deve ser chamado para cada elemento.
object_array04.cpp
#include <iostream>
#include <string>
/*
author:梦悦foundation
公众号:梦悦foundation
可以在公众号获得源码和详细的图文笔记
*/
using namespace std;
const int SIZE = 3;
class Demo {
private:
int iDemo;
string str;
public:
Demo();
Demo(int iDemo, const string & str);
void Show();
};
Demo::Demo(int iDemo, const string &str = "meng-yue")
{
cout << "Demo(int iDemo = " << iDemo << ", string = " << str << ")" << endl;
this->iDemo = iDemo;
this->str = str;
}
Demo::Demo()
{
cout << "Demo()" << endl;
this->iDemo = 1;
this->str = "default";
}
void Demo::Show()
{
cout << "iDemo:" << iDemo << ", str:" << str << endl;
}
int main(int argc, char *argv[])
{
int i = 0;
cout << "---------------开始--->公众号:梦悦foundation---------------" << endl;
Demo d[SIZE] = {
Demo(7, "1-meng-yue"),
Demo(),
Demo(8, "2-meng-yue")
};
for (i = 0; i < SIZE; i++) {
cout << "d[" << i << "]:";
d[i].Show();
}
cout << "---------------结束--->公众号:梦悦foundation---------------" << endl;
return 0;
}
resultado da operação!
meng-yue@ubuntu:~/MengYue/c++/object_class/04$ g++ -o object_array04 object_array04.cpp
meng-yue@ubuntu:~/MengYue/c++/object_class/04$ ./object_array04
---------------开始--->公众号:梦悦foundation---------------
Demo(int iDemo = 7, string = 1-meng-yue)
Demo()
Demo(int iDemo = 8, string = 2-meng-yue)
d[0]:iDemo:7, str:1-meng-yue
d[1]:iDemo:1, str:default
d[2]:iDemo:8, str:2-meng-yue
---------------结束--->公众号:梦悦foundation---------------
meng-yue@ubuntu:~/MengYue/c++/object_class/04$
O código acima é equivalente a
d[0] = Demo(7, "1-meng-yue");
d[1] = Demo();
d[2] = Demo(8, "2-meng-yue");