对象数组:
定义类时,仅定义对象的规范;否则,将仅定义对象的规范。没有分配内存或存储空间。要使用该类中定义的数据和访问功能,您需要创建对象。
句法:
ClassName ObjectName[number of objects];
使用参数化构造函数初始化对象数组的不同方法:
1.使用一堆函数调用作为数组的元素:就像普通的数组声明一样,但是在这里,我们使用构造函数调用作为该数组的元素来初始化该数组。
C++
#include
using namespace std;
class Test {
// private variables.
private:
int x, y;
public:
// parametrized 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
// parametrized 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;
}
CPP
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterised 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;
}
CPP
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// dummy constructor
Test() {}
// parameterised 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;
}
CPP
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterised 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;
}
CPP
#include
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterised 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 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;
}
2.使用malloc() :为避免调用非参数化构造函数,请使用malloc()方法。 C++中的“ malloc”或“内存分配”方法用于动态分配具有指定大小的单个大内存块。它返回类型为void的指针,该指针可以转换为任何形式的指针。
CPP
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterised 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.使用new关键字: new运算符表示在Heap上分配内存的请求。如果有足够的可用内存,则new运算符将初始化该内存,并将新分配和初始化的内存的地址返回给指针变量。这里,pointer-variable是数据类型的指针。数据类型可以是任何内置数据类型(包括数组),也可以是任何用户定义的数据类型(包括结构和类)。
对于动态初始化,如果我们添加参数化的构造函数,则new关键字需要非参数化的构造函数。因此,我们将为其使用虚拟构造函数。
CPP
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// dummy constructor
Test() {}
// parameterised 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
如果我们不使用虚拟构造函数,编译器将显示以下错误
编译器错误:
error: no matching function for call to ‘Test::Test()’
Test *arr=new Test[N];
4.使用双指针(指向指针概念的指针) :指向指针的指针是多种间接形式或一系列指针的形式。通常,指针包含变量的地址。当我们定义指向指针的指针时,第一个指针包含第二个指针的地址,该地址指向包含实际值的位置,如下所示。
在这里,我们可以分配许多要分配的块,因此对于每个索引,我们都必须使用new关键字来调用参数化构造函数进行初始化。
CPP
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterised 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.使用类型类型为Vector的Vector : Vector是标准模板库中最强大的元素之一,可以轻松高效地编写与静态或动态数组有关的任何复杂代码。它采用一个可以是任何类型的参数,因此我们将Class用作向量的类型,并在循环的每次迭代中推送对象。
向量与动态数组相同,具有在插入或删除元素时自动调整自身大小的能力,并且容器自动处理其存储。向量元素放置在连续的存储中,以便可以使用迭代器对其进行访问和遍历。在向量中,数据将插入到末尾。
CPP
#include
#include
#define N 5
using namespace std;
class Test {
// private variables
int x, y;
public:
// parameterised 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 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