Array de objetos:
cuando se define una clase, solo se define la especificación del objeto; no se asigna memoria ni almacenamiento. Para usar las funciones de datos y acceso definidas en la clase, debe crear objetos.
Sintaxis:
ClassName ObjectName[number of objects];
Diferentes métodos para inicializar el Array de objetos con constructores parametrizados :
1. Usar un montón de llamadas a funciones como elementos de la array: es como una declaración de array normal, pero aquí inicializamos la array con llamadas a funciones del constructor como elementos de esa array.
C++
#include <iostream>
using namespace std;
class Test {
// private variables.
private:
int x, y;
public:
// parameterized constructor
Test(int cx, int cy)
{
x = cx;
y = cy;
}
// method to add two numbers
void add() { cout << x + y << endl; }
};
int main()
{
// Initializing 3 array Objects with function calls of
// parameterized constructor as elements of that array
Test obj[] = { Test(1, 1), Test(2, 2), Test(3, 3) };
// using add method for each of three elements.
for (int i = 0; i < 3; i++) {
obj[i].add();
}
return 0;
}
2. Usando malloc() : Para evitar la llamada de un constructor no parametrizado, use el método malloc(). El método «malloc» o «asignación de memoria» en C++ se usa para asignar dinámicamente un solo bloque grande de memoria con el tamaño especificado. Devuelve un puntero de tipo void que se puede convertir en un puntero de cualquier forma.
C++
#include <iostream>
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterized constructor
Test(int x, int y)
{
this->x = x;
this->y = y;
}
// function to print
void print() { cout << x << " " << y << endl; }
};
int main()
{
// allocating dynamic array
// of Size N using malloc()
Test* arr = (Test*)malloc(sizeof(Test) * N);
// calling constructor
// for each index of array
for (int i = 0; i < N; i++) {
arr[i] = Test(i, i + 1);
}
// printing contents of array
for (int i = 0; i < N; i++) {
arr[i].print();
}
return 0;
}
0 1 1 2 2 3 3 4 4 5
3. Uso de palabra clave nueva : el operador nuevo denota una solicitud de asignación de memoria en el montón. Si hay suficiente memoria disponible, el operador new inicializa la memoria y devuelve la dirección de la memoria recién asignada e inicializada a la variable de puntero. Aquí, pointer-variable es el puntero de tipo data-type. El tipo de datos podría ser cualquier tipo de datos incorporado, incluida la array, o cualquier tipo de datos definido por el usuario, incluidas la estructura y la clase.
Para la inicialización dinámica, la nueva palabra clave requiere un constructor no parametrizado si agregamos un constructor parametrizado. Así que usaremos un constructor ficticio para ello.
C++
#include <iostream>
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// dummy constructor
Test() {}
// parameterized constructor
Test(int x, int y)
{
this->x = x;
this->y = y;
}
// function to print
void print() { cout << x << " " << y << endl; }
};
int main()
{
// allocating dynamic array
// of Size N using new keyword
Test* arr = new Test[N];
// calling constructor
// for each index of array
for (int i = 0; i < N; i++) {
arr[i] = Test(i, i + 1);
}
// printing contents of array
for (int i = 0; i < N; i++) {
arr[i].print();
}
return 0;
}
0 1 1 2 2 3 3 4 4 5
Si no usamos el compilador del constructor ficticio, mostraría el error que se muestra a continuación
Error del compilador:
error: no matching function for call to ‘Test::Test()’
Test *arr=new Test[N];
4. Uso de puntero doble (concepto de puntero a puntero) : un puntero a un puntero es una forma de múltiples direcciones indirectas, o una string de punteros. Normalmente, un puntero contiene la dirección de una variable. Cuando definimos un puntero a un puntero, el primer puntero contiene la dirección del segundo puntero, que apunta a la ubicación que contiene el valor real, como se muestra a continuación.
Aquí podemos asignar una cantidad de bloques para asignar y, por lo tanto, para cada índice tenemos que llamar al constructor parametrizado usando la nueva palabra clave para inicializar.
C++
#include <iostream>
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterized constructor
Test(int x, int y)
: x(x)
, y(y)
{
}
// function to print
void print() { cout << x << " " << y << endl; }
};
int main()
{
// allocating array using
// pointer to pointer concept
Test** arr = new Test*[N];
// calling constructor for each index
// of array using new keyword
for (int i = 0; i < N; i++) {
arr[i] = new Test(i, i + 1);
}
// printing contents of array
for (int i = 0; i < N; i++) {
arr[i]->print();
}
return 0;
}
0 1 1 2 2 3 3 4 4 5
5. Uso de Vector de clase de tipo: Vector es uno de los elementos más poderosos de la Biblioteca de plantillas estándar que facilita la escritura de códigos complejos relacionados con arrays estáticas o dinámicas de una manera eficiente. Toma un parámetro que puede ser de cualquier tipo y, por lo tanto, usamos nuestra Clase como un tipo de vector y empujamos Objetos en cada iteración del ciclo.
Los vectores son lo mismo que las arrays dinámicas con la capacidad de cambiar su tamaño automáticamente cuando se inserta o elimina un elemento, y el contenedor maneja automáticamente su almacenamiento. Los elementos vectoriales se colocan en almacenamiento contiguo para que se pueda acceder a ellos y recorrerlos mediante iteradores. En los vectores, los datos se insertan al final.
C++
#include <iostream>
#include <vector>
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterized constructor
Test(int x, int y)
: x(x)
, y(y)
{
}
// function to print
void print() { cout << x << " " << y << endl; }
};
int main()
{
// vector of type Test class
vector<Test> v;
// inserting object at the end of vector
for (int i = 0; i < N; i++)
v.push_back(Test(i, i + 1));
// printing object content
for (int i = 0; i < N; i++)
v[i].print();
return 0;
}
0 1 1 2 2 3 3 4 4 5