📜  如何在 C++ 中使用参数化构造函数初始化对象数组

📅  最后修改于: 2021-09-06 06:09:57             🧑  作者: Mango

对象数组:
定义类时,只定义对象的规范;没有分配内存或存储。要使用类中定义的数据和访问函数,您需要创建对象。

句法:

ClassName ObjectName[number of objects];

使用参数化构造函数初始化对象数组的不同方法

1.使用一堆函数调用作为数组的元素:就像普通的数组声明一样,但这里我们使用构造函数调用来初始化数组作为该数组的元素。

C++
#include 
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;
}


C++
#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;
}


C++
#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;
}


C++
#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;
}


C++
#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 类型的指针,该指针可以转换为任何形式的指针。

C++

#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运算符表示在堆上分配内存的请求。如果有足够的内存可用,new运算符初始化内存并将新分配和初始化的内存的地址返回给指针变量。这里,指针变量是数据类型类型的指针。数据类型可以是任何内置数据类型,包括数组或任何用户定义的数据类型,包括结构和类。

如果我们添加参数化构造函数,则对于动态初始化 new 关键字需要非参数化构造函数。因此,我们将为它使用一个虚拟构造函数。

C++

#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.使用双指针(pointer to pointer concept) 一个指针的指针是多重间接的一种形式,或者是一个指针链。通常,指针包含变量的地址。当我们定义一个指向指针的指针时,第一个指针包含第二个指针的地址,第二个指针指向包含实际值的位置,如下所示。
在这里,我们可以分配多个要分配的块,因此对于每个索引,我们必须使用 new 关键字调用参数化构造函数进行初始化。

C++

#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是标准模板库中最强大的元素之一,可以轻松高效地编写任何与静态或动态数组相关的复杂代码。它接受一个可以是任何类型的参数,因此我们使用我们的类作为一种向量,并在循环的每次迭代中推送对象。
向量与动态数组相同,具有在插入或删除元素时自动调整自身大小的能力,其存储由容器自动处理。向量元素被放置在连续的存储中,以便可以使用迭代器访问和遍历它们。在向量中,数据插入在末尾。

C++

#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
想要从精选的视频和练习题中学习,请查看C++ 基础课程,从基础到高级 C++ 和C++ STL 课程,了解基础加 STL。要完成从学习语言到 DS Algo 等的准备工作,请参阅完整的面试准备课程