тетср пустоты указатель на объединение

Question

Код:

union foo 
{ 
    char c; 
    int i; 
}; 

void func(void * src) 
{ 
    union foo dest; 
    memcpy(&dest, src, sizeof(union foo)); //here 
} 

Если я называю func() так:

int main() 
{ 
    char c; 
    int i; 
    func(&c); 
    func(&i); 
    return 0; 
} 

В вызове func(&c), размер c меньше sizeof(union foo), которые могут быть опасно, правда?

Есть ли линия с memcpy правильно? А если нет, то как это исправить?

Что я хочу, это безопасный звонок memcpy, который скопировал указатель void * на номер union.

---

Немного предыстории: это извлекается из очень сложной функции, а также подпись func() включая параметр void * находится вне моего контроля. Конечно, пример ничего не полезен, потому что я удалил весь код, который не имеет отношения к тому, чтобы предоставить пример с минимальным кодом.

Answer 1

Правильно ли линия с memcpy? А если нет, то как это исправить?

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

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

Answer 2

В вызове func(&c), размер c меньше sizeof(union foo), что может быть опасно, правда?

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

Но позвольте мне быть более конкретным. Согласно стандарту C, запись dest.c, но чтение dest.i будет всегда выход неопределенного поведения. Но большинство компиляторов на большинстве платформ также будут иметь четкое поведение для этих случаев. Так часто пишет dest.c, но чтение dest.i имеет смысл, несмотря на то, что говорит стандарт. В этом случае, однако, чтение от dest.i по-прежнему будет зависеть от неизвестных окружающих переменных, поэтому оно не определено не только с точки зрения стандартов, но и в очень практическом смысле.

Существует также редкий сценарий, который вы должны учитывать: c может быть расположен в самом конце выделенных страниц памяти. (Это относится к страницам памяти, выделенным из операционной системы и, в конечном итоге, к устройству управления памятью (MMU), а не к блочному распределению пространства пользователя, сделанному malloc и друзьям.) В этом случае чтение более одного байта может привести к доступ к немаркированной памяти и, следовательно, вызывают серьезную ошибку, скорее всего, сбой программы. Учитывая расположение вашего c в качестве автоматической переменной в главном, это кажется маловероятным, но я полагаю, что этот фрагмент кода является лишь примером.

Является ли линия с memcpy правильной? А если нет, то как это исправить?

В зависимости от того, что вы хотите сделать. Как бы то ни было, код не имеет особого смысла, поэтому я не знаю, какое правильное разумное приложение вы могли бы иметь в виду.Возможно, вам необходимо передать sizeof объект src на номер func.

Answer 3

memcpy в порядке. Пропустив адрес наименьшего члена профсоюза, вы закончите мусор в большем члене. Способ избежать бит мусора состоит в том, чтобы по умолчанию сделать все вызовы func - что я предполагаю, что вы выполняете управление - используйте только указатели на более крупный элемент - этого можно добиться, установив более крупный элемент на меньший: i = c, а затем позвоните по телефону func(&i).

Answer 4

Поскольку вы знаете, что и какой размер для копирования, почему бы не дать более явную функцию, пусть функция знает, как скопировать нужный размер памяти, на который указывает указатель void.

union foo 
{ 
    char c; 
    int i; 
}; 

void func(void * src, const char * type) 
{ 
    union foo dest; 

    if(strcmp(type, "char") == 0){ 
     memcpy(&dest, src, 1); 
    }else if(...){ 

    } 
} 

Answer 5

func сам в порядке.

Проблема заключается в том, действительно ли вызывающий должен убедиться, что память, на которую ссылаются при вызове func(), составляет не менее sizeof(union foo).

Если последнее всегда так, все в порядке. Это не случай для двух вызовов func() в примере OP.

Если память, на которую ссылаются при вызове func(), меньше sizeof(union foo), то memcpy() провоцирует неопределенное поведение.