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

Если указатель на объект брошен в указатель на различный объект, получившийся указатель может быть неправильно выровнен. Неправильное выравнивание вызывает неопределенное поведение.

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

Исключение: можно преобразовать указатель на тип объекта в указатель на один из следующих типов:

signed   char *p1;
unsigned int *p2;

void foo(void){ 
  p2 = ( unsigned int * ) p1;     /* Non-compliant */				
}

В этом примере, p1 может указать на signed char объект. Однако p1 брошен к указателю, который указывает на объект более широкого типа, unsigned int.

extern unsigned int read_value ( void );
extern void display ( unsigned int n );

void foo ( void ){
  unsigned int u = read_value ( );
  unsigned short *hi_p = ( unsigned short * ) &u;    /* Non-compliant  */	
  *hi_p = 0;                                         
  display ( u );                                     
}

В этом примере, u unsigned int переменная. &u брошен к указателю, который указывает на объект более узкого типа, unsigned short.

На машине с обратным порядком байтов, операторе *hi_p = 0 попытки очистить высокие биты ячейки памяти, что &u точки к. Но, от результата display(u), вы можете найти, что высокие биты не были очищены.

const short *p;
const volatile short *q;
void foo (void){
  q = ( const volatile short * ) p;  /* Compliant */								
}

В этом примере, обоих p и q может указать на short объекты. Бросок между ними добавляет volatile спецификатор только и поэтому совместим.

Эта проблема происходит, когда вы делаете следующее в последовательности:

Чтение из перераспределенной памяти, которая не была повторно инициализирована, приводит к неопределенному поведению.

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

Средство проверки рассматривает любой доступ для записи на указателе на перераспределенную память как удовлетворение требованию реинициализации (даже если объектная сила только быть частично повторно инициализированным). Доступ для записи на указателе на перераспределенную память может произойти через указатель, разыменовывают или индексация массива. Передача указателя на функцию, которая берет указатель на non-const- квалифицированный объект как соответствующий параметр также рассчитывает как доступ для записи.

#include<stdlib.h>

struct group {
    char *groupFirst;
    int groupSize;
};

struct groupWithID {
    int groupID;
    char *groupFirst;
    int groupSize;
};

char* readName();
int readSize();

void createGroup(int nextAvailableID) {
    struct group *aGroup;
    struct groupWithID *aGroupWithID;
    
    aGroup = (struct group*) malloc(sizeof(struct group));
    
    if(!aGroup) {
        /*Handle error*/
    }
    
    aGroup->groupFirst = readName();
    aGroup->groupSize  = readSize();
    
    /* Reassign to group with ID */
    aGroupWithID = (struct groupWithID*) realloc(aGroup, sizeof(struct groupWithID));
    if(!aGroupWithID) {
        free(aGroup);
        /*Handle error*/
    }
    
    if(aGroupWithID -> groupSize > 0) { /* Noncompliant */
        /* ... */
    }
    
    /* ...*/
    free(aGroupWithID);
}

В этом примере, память, выделенная group* указатель с помощью malloc функция перераспределена к groupWithID* указатель с помощью realloc функция. Существует доступ для чтения на перераспределенной памяти, прежде чем память будет повторно инициализирована.

Повторно инициализируйте память, присвоенную groupWithID* указатель перед первым доступом для чтения. Все биты памяти могут быть повторно инициализированы с помощью memset функция.

#include<stdlib.h>
#include<string.h>

struct group {
    char *groupFirst;
    int groupSize;
};

struct groupWithID {
    int groupID;
    char *groupFirst;
    int groupSize;
};

char* readName();
int readSize();

void createGroup(int nextAvailableID) {
    struct group *aGroup;
    struct groupWithID *aGroupWithID;
    
    aGroup = (struct group*) malloc(sizeof(struct group));
    
    if(!aGroup) {
        /*Handle error*/
    }
    
    aGroup->groupFirst = readName();
    aGroup->groupSize  = readSize();
    
    /* Reassign to group with ID */
    aGroupWithID = (struct groupWithID*) realloc(aGroup, sizeof(struct groupWithID));
    if(!aGroupWithID) {
        free(aGroup);
        /*Handle error*/
    }
    
    memset(aGroupWithID, 0 , sizeof(struct groupWithID));
    /* Reinitialize group */
    if(aGroupWithID -> groupSize > 0) { 
        /* ... */
    }
    
    /* ...*/
    free(aGroupWithID);
}