对象实例化多次调用构造函数

时间:2018-10-28 23:59:29

标签: c++

我有一个模板化类,试图将其声明为二维模板化对象。当我声明我的2D对象时,我的构造函数被调用了大约15次,并且由于我认为是相关的原因,我的析构函数试图删除未分配的内存。我怀疑这与我尝试将类的另一个实例作为模板参数传递的方式有关...

一个可能相关的问题是,尽管main正在进行过多的构造函数调用,但我的析构函数却被调用,并且出现malloc错误。我似乎找不到没有新运算符的内存分配位置...据我所知,每个My_vector实例都应为数组分配new内存。

为什么在我的主函数的第一行中重复调用我的构造函数?

main.cpp

#include <iostream>
#include "My_vector.h"

int main() {
    My_vector<My_vector<bool>> board; //this is where I get 15 calls to the constructor

    My_vector<bool> row(4, 0);
    board.push_back(row);
}

My_vector.h

#include <cstring>
#include <initializer_list>

template <typename Type>
class My_vector {
private:
    Type* array;
    int vector_capacity;
    int vector_size;
public:
    //Constructors
    My_vector(int n = 0) {              //keeps getting called
        vector_capacity = n + 10;
        array = new Type[vector_capacity];
        vector_size = 0;
    }

    My_vector(int n, Type value) {
        initialize(n + 10);
        for ( ; n > 0; n--) {
            push_back(value);
        }
    }

    My_vector(std::initializer_list<Type> list) {
        initialize(list.size() + 10);
        memcpy(array, list.begin(), sizeof(Type) * list.size());
    }

    //Destructor
    ~My_vector() {delete [] array; array = nullptr;} //get a "pointer being freed was not allocated" error in the same line that creates the excessive constructor calls

    //Accessors
    int size() const {return vector_size;}
    int capacity() {return vector_capacity;}
    Type& at(int const) const;

    //Mutators
    void push_back(Type const& val);
    void increase_capacity();
    void initialize(int n = 10);
    void erase(int);
    void resize(int, Type val = Type());
    void assign(std::initializer_list<Type> list);
};

template <typename Type>
void My_vector<Type>::push_back(Type const& val) {
    if (size() == capacity()) {
        increase_capacity();
    }
    array[vector_size++] = val;
}

template <typename Type>
void My_vector<Type>::increase_capacity() {
    Type* temp_array = new Type[1.5 * capacity()];
    memcpy(temp_array, array, size() * sizeof(Type));
    delete [] array;
    array = temp_array;
    vector_capacity = 1.5 * capacity();
}

template <typename Type>
Type& My_vector<Type>::at(int const index) const {
    return *(array + index);
}

template <typename Type>
void My_vector<Type>::initialize(int n) {
    vector_capacity = n;
    array = new Type[vector_capacity];
    vector_size = 0;
}

3 个答案:

答案 0 :(得分:2)

您的调用将您带到第一个构造函数:

My_vector(int n = 0) {              //keeps getting called

在此构造函数中,您还创建了10个My_vector对象:

    vector_capacity = n + 10;
    array = new Type[vector_capacity];

再次-第一个条目是针对板对象-My_vector对象的My_vector。

同一构造函数中的其余条目都是针对您在上述代码中创建的10个新的bool对象My_vector的!

我希望这会有所帮助,

答案 1 :(得分:2)

我认为您正在调用11次构造函数

此行1次:My_vector<My_vector<bool>> board;在主行

此行

10次:array = new Type[vector_capacity];在构造函数中

第二行再次调用构造函数10次,因为vector_capacity默认为10

答案 2 :(得分:1)

array = new Type[vector_capacity];为在该数组中创建的每个对象调用默认构造函数。由于您有My_vector<My_vector<bool>> board;的期望,因此它将在每个内部My_vector上调用构造函数。