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

Question

我正在尝试使用数组启动对象。有没有办法用指针来做到这一点，或者我应该找到另一种方法来做到这一点。

编辑：我想用动态内存分配编写这段代码，我知道向量是解决这个问题的更好方法。

#include <iostream>

template <class t>
class die {
private:
    int sideCount;
    t* valueOfSides;
public:
    die(int side, t arr[]) {
        sideCount = side;
        valueOfSides = (t*)malloc(side * sizeof(t));
        for (int counter; counter < side; counter++) {
            valueOfSides[counter] = val[counter];
        }
    }

    ~die() {
        free(valueOfSides);
    }
};

int main() {
    die<int> sixsided(6, {1,2,3,4,5,6});
} 

Answer 1

使用更多的 C 技术可以做到这一点的一种方法是变量参数列表：

#include <cstdarg>
#include <iostream>

template <class t>
class die {
private:
    int sideCount;
    t* valueOfSides;
public:
    die(int side, ...) {
        sideCount = side;
        valueOfSides = new t[side];

        va_list args;
        va_start(args, side);
        for (int counter = 0; counter < side; counter++) {
            valueOfSides[counter] = va_arg(args, t);
        }
        va_end(args);
    }

    ~die() {
        delete[] valueOfSides;
    }
};

int main() {
    die<int> sixsided(6, 1,2,3,4,5,6);
}

您不是传递数组，而是单独传递参数（即不需要临时数组）并使用va_list 来访问它们。

此外，对 malloc 和 free 的调用被替换为 new 和 delete，这是 C++ 分配和释放内存的方式。

Answer 2

C++ 解决方案：

template <class t>
class die {
private:
    int sideCount;
    t* valueOfSides;
public:
    die(int side, t arr[]) {
        sideCount = side;
        valueOfSides = new T[side]
        for (int counter = 0; counter < side; counter++) { //always initialize variables
            valueOfSides[i] = arr[i];
        }
    }

    ~die() {
        delete[] valueOfSides;
    }
};

int main() {
    int arr[6] = { 1,2,3,4,5,6 };
    die<int> sixsided(6, arr);
}

new 运算符类似于malloc，delete 和delete[] 运算符类似于free。它们是动态分配器。

C 解决方案：

template <class t>
class die {
private:
    int sideCount;
    t* valueOfSides;
public:
    die(int side, t arr[]) {
        sideCount = side;
        valueOfSides = (t*)malloc(side * sizeof(t));
        for (int counter = 0; counter < side; counter++) { //always initialize variables
            valueOfSides[i] = arr[i];
        }
    }

    ~die() {
        free(valueOfSides);
    }
};

int main() {
    int arr[6] = { 1,2,3,4,5,6 };
    die<int> sixsided(6, arr);
}

注意：在 C 中，<iostream> 标头不起作用，这仅适用于 C++。

还有其他容器，即std::vector，可以工作，但这是您的答案的解决方案。

Answer 3

正确的做法是

std::vector<t> valueOfSides;

template<size_t len> die(t (&arr)[len])
: valueOfSides(std::begin(arr), std::end(arr))
{}

或

std::vector<t> valueOfSides;

die(std::initializer_list<t> arr) : valueOfSides(arr) {}

我想。虽然真的，最好的答案是

std::vector<t> valueOfSides;

die(std::vector<t> arr) : valueOfSides(std::move(arr)) {}

在 C++ 中永远不要使用原始指针来拥有自己的内存，并且实际上永远不要使用 new 或 malloc。实际上，由于滥用malloc，您的代码中有未定义的行为。

---

如果你真的疯了，或者在做作业，可以用原始指针来完成，但我怀疑如果没有测试和编译器，我能否完全正确。

template<class t>
class die {
private:
    int sideCount;
    t* valueOfSides;
public:
    die(int side, t* arr) {
        sideCount = 0;
        std::size_t buffer_size = sizeof(t)*side;
        char* buffer;
        try {
            buffer = new char[side];
            valueOfSides = reinterpret_cast<t*>(buffer);
            for(int i=0; i<side; i++) {
                new(valueOfSides+i)t(arr[i]);
                sideCount++;
            }
        } catch(...) {
            for(int i=sideCount; i>=0; i--)
                (valueOfSides+i)->~t();
            delete[]buffer;
            throw;
        }
    }
    die& operator=(die&& rhs) {
        sideCount = rhs.sideCount;
        valueOfSides = rhs.valueOfSides;
        rhs.valueOfSides = nullptr;
        rhs.sideCount = 0;
        return *this;
    }
    //die& operator=(const die& rhs) not shown because its super hard.

    ~die() {
        for(int i=sideCount; i>=0; i--)
            (valueOfSides+i)->~t();
        delete[]reinterpret_cast<char*>(valueOfSides);
    }
};

正如我们之前所说，把这些东西做好是非常困难的。使用std::vector。

Answer 4

使用std::vector。

#include <iostream>
#include <initalizer_list>
#include <vector>

template<class T>
class die {
public:
    die() = default;
    die(std::initializer_list<T> list)
    : sides{list}
    { /* DO NOTHING */ }
private:
    std::vector<T> sides{};
};

int main() {
    die<int> sixsided({1,2,3,4,5,6});
}