Solution for "dereferencing" void * 'pointer "warning in a struct in C?

I think your design will fail, but I'm also not convinced that the other answers I see are entirely about deeper reasons.

It looks like you are trying to use C to deal with generic types, which always gets hairy. You can do this if you're careful, but it's not easy, in which case I doubt it would be helpful.

Deeper mind . Suppose we have overcome syntactic (or hardly syntactic) problems. Your code shows T10CNT contains 20 int

and T20CNT contains 20 long

. On modern 64-bit machines - except Win64 - sizeof(long) != sizeof(int)

. Therefore, the code inside your print function must distinguish between dereferencing int

arrays and long

arrays. There is a rule in C ++ that you shouldn't try to handle arrays polymorphically, and that's why. CMNCNT type contains 3 long

values; unlike the structures T10CNT and T20CNT, although the underlying array type is T20CNT.

Style guide: I highly recommend avoiding underscores on names. In general, names beginning with an underscore are reserved for implementation use and for use as macros. Macros have nothing to do with scope; if the implementation defines a _cnt macro, it will destroy your code. There are nuances in what names are reserved; I am not going to get into these nuances. It is much easier to think that "names starting with underscores are reserved" and that will save you the trouble.

Style tip: Your print function returns success unconditionally. This is unreasonable; your function shouldn't return anything, so the caller doesn't need to check for success or failure (since he can never fail). A careful coder who notices that a function is returning a status will always check the return status and have error handling code. This code will never get executed, so it's dead, but it's hard for anyone (or the compiler) to figure it out.

Surface correction: temporary, we can assume that you can think of int

and long

as synonyms; but you have to get in the habit of thinking that they are synonymous. An argument void *

is the correct way to say "this function takes an undefined pointer". However, inside the function, you need to convert from void *

to a specific type before indexing.

typedef struct _CMNCNT
{
    long    count[3];
} CMNCNT;

static void printCommonStatistics(const void *data, size_t nelem, size_t elemsize)
{
    int i;
    for (i = 0; i < nelem; i++)
    {
        const CMNCNT *cmncnt = (const CMNCNT *)((const char *)data + (i * elemsize));
        fprintf(stdout,"STATISTICS_INP: %ld\n", cmncnt->count[0]);
        fprintf(stdout,"STATISTICS_OUT: %ld\n", cmncnt->count[1]); 
        fprintf(stdout,"STATISTICS_ERR: %ld\n", cmncnt->count[2]);
    }
}

      

        
        
        
      

    

(I like the idea of ​​a file stream called stout

). Suggestion: Use cut'n'paste for real source code - it's safer! I usually use " sed 's/^/ /' file.c

" to prepare the code to cut the "response" into the "SO" response.)

What does this casting line do? I'm glad you asked ...

• The first operation is to convert const void *
  
  to const char *
  
  ; this allows operations on the size of the bytes by address. In the days before the standard, C was instead void *
  
  used char *
  
  as a universal addressing mechanism.
• The following operation adds the correct number of bytes to jump to the beginning of the i
  
  th element of the size object array elemsize
  
  .
• The second cast tells the compiler "trust me - I know what I'm doing" and "treat this address as the address of the CMNCNT structure".

From there, the code is simple enough. Please note, since the CMNCNT structure contains a value long

, I used %ld

to tell the truth fprintf()

.

Since you are not going to change the data in this function, it would be nice to use a qualifier const

like I did.

Note that if you are correct sizeof(long) != sizeof(int)

, you will need two separate blocks of code (I would suggest separate functions) to work with array int

and 'array long

'.