Объекты с переменной длиной: Всегда хорошая идея?

Question

В моем приложении используется большое количество Panda объектов. Каждый Panda имеет список Bamboo объектов. Этот список не изменяется после инициализации Panda (не добавляются или удаляются объекты Bamboo). В настоящее время мой класс реализуется следующим образом:

class Panda 
{ 
    int a; 
    int b; 
    int _bambooCount; 
    Bamboo* _bamboo; 

    Panda (int count, Bamboo* bamboo) 
    { 
    _bambooCount = count; 
    _bamboo = new Bamboo[count]; 

    // ... copy bamboo into the array ... 
    } 
} 

Чтобы облегчить нагрузку выделения массива Bamboo объектов, я мог бы реализовать этот класс следующим образом - в основном, вместо того, чтобы создавать объекты с помощью регулярного конструктора, конструкции метод выделяет один блок памяти для хранения как Panda объекта и его Bamboo массива:

class Panda 
{ 
    int a; 
    int b; 

    Panda() 
    { 
     // ... other initializations here ... 
    } 

    static Panda *createPanda (int count, Bamboo* bamboo) 
    { 
    byte* p = new byte[sizeof(Panda) + 
     sizeof(Bamboo) * count]; 
    new (p) Panda(); 

    Bamboo* bamboo = (Bamboo*) 
     p + sizeof(Panda); 

    // ... copy bamboo objects into the memory 
     // behind the object... 

     return (Panda*)p; 
    } 
} 

Может ли вы предвидеть любые проблемы со второй конструкцией, кроме возросшего усилия по техническому обслуживанию? Является ли это приемлемым шаблоном дизайна или просто преждевременной оптимизацией, которая могла бы снова укусить меня?

Answer 1

C++ дает вам еще один вариант. Вы должны рассмотреть использование std :: vector.

class Panda 
{ 
    int a; 
    int b; 
    std::vector<Bamboo> bamboo; 
    // if you do not want to store by value: 
    //std::vector< shared_ptr<Bamboo> > bamboo; 

    Panda (int count, Bamboo* bamb) : bamboo(bamb, bamb+count) {} 
} 

Если вы хотите сохранить Panda и бамбук в непрерывной памяти можно использовать раствор из this article. Основная идея - перегрузить operator new и operator delete.

Answer 2

Вы используете «новый» вид нового оператора. Это полностью правильная относительная Panda, но почему вы не используете Bamboo initializer?

Answer 3

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

//compiler allocates 16-bytes on the stack for this local variable 
Panda panda = *createPanda(15, bamboo); 

Это может быть приемлемо (но очень вероятно, преждевременно и ужасно оптимизации), если вы только когда-либо относятся к вещам, по указателю и никогда не по значению, и если вы берегитесь конструктор копирования и оператор присваивания.

Answer 4

Основываясь на моем опыте, преждевременная оптимизация всегда всегда «преждевременна». То есть вы должны профилировать свой код и определять, нужно ли оптимизировать или нет, или просто создаете больше работы для себя в долгое время.

Кроме того, мне кажется, что вопросы о том, стоит ли оптимизация или нет, сильно зависят от размера класса Bamboo и среднего количества бамбуковых объектов на Panda.

Answer 5

Это было найдено в C.
Но в C++ нет настоящей необходимости.

Реальный вопрос, почему вы хотите это сделать?

Это преждевременная оптимизация, просто используйте std :: vector <> внутренне, и все ваши проблемы исчезнут.

Поскольку вы используете RAW указатель внутри, что класс владеет вам нужно будет переопределить версии по умолчанию:

• По умолчанию Конструктор
• Destructor
• конструктор копирования
• оператора Назначение

Answer 6

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

- Дейкстр

Answer 7

Если вы что отчаянный, вы, вероятно, можете сделать что-то вроде этого:

template<std::size_t N> 
class Panda_with_bamboo : public Panda_without_bamboo 
{ 
    int a; 
    int b; 
    Bamboo bamboo[N]; 
} 

Но я верю, что вы не отчаянными, но оптимизировать преждевременно.