Как я могу стать владельцем данных C++ std::string char без копирования и сохранения объекта std::string?

Как я могу стать владельцем данных std::string char без копирования и без сохранения исходного объекта std::string? (Я хочу использовать движущуюся семантику, но между разными типами)

Вы не можете сделать это безопасно.

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

Если вы хотите избежать копирования, вы можете рассмотреть возможность изменения интерфейса на ScheduleWrite. Одна возможность что-то вроде:

template<typename Container>
void scheduledWrite(Container data)
{
    // requires data[i], data.size(), and &data[n] == &data[0] + n for n [0,size)
    …
}

// move resources from object owned by a unique_ptr
WriteId write( std::unique_ptr< std::vector<char> > vecToWrite)
{
    scheduleWrite(std::move(*vecToWrite));
}

WriteId write( std::unique_ptr< std::string > strToWrite)
{
    scheduleWrite(std::move(*strToWrite));
}

// move resources from object passed by value (callers also have to take care to avoid copies)
WriteId write(std::string strToWrite)
{
    scheduleWrite(std::move(strToWrite));
}

// assume ownership of raw pointer
// requires data to have been allocated with new char[]
WriteId write(char const *data,size_t size) // you could also accept an allocator or deallocation function and make ptr_adapter deal with it
{
    struct ptr_adapter {
        std::unique_ptr<char const []> ptr;
        size_t m_size;
        char const &operator[] (size_t i) { return ptr[i]; }
        size_t size() { return m_size; }
    };

    scheduleWrite(ptr_adapter{data,size});
}

Этот класс становится владельцем строки, используя семантику перемещения и shared_ptr:

struct charbuffer
{
  charbuffer()
  {}

  charbuffer(size_t n, char c)
  : _data(std::make_shared<std::string>(n, c))
  {}

  explicit charbuffer(std::string&& str)
  : _data(std::make_shared<std::string>(str))
  {}

  charbuffer(const charbuffer& other)
  : _data(other._data)
  {}

  charbuffer(charbuffer&& other)
  {
    swap(other);
  }

  charbuffer& operator=(charbuffer other)
  {
    swap(other);
    return *this;
  }

  void swap(charbuffer& other)
  {
    using std::swap;
    swap(_data, other._data);
  }

  char& operator[](int i)
  { 
    return (*_data)[i];
  } 

  char operator[](int i) const
  { 
    return (*_data)[i];
  } 

  size_t size() const
  {
    return _data->size();
  }

  bool valid() const
  { 
    return _data;
  }

private:
  std::shared_ptr<std::string> _data;

};

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

std::string s("possibly very long user string");

charbuffer cb(std::move(s)); // s is empty now

// use charbuffer...

Вы можете использовать полиморфизм, чтобы решить эту проблему. Базовый тип — это интерфейс к реализации вашего унифицированного буфера данных. Тогда у вас будет два производных класса. Один для std::string в качестве источника, а другой использует ваше собственное представление данных.

struct MyData {
    virtual void * data () = 0;
    virtual const void * data () const = 0;
    virtual unsigned len () const = 0;
    virtual ~MyData () {}
};

struct MyStringData : public MyData {
    std::string data_src_;
    //...
};

struct MyBufferData : public MyData {
    MyBuffer data_src_;
    //...
};