после того, как я изучаю о allocator в течение нескольких дней, прочитав некоторые статьи
(cppreference и Мы) ,
Я смущен тем, как управлять структурой данных для выделения памяти определенным образом.

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

вот что я (mis)поймите: -

фрагмент

предположим, что B::generateCs() - это функция, которая создает список C из списка CPrototype.
The B::generateCs() используется B() конструктора:-

class C          {/*some trivial code*/};
class CPrototype {/*some trivial code*/};
class B {
    public: 
    std::vector<C> generateCs() {  
        std::vector<CPrototype> prototypes = getPrototypes();
        std::vector<C> result;                     //#X
        for(std::size_t n=0; n < prototypes.size(); n++) {
            //construct real object  (CPrototype->C)
            result.push_back( makeItBorn(prototypes[n]) ); 
        }
        return result;
    }
    std::vector<C> bField;    //#Y
    B() {
        this->bField = generateCs();    //#Y  ; "generateCs()" is called only here
    }
    //.... other function, e.g. "makeItBorn()" and "getPrototypes()"
};

в приведенном выше коде std::vector<C> в настоящее время используется общий default std::allocator.

для простоты, с этого момента, скажем, есть только 2 распределителя (рядом с std::allocator) ,
что я код сам или изменить где-то :-

• HeapAllocator
• StackAllocator

Часть 1 (#X)

этот фрагмент можно улучшить с помощью конкретного распределителя типов.
Его можно улучшить в 2 положениях. (#X и #Y)

std::vector<C> в строке #X кажется, переменная стека,
поэтому я должен использовать stack allocator :-

std::vector<C,StackAllocator> result;   //#X

это имеет тенденцию давать производительность прибыль. (#X закончена.)

Часть 2 (#Y)

далее, более трудная часть в B() конструктор. (#Y)
Было бы неплохо, если переменная bField имеет соответствующий протокол распределения.

просто кодирование звонящего использовать распределитель явно невозможно, потому что вызывающий конструктор может делать только то, что: -

std::allocator<B> bAllo;   
B* b = bAllo.allocate(1);   

, который не имеет никакого влияния на протокол распределения bField.

таким образом, это обязанность самого конструктора, чтобы выбрать правильный протокол распределения.

Часть 3

я не могу знать, является ли экземпляр B будет построен как переменная кучи или переменная стека.
Это важно, потому что эта информация важна для выбора правильного распределителя/протокола.

если я знаю, какой из них (куча или стек), я могу изменить объявление bField to быть:-

std::vector<C,StackAllocator> bField;     //.... or ....
std::vector<C,HeapAllocator> bField;     

к сожалению, с ограниченной информацией (я не знаю, какая это будет куча/стек, это может быть и то, и другое),
этот путь (используя std::vector) ведет в тупик.

Часть 4

поэтому лучший способ-передать распределитель в конструктор: -

MyVector<C> bField; //create my own "MyVector" that act almost like "std::vector"
B(Allocator* allo) {
    this->bField.setAllocationProtocol(allo);  //<-- run-time flexibility 
    this->bField = generateCs();   
}

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

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

class System1 {
    Allocator* heapForSystem1;
    void test(){
        B b=B(heapForSystem1);
    }
};
class System2 {
    Allocator* heapForSystem2;
    void test(){
        B b=B(heapForSystem2);
    }
};

вопрос

• где я начал ошибаться, как?
• как я могу улучшить фрагмент, чтобы использовать соответствующий распределитель (#X и #Y)?
• когда я должен передать распределитель в качестве параметра?

трудно найти практический пример использования распределителя.

редактировать (ответ Уолтер)

... использование другого, чем std:allocator, рекомендуется редко.

Это было бы ценное знание, если бы оно было надежным.

1. Существуют ли какие-либо книги/ссылки/ссылки/доказательства, подтверждающие это?
Список не поддерживает требование. (Он на самом деле поддерживает противоположное немного.)
Это из личного опыта?

2. Ответ как-то противоречит многим источникам. Прошу защиты.
Есть много источников, которые рекомендуют не использовать std:allocator<>.

• Мы :
  Не могу ответить "сколько памяти вы используете для подсистемы X?- виновен.
• пользовательские распределители C++ подходит для видеоигр
  Это означает, что пользовательский распределитель является обязательным для консольных игр.
  _{@ раздел " зачем заменять распределитель по умолчанию?"}
• управление памятью часть 1 из 3
  без пользовательского распределителя = " время от времени есть небольшое отставание (в игре)"

более конкретно, они просто "шумиха", которую редко стоит использовать в реальном мире?

еще один маленький вопрос :-
Может ли претензия быть расширена до "большинство качественных игр редко используют пользовательский распределитель"?

3. Если я нахожусь в такой редкой ситуации, я должен заплатить за это, верно?

есть только 2 хороших способа:-

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

это правильно?