Cfrgtkky

I want to create a std::vector<float> vpd which will be a reference to 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;

How should I modify the code, if I want get 23 from cout?

You can't. std::vector is not designed to take ownership of a raw pointer.

Maybe you can make do with std::unique_ptr<float>, but the better solution is to directly use std::vector.

As alternative, you might use std::span (C++20)

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;

You could also create a vector of std::reference_wrapper objects that refer to the original float array - may that be std::vector<float> or a newed float*. An example:

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



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



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

¹) Thanks to @StoryTeller for pointing out that vpd can be directly initialized.

As std::vector has its own memory structure you cannot map vector<float> or even vector<float*> to an array of float. However you can map each vector item to an array one.

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;    

Output

23

45

Depending on version of C++ you'll have some options (if I understand the problem):
if you have an older c++ version then c++11 I would in this case declear std::vector as:

// then you really need to make sure u delete the memory as well

std::vector<float*> vpd(6); 

If however you got c++11 or higher I would use either std::share_ptr or std::unique_ptr depending on if you would like to share the memory space or not. Either this will ensure the memory is deleted by it self without having to do a "delete float*;" which is nice.
You can read about std::shared_ptr at: https://en.cppreference.com/w/cpp/memory/shared_ptr and std::unique_ptr at: https://en.cppreference.com/w/cpp/memory/unique_ptr

// For unique_ptr

std::vector<std::unique_ptr<float>> vpd(6);

// for std::shared_ptr

std::vector<std::shared_ptr<float>> vpd(6);

I would say that if you can then use unique_ptr rather then shared_ptr due to shared_ptr has som extra komplexitity within to be make sure the memory not used before deleteing memory space.