xtensor can adapt one-dimensional containers in place, and provide them a tensor interface. Only random access containers can be adapted.

The following example shows how to bring an std::vector into the expression system of xtensor:

#include <cstddef>
#include <vector>
#include "xtensor/xarray.hpp"

std::vector<double> v = {1., 2., 3., 4., 5., 6. };
std::vector<std::size_t> shape = { 2, 3 };

xt::xarray<double> a2 = {{ 1., 2., 3.},
{ 4., 5., 6.}};

xt::xarray<double> res = a1 + a2;
// res = {{ 2., 4., 6. }, { 8., 10., 12. }};


v is not copied into a1, so if you change a value in a1, you’re actually changing the corresponding value in v:

a1(0, 0) = 20.;
// now v is { 20., 2., 3., 4., 5., 6. }


xtensor provides two ways for adapting a C-style array; the first one does not take the ownership of the array:

#include <cstddef>

void compute(double* data, std::size_t size)
{
std::vector<std::size_t> shape = { size };
auto a = xt::adapt(data, size, xt::no_ownership(), shape);
a = a + a; // does not modify the size
}

int main()
{
std::size_t size = 2;
double* data = new double[size];
for (int i = 0; i < size; i++)
data[i] = i;
std::cout << data << std::endl;
// prints e.g. 0x557a363b7c20
compute(data, size);
std::cout << data << std::endl;
// prints e.g. 0x557a363b7c20 (same pointer)
for (int i = 0; i < size; i++)
std::cout << data[i] << " ";
std::cout << std::endl;
// prints 0 2 (data is still available here)
}


However if you replace xt::no_ownership with xt::acquire_ownership, the adaptor will take the ownership of the array, meaning it will be deleted when the adaptor is destroyed:

#include <cstddef>
#include "xtensor/xarray.hpp"

void compute(double*& data, std::size_t size)
{
// data pointer can be changed, hence double*&
std::vector<std::size_t> shape = { size };
auto a = xt::adapt(data, size, xt::acquire_ownership(), shape);
xt::xarray<double> b {1., 2.};
b.reshape({2, 1});
a = a * b; // size has changed, shape is now { 2, 2 }
}

int main()
{
std::size_t size = 2;
double* data = new double[size];
for (int i = 0; i < size; i++)
data[i] = i;
std::cout << data << std::endl;
// prints e.g. 0x557a363b7c20
compute(data, size);
std::cout << data << std::endl;
// prints e.g. 0x557a363b8220 (pointer has changed)
for (int i = 0; i < size * size; i++)
std::cout << data[i] << " ";
std::cout << std::endl;
// prints e.g. 4.65504e-310 1 0 2 (data has been deleted and is now corrupted)
}


To safely get the computed data out of the function, you could pass an additional output parameter to compute in which you copy the result before exiting the function. Or you can create the adaptor before calling compute and pass it to the function:

#include <cstddef>
#include "xtensor/xarray.hpp"

template <class A>
void compute(A& a)
{
xt::xarray<double> b {1., 2.};
b.reshape({2, 1});
a = a * b; // size has changed, shape is now { 2, 2 }
}

int main()
{
std::size_t size = 2;
double* data = new double[size];
for (int i = 0; i < size; i++)
data[i] = i;
std::vector<std::size_t> shape = { size };
auto a = xt::adapt(data, size, xt::acquire_ownership(), shape);
compute(a);
for (int i = 0; i < size * size; i++)
std::cout << data[i] << " ";
std::cout << std::endl;
// prints 0 1 0 2
}


Adapting C arrays allocated on the stack is as simple as adapting std::vector:

#include <cstddef>
#include <vector>
#include "xtensor/xarray.hpp"

double v[6] = {1., 2., 3., 4., 5., 6. };
std::vector<std::size_t> shape = { 2, 3 };

xt::xarray<double> a2 = {{ 1., 2., 3.},
{ 4., 5., 6.}};

xt::xarray<double> res = a1 + a2;
// res = {{ 2., 4., 6. }, { 8., 10., 12. }};


v is not copied into a1, so if you change a value in a1, you’re actually changing the corresponding value in v:

a1(0, 0) = 20.;
// now v is { 20., 2., 3., 4., 5., 6. }


If you want to manage your data with shared or unique pointers, you can use the adapt_smart_ptr function of xtensor. It will automatically increment the reference count of shared pointers upon creation, and decrement upon deletion.

#include <memory>
#include <xtensor/xio.hpp>

std::shared_ptr<double> sptr(new double[8], std::default_delete<double[]>());
sptr.get()[2] = 321.;
auto xptr = xt::adapt_smart_ptr(sptr, {4, 2});
xptr(1, 3) = 123.;
std::cout << xptr;


Or if you operate on shared pointers that do not directly point to the underlying buffer, you can pass the data pointer and the smart pointer (to manage the underlying memory) as follows:

#include <memory>
#include <xtensor/xio.hpp>

struct Buffer {
Buffer(std::vector<double>& buf) : m_buf(buf) {}
~Buffer() { std::cout << "deleted" << std::endl; }
std::vector<double> m_buf;
};

auto data = std::vector<double>{1,2,3,4,5,6,7,8};
auto shared_buf = std::make_shared<Buffer>(data);
auto unique_buf = std::make_unique<Buffer>(data);

std::cout << shared_buf.use_count() << std::endl;
{
{2, 4}, shared_buf);
// Use count increased to 2
std::cout << shared_buf.use_count() << std::endl;
std::cout << obj << std::endl;
}
// Use count reset to 1
std::cout << shared_buf.use_count() << std::endl;

{