使用C+通过类构造函数传递数组+；可变参数模板 我想用一个新的C++范例来实现一个小型的数学库的现代化（我有一个C++ 17编译器）。具体来说，我需要通过构造函数将数组传递给类

这是我用的“古典”老方法。它起作用了

class Vector {
public:
    long double* elements;
public:
    Vector(int size, long double *array) {
        elements = new long double[size];
        for(int i = 0; i < size; i++) {
            elements[i] = array[i];
        }
    };

    virtual ~Vector() {
        delete []elements;
    }

};

int main() {
    long double array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    Vector vector = Vector(10, array);
    for (int i = 0; i < 10; i++) {
        std::cout << vector.elements[i] << std::endl;
    }

    return 0;
}

我做错了什么？

---

此外，我想知道是否可以在main方法内部和Vector类中使用std:：array而不是raw数组。

传递这样的数组不是解决方案。可变模板用于将N个参数传递给类/函数。但您只传递了一个参数

我建议你去

我建议您使用数组引用，这些引用在所有C++版本中都可用：

class Vector {
public:
    long double* elements;
public:
    template<std::size_t size>
    Vector(long double (&array)[size]) {
        elements = new long double[size];
        for(int i = 0; i < size; i++) {
            elements[i] = array[i];
        }
    };

    virtual ~Vector() {
        delete []elements;
    }
};

类向量{
公众：
长双*元素；
公众：
模板
向量（长双精度（&数组）[大小]）{
元素=新的长双[大小]；
对于（int i=0；i

---

顺便说一下，如果可以的话，请使用向量。我非常怀疑这个定制向量类是否能像std:：vector（没有几何增长或优化的复制和移动）那样高效地传递数组，就像可变模板不是解决方案一样。可变模板用于将N个参数传递给类/函数。但您只传递了一个参数

我建议你去

我建议您使用数组引用，这些引用在所有C++版本中都可用：

class Vector {
public:
    long double* elements;
public:
    template<std::size_t size>
    Vector(long double (&array)[size]) {
        elements = new long double[size];
        for(int i = 0; i < size; i++) {
            elements[i] = array[i];
        }
    };

    virtual ~Vector() {
        delete []elements;
    }
};

类向量{
公众：
长双*元素；
公众：
模板
向量（长双精度（&数组）[大小]）{
元素=新的长双[大小]；
对于（int i=0；i

---

顺便说一下，如果可以的话，请使用向量。我非常怀疑这个定制向量类是否像std:：vector（没有几何增长或优化的复制和移动）一样高效

 template<typename... Args> Vector(Args... args);

如果您将构造函数的定义修改为：

template<typename... Args>
Vector(Args... args){
    constexpr int size = sizeof...(Args);
    elements = new long double[size]{static_cast<long double>(args)...};
}

模板
向量（Args…Args）{
constexpr int size=sizeof…（Args）；
元素=新的长双[size]{static_cast（args）…}；
}

---

请注意，此类使用是不良好做法，您通常应使用

std

容器，并避免使用

新的

操作员。

根据您对

 template<typename... Args> Vector(Args... args);

如果您将构造函数的定义修改为：

template<typename... Args>
Vector(Args... args){
    constexpr int size = sizeof...(Args);
    elements = new long double[size]{static_cast<long double>(args)...};
}

模板
向量（Args…Args）{
constexpr int size=sizeof…（Args）；
元素=新的长双[size]{static_cast（args）…}；
}

---

请注意，这种使用是不好的做法，您通常应该使用

std

容器，避免使用

新的

操作员。

我不确定这是否回答了您的问题，但我会给您一个一般性建议： 我猜你想把你自己的逻辑封装到向量中。 标准库向量非常先进，您应该使用它，而不是浪费时间编写自己的低级代码。你可以更专注于你需要的逻辑

您可以定义自己的向量，并且仍然使用std:：vector的优点来构建向量对象。 例如，对于继承：

template<typename T>
class Vector : public std::vector<int>
{
   // here comes the implementation of your interface.
}

模板
类向量：public std:：Vector
{
//下面是接口的实现。
}

或组成：

template<typename T>
class Vector {
private:
    std::vector<T> elems;
}

模板
类向量{
私人：
std：：向量元素；
}

在组合的情况下，您必须定义所需的构造函数

在这两种情况下，您可以使用自己的向量，如下所示：

Vector<double> vec1(10);         // construct vector with 10 double's each = 0
Vector<double> vec2(10, 5);      // construct vector with 10 double's each = 5
Vector<double> vec3{1,2,3,4};    // using initializer list
Vector<double> vec4(somecontainer.begin(), somecontainer.end());   // construct vector by copying elemts from some other container 

向量向量1（10）；//构造向量，每个向量有10个双精度=0 向量向量2（10，5）；//构造10个双精度的向量，每个=5 向量vec3{1,2,3,4}；//使用初始值设定项列表 向量vec4（somecontainer.begin（），somecontainer.end（））；//通过从其他容器复制元素来构造向量 等等

---

正如您所看到的，通过std:：vector，您可以获得构建自己的向量对象所需的所有好处。

我不确定这是否回答了您的问题，但我会给您一个一般性建议： 我猜你想把你自己的逻辑封装到向量中。 标准库向量非常先进，您应该使用它，而不是浪费时间编写自己的低级代码。你可以更专注于你需要的逻辑

您可以定义自己的向量，并且仍然使用std:：vector的优点来构建向量对象。 例如，对于继承：

template<typename T>
class Vector : public std::vector<int>
{
   // here comes the implementation of your interface.
}

模板
类向量：public std:：Vector
{
//下面是接口的实现。
}

或组成：

template<typename T>
class Vector {
private:
    std::vector<T> elems;
}

模板
类向量{
私人：
std：：向量元素；
}

在组合的情况下，您必须定义所需的构造函数

在这两种情况下，您可以使用自己的向量，如下所示：

Vector<double> vec1(10);         // construct vector with 10 double's each = 0
Vector<double> vec2(10, 5);      // construct vector with 10 double's each = 5
Vector<double> vec3{1,2,3,4};    // using initializer list
Vector<double> vec4(somecontainer.begin(), somecontainer.end());   // construct vector by copying elemts from some other container 

向量向量1（10）；//构造向量，每个向量有10个双精度=0 向量向量2（10，5）；//构造10个双精度的向量，每个=5 向量vec3{1,2,3,4}；//使用初始值设定项列表 向量vec4（somecontainer.begin（），somecontainer.end（））；//通过从其他容器复制元素来构造向量 等等

---

正如您所看到的，使用std:：vector，您将获得构建自己的矢量对象所需的所有好处。

术语牌在编译时展开，它不会用初始化列表替换

数组

。请使用

std:：array

而不是这些糟糕的c样式数组！将

std

与名为

Vector

的类和名为

Vector

的变量一起使用可能是一个非常糟糕的想法。（请参见

std:：vector

）您使用的是

new

，这是一个非常糟糕的选择