Question

完全重写了这个问题。请仔细阅读

单注意不要混淆你：基础构造函数需要指向常量数组的指针。它不存储指针本身，它存储数据！

我有以下代码：

class Base {
public:
    Base(int*);
    // added this to explain why I need inheritance
    virtual void abstractMethod() = 0;
};

Base::Base(const int *array) {
    // just for example
    cout << array[0] << endl;
    cout << array[1] << endl;
    cout << array[2] << endl;
}

class Derived : private Base {
public:
    Derived();
    void abstractMethod();
};

// who will delete? how to initialize?
Derived::Derived(): Base(new int[3]) {
}

我想隐藏Derived类用户的Base（int *）构造函数。为此，我需要为该数组提供默认值。

问题在于，当我使用这样的初始化列表时：

Derived::Derived(): Base(new int[3]) {
}

数组未初始化，Base构造函数打印一些垃圾。这段代码的另一个问题是：谁将释放新的数组？

如何在将数组传递给Base类之前初始化数组？在C ++中是否可以使用？

Answer 1

简短的回答：你不能（除非你愿意依赖特定编译器中可能存在的怪癖）。对于标准合规性，Base必须完全构建，才能安全触及Derived中的任何其他内容。

专注而不是你想要实现的目标。为什么数组必须在Derived;为什么你觉得有必要让Base初始化？可能有数十种安全的方法可以实现您的需求。

Answer 2

这是一些非常糟糕的设计。当没有成员初始化时，为什么需要一个在int*类中使用Base的构造函数？
从你对Pontus答案的评论中，你似乎意识到了这个缺陷。

class Base {
private:
    int array[3];
public:
    Base(int* arr);
    virtual ~Base();
};

class Derived : Base {
public:
    Derived();
};

然后，您将使用初始化列表将数组传递回基类：

Derived() : Base(new int[3]) {
    array[0] = array[1] = array[2] = 1;
}

您基本上调用class Base的构造函数并传递参数。 Base的构造函数也会使用初始化列表：

Base(int* arr) : array(arr) {
}

此外，当Derived构造函数被执行时，Base对象已经完全初始化，这是标准所承诺的。
当然，您必须在Base中处理动态分配的数组的破坏：

virtual ~Base(){
    delete [] array;
}

干杯。

Answer 3

您可以使用静态函数生成对象：

class Base {
public:
    Base(int*);
};

class Derived : Base {
public:
    static Derived createDerived()
    {
        int *a= new int[3];
        a[0]=a[1]=a[2]=1;
        return Derived(a);
    }
    ~Derived()
    {
       delete [] array;
    }
private:
    int *array;
    Derived(int * a):arrary(a),Base(a)
    {
    }
};

Answer 4

找到解决方案：

Derived::Derived(): Base(new int[3]{1,1,1}) {
}

但是，这只在C ++ 0x中有效。 g ++给了我一个警告：

warning: extended initializer lists only available with -std=c++0x or -std=gnu++0x

Answer 5

我进入另一个解决方案：

class Int3Array {
    int array[3];
public:
    Int3Array(int v1, int v2, int v3) {
        array[0] = v1;
        array[1] = v2;
        array[2] = v3;
    }
    int* getPtr() {
        return array;
    }
};

Derived::Derived(): Base((Int3Array(1,1,1)).getPtr()) {
}

你怎么看？它也不好吗？

Answer 6

此时我能找到的最佳解决方案是使用静态数组：

class Derived : private Base {
public:
    Derived();
    void abstractMethod();
    static int array[3];
};

int Derived::array[3] = {5, 5, 5};

Derived::Derived(): Base(array) {
}

随时添加您的评论。

如何初始化数组并将指针传递给派生的基础构造函数？

6 个答案: