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

Question

Так у меня есть несколько структур ...

struct myBaseStruct 
{ 
}; 

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

myDerivedStruct* pNewStruct; 

... и я хочу, чтобы динамически выделять достаточно мест, так что я могу «тетср» в некоторых данных, в том числе заканчивающегося нуля. Размер базовой структуры, по-видимому, «1» (я предполагаю, потому что он не может быть равен нулю), а размер производного равен 20, что, по-видимому, имеет смысл (5 х 4).

Итак, у меня есть буфер данных, размер которого равен 29, первые 16 байтов - это int, а остальные 13 - строка.

Как я могу выделить достаточно памяти для pNewStruct, чтобы этого было достаточно? В идеале, я просто хочу пойти:

• выделить 29 байт в pNewStruct;
• memcpy из буфера в pNewStruct;

Спасибо,

Answer 1

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

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

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

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

Answer 2

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

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

однако

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

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

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

Answer 3

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

Answer 4

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)); 

Что-то в этом роде.

Answer 5

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

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

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

Answer 6

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

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

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

myDerivedClass * Foo = новый myDerivedClass (а, Ь, с, d, идентификаторы);

Answer 7

Является ли размер буфера известен во время компиляции? В этом случае статически назначенный массив будет более простым решением. В противном случае см. Ответ Ремуса Русану выше. Вот как win32 api управляет структурами с переменным размером.

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

Answer 8

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

Во-вторых, то, что вы указали в своем оригинальном посте, не будет работать с описанным вами макетом данных. За то, что вы описали в ОП, необходимо последний член структуры, чтобы быть массивом, а не указатель

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, предполагая, что размер правильный.

Answer 9

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

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 
};