получение памяти от std::vector

Вы не можете стать владельцем памяти из вектора, но вы можете решить основную проблему другим способом.

Вот как я бы к этому подошел - это немного хакерски из-за статической глобальной переменной и не потокобезопасности, но это можно сделать с помощью простой блокировки доступа к объекту registry.

static std::map<T*, std::vector<T>*> registry;
void my_startProcessing(std::vector<T> * data) {
  registry.put(data->data(), data);
  lib::startProcesing(data->data(), data->size());
}

void my_callback(T * data, size_t length) {
  std::vector<T> * original = registry.get(data);
  delete original;
  registry.remove(data);
}

Теперь вы можете просто сделать

std::vector<T> * input = ...
my_startProcessing(input);

Но будьте осторожны! Плохие вещи произойдут, если вы добавите/удалите элементы во входные данные после того, как вы вызвали my_startProcessing - буфер, который есть в библиотеке, может стать недействительным. (Вам может быть разрешено изменять значения в векторе, так как я считаю, что это будет правильно записывать данные в to, но это будет зависеть и от того, что позволяет библиотека.)

Также это не работает, если T=bool, так как std::vector<bool>::data() не работает.

Вы можете создать собственную сборку класса поверх вектора.

Ключевым моментом здесь является использование семантики перемещения в конструкторе SomeData.

• вы получаете подготовленные данные без копирования (обратите внимание, что исходный вектор будет очищен)
• данные будут правильно размещены деструктором вектора thisData
• исходный вектор может быть удален без проблем

Поскольку базовый тип данных будет массивом, вы можете вычислить начальный указатель и размер данных (см. SomeDataImpl.h ниже):

SomeData.h

#pragma once
#include <vector>

template<typename T>
class SomeData
{
    std::vector<T> thisData;

public:
    SomeData(std::vector<T> && other);

    const T* Start() const;
    size_t Size() const;
};

#include "SomeDataImpl.h"

SomeDataImpl.h

#pragma once

template<typename T>
SomeData<T>::SomeData(std::vector<T> && otherData) : thisData(std::move(otherData)) { }

template<typename T>
const T* SomeData<T>::Start() const {
    return thisData.data();
}

template<typename T>
size_t SomeData<T>::Size() const {
    return sizeof(T) * thisData.size();
}

Пример использования:

#include <iostream>
#include "SomeData.h"

template<typename T>
void Print(const T * start, size_t size) {
    size_t toPrint = size / sizeof(T);
    size_t printed = 0;

    while(printed < toPrint) {
        std::cout << *(start + printed) << ", " << start + printed << std::endl;
        ++printed;
    }
}

int main () {
    std::vector<int> ints;
    ints.push_back(1);
    ints.push_back(2);
    ints.push_back(3);

    SomeData<int> someData(std::move(ints));
    Print<int>(someData.Start(), someData.Size());

  return 0;
}

Вы не можете сделать это каким-либо переносимым способом, но вы МОЖЕТЕ сделать это таким образом, который, вероятно, будет работать в большинстве реализаций C++. Этот код, кажется, работает после быстрого теста на VS 2017.

#include <iostream>

#include <vector>

using namespace std;

template <typename T>
T* HACK_stealVectorMemory(vector<T>&& toStealFrom)
{
    // Get a pointer to the vector's memory allocation
    T* vectorMemory = &toStealFrom[0];

    // Construct an empty vector in some stack memory using placement new
    unsigned char buffer[sizeof(vector<T>)];
    vector<T>* fakeVector = new (&buffer) vector<T>();

    // Move the memory pointer from toCopy into our fakeVector, which will never be destroyed.
    (*fakeVector) = std::move(toStealFrom);

    return vectorMemory;
}

int main()
{
    vector<int> someInts = { 1, 2, 3, 4 };
    cout << someInts.size() << endl;

    int* intsPtr = HACK_stealVectorMemory(std::move(someInts));

    cout << someInts.size() << endl;

    cout << intsPtr[0] << ", " << intsPtr[3] << endl;

    delete intsPtr;
}

Выход:

4
0
1, 4