C++ c++；浮点*数组作为std:：vector的参考<；浮动>；

我想创建一个

std:：vector vpd

，它将作为

float*

的参考

float * old = new float[6];
for (int i = 0; i < 6; i++)
{
    old[i] = i;
}
vector<float> vpd(6);
auto refasd = &*vpd.begin();
*refasd = *old;
vpd[0] = 23;
cout << old[0] << endl;

float*old=newfloat[6]；
对于（int i=0；i<6；i++）
{
旧[我]=我；
}
载体vpd（6）；
自动重构=&*vpd.begin（）；
*refasd=*旧；
vpd[0]=23；
你不能
std:：vector
不是为获得原始指针的所有权而设计的。

也许你可以用
std:：unique\u ptr
，但是更好的解决方案是直接使用
std:：vector
您还可以创建
std:：reference\u wrapper
对象的
vector
，这些对象引用原始
float
数组-可能是
std:：vector
或
new
ed
float*
。例如：

vector<std::reference_wrapper<float>> vpd(old, old + 6); // ¹

vpd[0].get() = 23.f;

cout << old[0] << endl; // prints 23

vectorvpd（旧的，旧的+6）；//¹
vpd[0].get（）=23.f；
CUT< P>依赖于C++版本，您将有一些选项（如果我理解问题）：
如果你有一个旧的C++版本，那么C++ 11，我会在这个例子中，DECARAR STD：：向量为：

// then you really need to make sure u delete the memory as well
std::vector<float*> vpd(6); 

//那么你真的需要确保你也删除了内存
std：：载体vpd（6）；

然而，如果你有c++11或更高版本，我会使用std:：share_ptr或std:：unique_ptr，这取决于你是否想共享内存空间。这两种方法都可以确保内存被自己删除，而不必执行“delete float*；”，这很好。
您可以在以下位置阅读关于std:：shared_ptr和std:：unique_ptr的信息：

//用于唯一的\u ptr
std：：载体vpd（6）；
//对于std:：shared_ptr
std：：载体vpd（6）；

我想说的是，如果你可以使用unique而不是shared，因为shared，ptr有一些额外的复杂性，可以确保在删除内存空间之前没有使用内存。
因为
std:：vector
有自己的内存结构，你不能将
vector
甚至
vector
映射到浮点数组。但是，您可以将每个向量项映射到一个数组

float* old = new float[6];
for (int i = 0; i < 6; i++)
{
    old[i] = i;
}
vector<float*> vpd(6);
int i = 0;
for (auto it = vpd.begin(); it != vpd.end(); it++)
{
    *it = &old[i++];
}
*vpd[0] = 23;
*vpd[2] = 45;
cout << old[0] << endl << old[2] << endl;    

或者，您可以使用（C++20）

float*old=newfloat[6]；
标准：物联网（旧的，旧的+6,0）；
标准：span vpd（旧，6）；
vpd[0]=23；
std：：cout你可能在寻找这个：是告诉向量使用你的“预分配”缓冲区而不是向量内部管理的缓冲区，还是你只是想用
float*
-类型来引用向量的内部缓冲区？也许你的意思是
vpd[0]=23*old=*refasd？我不确定您是否需要
std:：transform
。IIRC
std:：vectorvpd（旧的，旧的+6）应该是现成的。@StoryTeller True，这是一个很好的改进！再加上未来的一个。
span
是否拥有内存，即
delete[]
是否故意丢失？如果我没有弄错的话，span不拥有内存，所以是的，
delete[]
丢失了。您这样做破坏了缓存位置， though@LightnessRacesinOrbitcold请您详细解释一下？@LightnessRacesinOrbit该链接在设计环境中很酷，但我仍然不认为它与重用指针访问的某些内存块有什么关系。整篇文章都是关于容器中的间接寻址如何通过阻碍CPU缓存而降低性能。除非出于某种目的需要，否则应避免使用连续容器中的指针。一组连续的数据意味着当您获取第一个元素时，缓存将正常工作；也就是说，第二本、第三本甚至更多本书都已经准备好阅读了。如果您正在提取指针，并且必须取消对每个指针的引用，则每次该信息位于缓存中的几率很低（除非“真实”数据在附近），因此您将有大量缓存未命中。这是很昂贵的。现在您讨论的是创建这些元素的成本，而不是访问它们的成本。但答案仍然是肯定的。
float* old = new float[6];
for (int i = 0; i < 6; i++)
{
    old[i] = i;
}
vector<float*> vpd(6);
int i = 0;
for (auto it = vpd.begin(); it != vpd.end(); it++)
{
    *it = &old[i++];
}
*vpd[0] = 23;
*vpd[2] = 45;
cout << old[0] << endl << old[2] << endl;    

23
45

float* old = new float[6];
std::iota(old, old + 6, 0);
std::span<float> vpd(old, 6);
vpd[0] = 23;
std::cout << old[0] << std::endl;
delete[] old;