A>1  std::string a;
A>2  std::string b;
A>3  a = "aaaa";
A>4  b = a;
A>5  a = "bbbb";
A>

A>И то и другое мало похоже на правду

1  std::string a;
2  std::string b;
3  a = "aaaa"; // reference count to "aaaa" = 1 (self)
4  b = a;      // reference count to "aaaa" = 2 (a and b). Reference count to "aaaa" in b instance = 1;
5  a = "bbbb"; // a now owned another string ("bbbb"). 
               // Decrement reference count to "aaaa" (if 0 - delete "aaaa"), 
               // then allocate new buffer for string, copy string to buffer and set 
               // reference count to 1 (exclusive ownership).
               // In this sample, b had continue ownership to string "aaaa" with reference count = 1.

void some_func(std::string arg1, std::string arg2) // так пишет "криворукий" программист :))
{

namespace std
{
  void swap(std::string & str1, std::string & str2)
    {
      str1.swap(str2);
    }
}

std::string f(const std::string& s1)
{
  std::string s2 = s1;
  s2[2] = 'x';
  return s2;
}

class SomeClass
 {
   CriticalSection cs;
   
   String str;
   
  public:
  
   void setMessage(const String &str_) 
    {
     CriticalLock lock(cs);
      
     str=str_; 
    }
    
   void getMessage(String &ret) 
    {
     CriticalLock lock(cs);
      
     ret=str; 
    }
 };

inline void DetachedCopy(String &ret,const String &str)
 {
  ret=String(str.c_str());
 }

class SomeClass
 {
   CriticalSection cs;
   
   String str;
   
  public:
  
   void setMessage(const String &str_) 
    {
     CriticalLock lock(cs);
      
     DetachedCopy(str,str_);
    }
    
   void getMessage(String &ret) 
    {
     CriticalLock lock(cs);
      
     DetachedCopy(ret,str);
    }
 };

F>1  std::string a;
F>2  std::string b;
F>3  a = "aaaa"; // reference count to "aaaa" = 1 (self)
F>4  b = a;      // reference count to "aaaa" = 2 (a and b). Reference count to "aaaa" in b instance = 1;
F>5  a = "bbbb"; // a now owned another string ("bbbb"). 
F>               // Decrement reference count to "aaaa" (if 0 - delete "aaaa"), 
F>               // then allocate new buffer for string, copy string to buffer and set 
F>               // reference count to 1 (exclusive ownership).
F>               // In this sample, b had continue ownership to string "aaaa" with reference count = 1.
F>

string a = "aaaa";
string b = a;
cout << a[1] << '\n'; // (*)

F>Сорри фор инглиш — пиво было хорошее, и, как следствие закона сохранения энергии — инглиш получился фиговым

static std::string mystring;

AD>У... Как всё у нас тут запущено...

AD>class CTask
AD>{
AD>  int id;
AD>  std::vector<char> message;

AD>public:
AD>  ...
AD>

AD>ЗЫ: сижу в резиновом плаще и жду

class CTask
{
  int id;
  std::string message;
    
public:
  ...

1  std::string a;
2  std::string b;
3  a = "aaaa";
4  b = a;
5  a = "bbbb";

...
So deeply rooted is the idea that copy-on-write reference counting is mandatory for strings that many developers are shocked — and sometimes go into denial — when they discover that the return on investment in this technique is often negligible and sometimes negative. The long-standing belief in this old practice is, however, younger than faith in another more fundamental software engineering principle: separation of concerns. And hey, do we have concerns.
...

...
Without atomic integer operations, copy-on-write typically incurs a significant performance penalty. Even with atomic integer operations, COW can make common String operations take nearly 50% longer -- even in single-threaded programs.

In general, copy-on-write is often a bad idea in multithread-ready code. In short, the reason is that the calling code can no longer know whether two distinct String objects actually share the same representation under the covers, and so String must incur overhead to do enough serialization that calling code can take its normal share of responsibility for thread safety. Depending on the availability of more-efficient options like atomic integer operations, the impact on performance ranges from "moderate" to "profound."
...

Использовать планируется так:

std::vector<CTask> CTasks;

CTask t1(1);
t1.SetMessage("Hello!");

CTasks.push_back(t1);

element {
  std::vector< std::pair<std::string,std::string>> attributes;
}

A>Делись!

class NoCopy
 {
   NoCopy(const NoCopy &) {} 
   void operator = (const NoCopy &) {}
 
  public:
  
   NoCopy() {}
 };

EX>std::string a="hello";
EX>std::string b=a;

template<class T>
class cowboy // парадокс: несколько ковбоев пасут одну корову :))
{
public:
    cowboy(); // разделяет общие дефолтные данные
    cowboy(const T& data); // клонирует
    cowboy(const cowboy& buddy); // разделяет данные с партнёром (если тот не монополист), либо клонирует
    
    cowboy& operator=(const T& data); // клонирует
    cowboy& operator=(const cowboy& buddy); // разделяет либо клонирует
    
    ~cowboy(); // отпускает (возможно, удаляет)
    
    const T& get() const; // ничего не меняет
    
    void take(); // отпочковывает, заявляет монопольные права
    T& unsafe(); // ничего не меняет при условии монопольного права (должен быть предварён вызовом take(), валиден до give())
    void give(); // снимает монопольные права
        // take/give должны быть реентерабельны, поэтому у буфера, помимо счётчика ссылок, есть счётчик монопольности
        // если счётчик монопольности == 0, то данные можно разделять
        // если счётчик монопольности > 0, то счётчик ссылок == 1 (кроме этого экземпляра, никто буфером не владеет)
        // в случае, если забыли снять монопольность, просто будут немедленные клонирования в копикторе и присваивании
        // если же забыли назначить монопольность, то при модификации через unsafe() возможно unspecified и даже undefined behavior
        
    // простенькая обёртка для вызова
    class taker
    {
        cowboy& domain;
    public:
        taker(cowboy& d) : domain(d) { domain.take(); }
        taker(const taker& src) : domain(d) { domain.take(); }
        T& get() const { return domain.unsafe(); }
        ~taker() { domain.give(); }
    };
    taker safe() { return taker(*this); }
    
private:
    // лень расписывать
};

.....
class Holder
{
    cowboy<string> str;
        
    с1() { cout << str.get() << endl; } // константный доступ
    с2() { const string& ref = str.get(); cout << ref << endl; } // не нуждается в какой-то рантаймовой защите
    
    m1() { str.take(); str.unsafe() = "a"; str.unsafe() += "b"; str.give(); } // а неконстантный - нуждается
    // причём в пределах защиты можно держать ссылки на данные
    m2() { str.take(); string& ref = str.unsafe(); ref += "c"; ref += "d"; str.give(); }
    // хороший стиль - использовать scope guard
    m3() { cowboy<string>::taker t(str); str.unsafe() += "e"; m2(); str.unsafe() += "f"; } // заодно - пример реентера
    m4() { str.safe().get() = "g"; } // для однократной защиты можно получить умную ссылку 
};

ПК>Мне кажется, с процентами ты немного преувеличил

527       enum
528         {
529           F_NONE         = 0,       // no flags
530 
531           // data flags are in the lower 16-bits
532           F_TERMINATED   = 1 << 0,  // IsTerminated returns true
533           F_VOIDED       = 1 << 1,  // IsVoid returns true
534           F_SHARED       = 1 << 2,  // mData points to a heap-allocated, shared buffer
535           F_OWNED        = 1 << 3,  // mData points to a heap-allocated, raw buffer
536           F_FIXED        = 1 << 4,  // mData points to a fixed-size writable, dependent buffer
537 
538           // class flags are in the upper 16-bits
539           F_CLASS_FIXED  = 1 << 16   // indicates that |this| is of type nsTFixedString
540         };
541 
542       //
543       // Some terminology:
544       //
545       //   "dependent buffer"    A dependent buffer is one that the string class
546       //                         does not own.  The string class relies on some
547       //                         external code to ensure the lifetime of the
548       //                         dependent buffer.
549       //
550       //   "shared buffer"       A shared buffer is one that the string class
551       //                         allocates.  When it allocates a shared string
552       //                         buffer, it allocates some additional space at
553       //                         the beginning of the buffer for additional 
554       //                         fields, including a reference count and a 
555       //                         buffer length.  See nsStringHeader.
556       //                         
557       //   "adopted buffer"      An adopted buffer is a raw string buffer
558       //                         allocated on the heap (using nsMemory::Alloc)
559       //                         of which the string class subsumes ownership.
560       //
561       // Some comments about the string flags:
562       //
563       //   F_SHARED, F_OWNED, and F_FIXED are all mutually exlusive.  They
564       //   indicate the allocation type of mData.  If none of these flags
565       //   are set, then the string buffer is dependent.
566       //
567       //   F_SHARED, F_OWNED, or F_FIXED imply F_TERMINATED.  This is because
568       //   the string classes always allocate null-terminated buffers, and
569       //   non-terminated substrings are always dependent.
570       //
571       //   F_VOIDED implies F_TERMINATED, and moreover it implies that mData
572       //   points to char_traits::sEmptyBuffer.  Therefore, F_VOIDED is
573       //   mutually exclusive with F_SHARED, F_OWNED, and F_FIXED.

class InfoProvider{
public:
  std::string getInfo(const std::string& key)const
  {
    MutexGuard g(mtx);
    StringToStringMap::iterator it=infoMap.find(key);
    if(it==infoMap.end())return "";
    return *it;
  }
protected:
  typedef std::map<std::string,std::string> StringToStringMap;
  StringToStringMap infoMap;
  Mutex mtx;
};