How to efficiently swap two parts of string without allocation?

You might swap the common size and rotate the remaining part:

void swapInPlace(std::string& s, sizet a, sizet nexta, sizet b, sizet nextb)
{
    const auto minlength = std::min(nexta - a, nextb - b);
    std::swapranges(s.begin() + a, s.begin() + a + minlength, s.begin() + b);
    if (nexta - a < nextb - b) {
        std::rotate(s.begin() + nexta,
                    s.begin() + b + minlength,
                    s.begin() + nextb);
    } else {
        std::rotate(s.begin() + a + minlength,
                    s.begin() + nexta,
                    s.begin() + next_b);
    }
}

Demo

A common implementation of rotate uses reverse. Let's do that directly:

void swapInPlace(std::string& data, sizet a, sizet nexta, sizet b, sizet nextb) {
  auto ba = data.begin() + a;
  auto ea = ba + (nexta - a);
  auto bb = data.begin() + b;
  auto eb = bb + (nextb - b);
  // example:
  //    ba  ea bb
  //    |   |  | eb
  //    |   |  | |
  //    v   v  v v
  // abc1234rst78xyz
  std::reverse(ba, ea);
  // abc4321rst78xyz
  std::reverse(ea, bb);
  // abc4321tsr78xyz
  std::reverse(bb, eb);
  // abc4321tsr87xyz
  std::reverse(ba, eb);
  // abc78rst1234xyz
}

void swapInPlace(std::string& s, sizet a, sizet nexta, sizet b, sizet nextb) {
    const sizet lenb = nextb - b;
    const sizet lena = nexta - a;
    const sizet lengap = b - nexta;
    std::rotate(s.begin() + a, s.begin() + b, s.begin() + nextb);
    const auto newastart = s.begin() + a + lenb;
    std::rotate(newastart, newastart + lena, newastart + lena + lengap);
}

#include 
#include 
template
void swapinplace(It pa, It pz, It qa, It qz)
{
    //  Ppp...Qqqqq     or   Ppppp...Qqq
    auto pm = std::swapranges(qa, qz, pa);
    //  Qqqqq.Ppp..     or   Qqqpp...Ppp
    std::rotate(pm, pm < pz ? pz : qa + (pz - pa), qz);
    //  Qqqqq...Ppp     or   Qqq...Ppppp
}

#include 
#include 
int main()
{
    std::wstring s{LR"--(That is a "foobar", this here is a "baz")--"};
    {
        auto pa = s.begin() + 11;
        auto pz = pa + 6;
        auto qa = s.begin() + 36;
        auto qz = qa + 3;
        swapin_place(pa, pz, qa, qz);
        // That is a "baz", this here is a "foobar"
        std::wcout