C++ 从其他数组初始化堆数组

如何在堆上创建一个数组，并在构建时从另一个数组初始化它

template <typename T>
T* Copy(T* myOriginalArray, size_t myOriginalArraySize)
{
    T* copy = new T[myOriginalArraySize]; // copy data from myOriginalArray here too
    return copy;
}

模板
T*复制（T*myOriginalArray，大小\u T myOriginalArraySize）
{
T*copy=new T[myOriginalArraySize]；//在此处也从myOriginalArraySize复制数据
返回副本；
}

---

我可以创建数组，然后使用std:：copy，但这需要数组内容有一个空构造函数。您可以假定对象具有复制和移动构造函数。我可以访问C++17。

不确定这是否是您所要求的，但您可以先分配内存，然后使用（这基本上就是预分配STL容器所做的）

模板
T*复制（T*myOriginalArray，大小\u T myOriginalArraySize）
{
自动t_size=sizeof（t）；
T*copy=（T*）新字符[myOriginalArraySize*T_size]；
对于（大小i=0；i

不确定这是否是您所要求的，但您可以先分配内存，然后再使用（这基本上就是预分配STL容器所做的）

模板
T*复制（T*myOriginalArray，大小\u T myOriginalArraySize）
{
自动t_size=sizeof（t）；
T*copy=（T*）新字符[myOriginalArraySize*T_size]；
对于（大小i=0；i

您使用的是

：：操作员新建

和

std:：未初始化\u复制

#include<memory>
#include<new>

template<typename T>
T* Copy(T* src, size_t sz)
{
    auto buf = static_cast<T*>(::operator new(sizeof(T) * sz));
    std::uninitialized_copy(src, src + sz, buf);
    return buf;    
}

#包括
#包括
模板
T*Copy（T*src，尺寸_T sz）
{
自动buf=静态_转换（：：运算符新（sizeof（T）*sz））；
未初始化的拷贝（src，src+sz，buf）；
返回buf；
}

而且可能会移动，有点麻烦

#include<utility>

template<typename T>
T* Move(T* src, size_t sz)
{
    auto buf = static_cast<T*>(::operator new(sizeof(T) * sz));
    for(size_t i = 0; i < sz; i++)
        new (buf + i) T(std::move(src[i]));
    return buf;
}

#包括
模板
T*Move（T*src，尺寸_T sz）
{
自动buf=静态_转换（：：运算符新（sizeof（T）*sz））；
对于（大小i=0；i

这真的不是一个好主意，考虑到你必须处理一些疯狂的代码

template<typename T>
void Delete(T* src, size_t sz)
{
    for(size_t i = 0; i < sz; i++)
        src[i].~T();
    ::operator delete(src);
}

模板
无效删除（T*src，尺寸_T sz）
{
对于（大小i=0；i

请考虑使用<代码> STD:：vector < /C> > .< /P> 旁注 Q:为什么用

size\u t

索引而不是使用

t*

？

---

A:事实证明，目前索引速度稍快。

您使用的是

：操作符new

和

std:：uninitialized\u copy

#include<memory>
#include<new>

template<typename T>
T* Copy(T* src, size_t sz)
{
    auto buf = static_cast<T*>(::operator new(sizeof(T) * sz));
    std::uninitialized_copy(src, src + sz, buf);
    return buf;    
}

#包括
#包括
模板
T*Copy（T*src，尺寸_T sz）
{
自动buf=静态_转换（：：运算符新（sizeof（T）*sz））；
未初始化的拷贝（src，src+sz，buf）；
返回buf；
}

而且可能会移动，有点麻烦

#include<utility>

template<typename T>
T* Move(T* src, size_t sz)
{
    auto buf = static_cast<T*>(::operator new(sizeof(T) * sz));
    for(size_t i = 0; i < sz; i++)
        new (buf + i) T(std::move(src[i]));
    return buf;
}

#包括
模板
T*Move（T*src，尺寸_T sz）
{
自动buf=静态_转换（：：运算符新（sizeof（T）*sz））；
对于（大小i=0；i

这真的不是一个好主意，考虑到你必须处理一些疯狂的代码

template<typename T>
void Delete(T* src, size_t sz)
{
    for(size_t i = 0; i < sz; i++)
        src[i].~T();
    ::operator delete(src);
}

模板
无效删除（T*src，尺寸_T sz）
{
对于（大小i=0；i

请考虑使用<代码> STD:：vector < /C> > .< /P> 旁注 Q:为什么用

size\u t

索引而不是使用

t*

？

---

A:事实证明，目前索引速度稍快。

除非您喜欢调试内存泄漏，否则不应该从函数返回指向动态分配内存的原始指针。

std:：array

。它已经有了一个合适的复制构造函数。然后使用

std:：vector

数组是C类的东西，我怀疑你能正确地使用移动语义。我认为这可以通过placement new、

alignof

和一些强制转换来完成，但要避免未定义的行为会非常复杂。除非您喜欢调试内存泄漏，否则不应该从函数返回指向动态分配内存的原始指针。它已经有了一个合适的复制构造函数。然后使用

std:：vector

数组是C类的东西，我怀疑你是否能正确地使用移动语义。我认为这可以通过placement new、

alignof

和一些强制转换来完成，但避免未定义的行为会非常复杂。我不，我试图解释的问题实际上我确实认为它可能与一些丑陋有关，移动的东西让我困惑。据我所知，没有涉及任何移动。对象数组是在没有实际构造的情况下分配的。对象使用其复制构造函数逐个就地构造。返回指向堆数组的指针。如果能解释一下移动语义缺失的地方，我们将不胜感激。我不知道，我试图解释的问题实际上我确实认为它可能涉及到一些丑陋的东西，移动的东西让我困惑。据我所知，没有涉及任何移动。对象数组是在没有实际构造的情况下分配的。对象使用其复制构造函数逐个就地构造。返回指向堆数组的指针。请解释一下移动语义缺失的地方，这就是我想要的（与jdehesa的答案相同，但更完整）。担心破坏是正义的。对我来说，这个问题的目标是学习像

std:：vector

这样的东西是如何在内部工作的。这就是我要寻找的（与jdehesa的答案相同，但更完整）。担心破坏是正义的。对我来说，这个问题的目的是学习像

std:：vector

这样的东西是如何在内部工作的。