Home / Questions / 131962
Accepted
NaCl
Asked: 2020-01-19 05:33:16 +0800 CST 2020-01-19 05:33:16 +0800 CST

What is the reserved word 'void' in the various languages ​​that use it?

  • 772

I have read somewhere a question that was about the pointer to voidor void *and the doubt about the reserved word voidof several languages ​​has arisen.

I have this code:

typedef enum VALUE_TYPE {
  VT_INTEGER, VT_STRING, VT_BOOL, VT_NULL
} valuetype_t;

typedef struct VALUE {
  void *iv;
  valuetype_t tp;
} value_t;

But I don't understand much what the void *in the is for struct.

As far as I understand, in and , the type voidis everything and it is nothing, but I am not very clear about what this is about.

Can someone explain to me what it is voidand its functions in the various languages ​​that use it?

Note: I've only used and because I'm not sure about using the tag , feel free to edit this snippet and the question tags.

c++

1 Answers

  1. Best Answer

    For and it is true that it voidpractically means nothing , but adding a simple asterisk ( *) to it, it can be everything or, rather, Anything!

    Starting with parts, the reserved word voidhas the following use cases in C (among others) :

    Type specifier:

    void HacerAlgoQueNoRetorna(void);

    Above is the declaration of a function of type void, that is, one that does not return a value of some type and therefore cannot have a variable of type voidto which to assign the return of the function:

    void MiVariable; /* Imposible! Se desatarán las aguas si esto pasase. */

    And much less:

    void MiVariable = HacerAlgoQueNoRetorna(); /* ¡RENUNCIO! */

    If you noticed in the first block of code, I used (void)in the parameters part that the method declared there uses, this is explained below.

    Function sealer .

    By default, C functions are variadic when voidnot explicitly put between the parentheses of the function definition 1 :

    void HacerAlgo() {}      /* Sí, entre esos paréntesis. */

int main(void) {
  HacerAlgo(10, 15, 20); /* Es totalmente normal, no pasará nada. */
}

    However, when we use voidbetween the parentheses, then the above doesn't work:

    void HacerAlgo(void) {}  /* Sí, entre esos paréntesis. */

int main(void) {
  HacerAlgo(10, 15, 20); /* Es totalmente normal, espera... ¡ERROR! */
}

    Delete... Warnings?

    It's never a good idea to suppress the warnings your compiler throws when there are non-killing problems that can cause unspecified behavior in your software:

    (void)fread(mi_contenido, 1, total, mi_archivo);

    In this context, it (void)serves as a casting or conversion operator ... as we are casting to nothing, the value is useless . Man!

    However, there are some compilers that instead throw a warning when using the cast to void.

    What we all expected... void *is whatever, or... so we thought.

    Yes, void, accompanied by a *, is a powerful data type that stores a pointer to any other existing data type, in fact, it is what the functions that reserve memory return:

    void *malloc(size_t sz);
void *calloc(size_t *sz, size_t nelem);
void *realloc(void *old, size_t new_size);

    And this is because it void *is a pointer to a memory address whose type is unknown 2 , which is what you do in the code you have in the question, you define a type fieldvoid * and guess its value by means of another variable.

    I really think it void *should be avoided or only used when the value it points to is known exactly:

    void *mi_memoria = calloc(1, 1000); /* Reservamos 1000 bytes. */

    In fact, I can do whatever I want with that memory 3 :

    #include <stdio.h>
#include <stdlib.h>

int main(void) {
  void *mi_memoria = calloc(1, 1000);
  int  *como_int = mi_memoria;          /* No hay problema alguno.   */
  int   t = 0;
  int   sz = (1000 / sizeof(int)) - sizeof(int); /* Sepamos el tamaño. */
  while (t <= sz)
    como_int[t] = t * 4;
  t = 0;
  while (t <= sz)
    printf("como_int[%d] = %d\n", t, como_int[t]);
  free(mi_memoria);
  return 0;
}

    In the example above, I've used it to store a 1000 byte dynamically allocated memory pointer, but since I didn't know what to do with those bytes, so I used them to store integers, likewise, I can convert that pointer to voidto a pointer to charand store a text string.

    But what is left when we pass a pointer from anything else to a type parameter void *? The important thing about this is that C is somewhat permissive (I don't want it to have children) and automatically converts to void *4 so that the called function can work with the pointer passed as an argument.

    The pointer to voidis a very powerful type in wise hands, however, it can cause oversights and problems in the code, like any good C practice, it is recommended not to abuse this type.

    1 : Ideone to check it out.
    2 : It's not entirely unheard of, but a pointer of type void only lets us know the address it points to, not the data it contains.
    3 : Ideone to check it out.
    4 : All the pointers have the same size, the only thing that changes is the way of interpreting the memory addresses according to the environment in which it runs.

    • 16