Basically it means "nothing" or "no type"

There are 3 basic ways that void is used:

1. Function argument: int myFunc(void) -- the function takes nothing.

2. Function return value: void myFunc(int) -- the function returns nothing

3. Generic data pointer: void* data -- 'data' is a pointer to data of unknown type, and cannot be dereferenced

Note: the void in a function argument is optional in C++, so int myFunc() is exactly the same as int myFunc(void), and it is left out completely in C#. It is always required for a return value.

The other comments explain it well but here are some examples. void greet() { printf("Hello, world!\n"); } This is void because it does not return anything, it just does what it is told and doesn't report back. int add(int num1, int num2) { int sum = num1 + num2; return sum; } This has "int" where void would be, because it returns an int value. you would call this somewhere else in the code like so: int total = add(1,2);

The keyword void (not a pointer) means "nothing" in those languages. This is consistent.

As you noted, void* means "pointer to anything" in languages that support raw pointers (C and C++). This is an unfortunate decision because as you mentioned, it does make void mean two different things.

I have not been able to find the historical reason behind reusing void to mean "nothing" and "anything" in different contexts, however C does this in several other places. For example, static has different purposes in different contexts. There is obviously precedent in the C language for reusing keywords this way, regardless of what one may think of the practice.

Java and C# are different enough to make a clean break to correct some of these issues. Java and "safe" C# also do not allow raw pointers and do not need easy C compatibility (Unsafe C# does allow pointers but the vast majority of C# code does not fall into this category). This allows them to change things up a bit without worrying about backwards compatibility. One way of doing this is introducing a class Object at the root of the hierarchy from which all classes inherit, so an Object reference serves the same function of void* without the nastiness of type issues and raw memory management.

Void is used as the return type when declaring a function that doesnt return anything. If I wrote a function that returned an int I would use int as the return type: ``` int someFunction(int a, int b) { int sum = a + b; return sum; } ``` if I wrote a function that doesnt return anything, I would need to use void as the return type ``` void someFunction(int a, int b) { //im not returning anything here, just printing it out on screen int sum = a + b; printf("%d", sum); //since nothing is being returned in the function, the return type should be void } ``` A lot of the time, the functions you write wont return anything, they just do something.

Hello Buddy, I am also very new to C++ so I may be wrong but ill give it a go from what i have learned so far. void means nothing, no value, no data, nothing. In certain functions we expect the code to return a value. E.g. int function (); ( we expect this to return int: an integer) or: bool fu…