Как перераспределить память, используя new для выделения переменных внутри структуры?

Вы можете выделить любой размер с помощью malloc:

myDerivedStruct* pNewStruct = (myDerivedStruct*) malloc(
      sizeof(myDerivedStruct) + sizeof_extra data);

Однако у вас другая проблема, поскольку myDerivedStruct::ident является очень неоднозначной конструкцией. Это указатель на символ (массив), тогда структуры заканчиваются адресом, где начинается массив символов? ident может указывать куда угодно и очень неоднозначно, кто владеет массивом, на который указывает ident. Мне кажется, что вы ожидаете, что структура закончится самим фактическим массивом символов, а структура владеет дополнительным массивом. Такие структуры обычно имеют член size для отслеживания их собственного размера, чтобы API-функции могли правильно управлять ими и копировать их, а дополнительные данные по соглашению начинаются после завершения структуры. Или они заканчиваются массивом нулевой длины char ident[0], хотя это создает проблемы для некоторых компиляторов. По многим причинам в таких структурах нет места наследованию:

struct myStruct 
{
size_t size;    
int a, b, c, d;    
char ident[0];
};

Вы возвращаетесь к C или отказываетесь от этих идей и фактически используете C++ по назначению.

• Используйте конструктор для выделения памяти и деструктор для ее удаления.
• Не позволяйте другому коду записывать в ваше пространство памяти, создайте функцию, которая обеспечит выделение памяти.
• Используйте std:string или std::vector для хранения данных вместо создания собственного класса контейнера.

В идеале вы должны просто сказать:

myDerivedClass* foo = новый myDerivedClass(a, b, c, d, ident);

В текущем стандарте C++ myDerivedStruct не является POD, поскольку у него есть базовый класс. Результат memcpyвставки чего-либо в него не определен.

Я слышал, что C++0x ослабит правила, так что больше классов будут POD, чем в C++98, но я не изучал это. Кроме того, я сомневаюсь, что очень многие компиляторы разместят ваш класс таким образом, который несовместим с POD. Я ожидаю, что у вас будут проблемы только с тем, что не выполняет оптимизацию пустого базового класса. Но вот оно.

Если бы это был POD или если вы готовы рискнуть своей реализацией, то вы могли бы использовать malloc(sizeof(myStruct)+13) или new char[sizeof(myStruct)+13] для выделения достаточного пространства, в основном так же, как и в C. По-видимому, мотивация состоит в том, чтобы избежать памяти и времени. накладные расходы на то, чтобы просто поместить член std::string в свой класс, но за счет необходимости писать код для ручного управления памятью.

Вы можете перераспределить ресурсы для любого экземпляра класса, но это требует определенных затрат на управление. Единственный допустимый способ сделать это — использовать специальный вызов выделения памяти. Это можно сделать без изменения определения класса.

void* pMem = ::operator new(sizeof(myDerivedStruct) + n);
myDerivedStruct* pObject = new (pMem) myDerivedStruct;

Предполагая, что вы не перегружаете operator delete в иерархии, тогда delete pObject будет правильным способом уничтожить pObject и освободить выделенную память. Конечно, если вы выделяете какие-либо объекты в области избыточной памяти, вы должны правильно освободить их перед освобождением памяти.

После этого у вас есть доступ к n байтам необработанной памяти по этому адресу: void* p = pObject + 1. Вы можете memcpy передавать данные в эту область и из нее по своему усмотрению. Вы можете присвоить самому объекту и не должны memcpy его данные.

Вы также можете предоставить настраиваемый распределитель памяти в самом классе, который требует дополнительных size_t, описывающих объем избыточной памяти для выделения, что позволяет вам выполнять выделение в одном выражении new, но это требует дополнительных накладных расходов при разработке класса.

myDerivedStruct* pObject = new (n) myDerivedStruct;

и

struct myDerivedStruct
{
    // ...
    void* operator new(std::size_t objsize, std::size_t excess storage);

    // other operator new and delete overrides to make sure that you have no memory leaks
};

В этом контексте смешивание memcpy и new кажется ужасной идеей. Вместо этого рассмотрите возможность использования malloc.

Вы можете динамически распределять пространство, выполнив:

myDerivedStruct* pNewStruct = reinterpret_cast<myDerivedStruct*>(new char[size]);

тем не мение

Вы уверены, что хотите это сделать?

Также обратите внимание, что если вы собираетесь использовать ident в качестве указателя на начало вашей строки, это будет неправильно. На самом деле вам нужен &ident, так как переменная ident находится в начале вашего неиспользуемого пространства, интерпретация того, что в этом пространстве, как указателя, скорее всего, будет бессмысленной. Следовательно, было бы более разумно, если бы ident был unsigned char или char, а не unsigned char*.

[редактировать снова] Я просто хотел бы подчеркнуть, что то, что вы делаете, на самом деле очень плохая идея.

char* buffer = [some data here];
myDerivedStruct* pNewStruct = new myDerivedStruct();
memcpy(buffer,pNewStruct,4*sizeof(int));
pNewStruct->ident = new char[ strlen(buffer+(4*sizeof int)) ];
strcpy(pNewStruct->ident,buffer+(4*sizeof int));

Что-то такое.

Известен ли размер буфера во время компиляции? В этом случае статически выделенный массив будет более простым решением. В противном случае см. ответ Ремуса Русану выше. Вот как Win32 API управляет структурами переменного размера.

struct myDerivedStruct : public myBaseStruct
{
    int a, b, c, d;
    unsigned char ident[BUFFER_SIZE];
};

Во-первых, я не понимаю, какой смысл иметь базу myBaseStruct. Вы не дали никаких объяснений.

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

struct myDerivedStruct : public myBaseStruct {
    int a, b, c, d;
    unsigned char ident[1];
};

Размер массива не имеет значения, но он должен быть больше 0. Массивы размера 0 явно недопустимы в C++.

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

char *raw_buffer = new char[29];
myDerivedStruct* pNewStruct = reinterpret_cast<myDerivedStruct*>(raw_buffer);

После этого вы можете сделать свой memcpy, предполагая, что размер правильный.